quasar

1
const path = require('node:path')
2
const { logError, writeFile, kebabCase } = require('./build.utils')
3

4
const { version } = require('../package.json')
5

6
const resolve = file => path.resolve(__dirname, '../dist/web-types', file)
7

8
function resolveType ({ type, values }) {
9
  // TODO transform Object with "values" and arrays Objects with values
10
  if (Array.isArray(type)) {
11
    return type.map(type => resolveType({ type })).join('|')
12
  }
13
  if (type === 'String' && values) {
14
    return values.map(v => (v === null ? 'null' : `'${ v }'`)).join('|')
15
  }
16
  if ([ 'Any', 'String', 'Boolean', 'Number', 'Object' ].includes(type)) {
17
    return type.toLowerCase()
18
  }
19
  if (type === 'Array') {
20
    return 'any[]'
21
  }
22
  return type
23
}
24

25
function getDescription (propApi) {
26
  return propApi.examples
27
    ? propApi.desc + '\n\nExamples:\n' + propApi.examples.join('\n')
28
    : propApi.desc
29
}
30

31
module.exports.generate = function ({ api, compact = false }) {
32
  const encodeFn = compact === true
33
    ? JSON.stringify
34
    : json => JSON.stringify(json, null, 2)
35

36
  try {
37
    const webtypes = encodeFn({
38
      $schema: '',
39
      framework: 'vue',
40
      name: 'quasar',
41
      version,
42
      contributions: {
43
        html: {
44
          'types-syntax': 'typescript',
45

46
          tags: api.components.map(({ api: { events, props, scopedSlots, slots, meta }, name }) => {
47
            const slotTypes = []
48
            if (slots) {
49
              Object.entries(slots).forEach(([ name, slotApi ]) => {
50
                slotTypes.push({
51
                  name,
52
                  description: getDescription(slotApi),
53
                  'doc-url': meta.docsUrl || 'https://v1.quasar.dev'
54
                })
55
              })
56
            }
57

58
            if (scopedSlots) {
59
              Object.entries(scopedSlots).forEach(([ name, slotApi ]) => {
60
                slotTypes.push({
61
                  name,
62
                  'vue-properties': slotApi.scope && Object.entries(slotApi.scope).map(([ name, api ]) => ({
63
                    name,
64
                    type: resolveType(api),
65
                    description: getDescription(api),
66
                    'doc-url': meta.docsUrl || 'https://v1.quasar.dev'
67
                  })),
68
                  description: getDescription(slotApi),
69
                  'doc-url': meta.docsUrl || 'https://v1.quasar.dev'
70
                })
71
              })
72
            }
73

74
            const result = {
75
              name,
76
              source: {
77
                module: 'quasar',
78
                symbol: name
79
              },
80
              attributes: props && Object.entries(props).map(([ name, propApi ]) => {
81
                const result = {
82
                  name,
83
                  value: {
84
                    kind: 'expression',
85
                    type: resolveType(propApi)
86
                  },
87
                  description: getDescription(propApi),
88
                  'doc-url': meta.docsUrl || 'https://v1.quasar.dev'
89
                }
90
                if (propApi.required) {
91
                  result.required = true
92
                }
93
                if (propApi.default) {
94
                  result.default = JSON.stringify(propApi.default)
95
                }
96
                if (propApi.type === 'Boolean') {
97
                  // Deprecated but used for compatibility with WebStorm 2019.2.
98
                  result.type = 'boolean'
99
                }
100
                return result
101
              }),
102
              events: events && Object.entries(events).map(([ name, eventApi ]) => ({
103
                name,
104
                arguments: eventApi.params && Object.entries(eventApi.params).map(([ paramName, paramApi ]) => ({
105
                  name: paramName,
106
                  type: resolveType(paramApi),
107
                  description: getDescription(paramApi),
108
                  'doc-url': meta.docsUrl || 'https://v1.quasar.dev'
109
                })),
110
                description: getDescription(eventApi),
111
                'doc-url': meta.docsUrl || 'https://v1.quasar.dev'
112
              })),
113
              slots: slotTypes,
114
              description: `${ name } - Quasar component`,
115
              'doc-url': meta.docsUrl || 'https://v1.quasar.dev'
116
            }
117
            if (props && props.value && ((events && events.input) || props.value.category === 'model')) {
118
              result[ 'vue-model' ] = {
119
                prop: 'value',
120
                event: 'input'
121
              }
122
            }
123
            Object.entries(result).forEach(([ key, v ]) => {
124
              if (!v) {
125
                delete result[ key ]
126
              }
127
            })
128

129
            return result
130
          }),
131

132
          attributes: api.directives.map(({ name, api: { modifiers, value, meta } }) => {
133
            const valueType = value.type
134
            const result = {
135
              name: 'v-' + kebabCase(name),
136
              source: {
137
                module: 'quasar',
138
                symbol: name
139
              },
140
              required: false, // Directive is never required
141
              description: `${ name } - Quasar directive`,
142
              'doc-url': meta.docsUrl || 'https://v1.quasar.dev'
143
            }
144
            if (modifiers) {
145
              result[ 'vue-modifiers' ] = Object.entries(modifiers).map(([ name, api ]) => ({
146
                name,
147
                description: getDescription(api),
148
                'doc-url': meta.docsUrl || 'https://v1.quasar.dev'
149
              }))
150
            }
151
            if (valueType !== 'Boolean') {
152
              result.value = {
153
                kind: 'expression',
154
                type: resolveType(value)
155
              }
156
            }
157
            return result
158
          })
159
        }
160
      }
161
    })
162

163
    writeFile(resolve('web-types.json'), webtypes)
164
  }
165
  catch (err) {
166
    logError('build.web-types.js: something went wrong...')
167
    console.log()
168
    console.error(err)
169
    console.log()
170
    process.exit(1)
171
  }
172
}
173