@tarojs/plugin-platform-h5 3.7.0-alpha.2 → 3.7.0-alpha.22

package/build/definition-json/index.ts

@@ -0,0 +1,3 @@
+import { parseDefinitionJSON } from './parser'
+
+parseDefinitionJSON()

package/build/definition-json/parser.ts

@@ -0,0 +1,112 @@
+import { fs } from '@tarojs/helper'
+import { paramCase } from 'change-case'
+import ts from 'typescript'
+
+import { generateDocumentation } from '../utils/ast'
+
+import type { DocEntry } from '../utils/ast'
+
+const tsconfig: ts.CompilerOptions = {
+  target: ts.ScriptTarget.ES5,
+  module: ts.ModuleKind.NodeNext,
+  moduleResolution: ts.ModuleResolutionKind.NodeNext,
+  noResolve: false,
+  paths: {
+    '@tarojs/api': ['node_modules/@tarojs/taro/types']
+  },
+  'types': ['@tarojs/taro-h5/types']
+}
+const CompRGX = /^Taro(.*)Core$/
+const IgnoreSymbols = [
+  ts.SymbolFlags.Interface,
+  ts.SymbolFlags.TypeLiteral,
+  ts.SymbolFlags.TypeAlias,
+]
+
+export function parseComponents (docTree: DocEntry[]) {
+  // ${component}.${attribute}.${option}
+  return docTree.reduce((p, e) => {
+    let { name = '', members = [] } = e
+    if (CompRGX.test(name)) {
+      name = paramCase(name.replace(CompRGX, '$1'))
+      p[name] = members.reduce((p2, e2) => {
+        p2[e2.name ?? ''] = parseComponentAttribute(e2)
+
+        return p2
+      }, {})
+    }
+    return p
+  }, {})
+}
+
+export function parseAPIs (docTree: DocEntry[]) {
+  // ${API}.${method}.${param}.${option}
+  return docTree.reduce((p, e) => {
+    if (!IgnoreSymbols.includes(e.flags!)) {
+      p[e.name ?? ''] = parseAPIMethod(e)
+    }
+
+    return p
+  }, {})
+}
+
+const anyTypes = ['any', 'TaroStatic', '{}', 'IAnyObject', 'T']
+const voidTypes = ['', 'void', 'null', 'undefined']
+const anyStr = '*'
+const voidStr = 'void'
+export function parseComponentAttribute (e: DocEntry) {
+  return parseAnyOrVoid(e.type, e.type)
+}
+
+export function parseAPIMethod (e: DocEntry) {
+  const o: Record<string, any> = {}
+  const { type = 'any', flags = ts.SymbolFlags.None, declarations = [] } = e
+  if (anyTypes.includes(type)) {
+    return anyStr
+  } else if (flags === ts.SymbolFlags.BlockScopedVariable && declarations.length > 0) {
+    const [declaration = {}] = declarations
+    const { parameters = [], returnType = '' } = declaration
+    const [parameter] = parameters
+    const isCallback = parameter?.name === 'callback'
+    // console.log('parseAPIMethod', e.name, parameters)
+    if (isCallback) {
+      const [callback] = parameter?.declarations || []
+      const obj = callback?.parameters?.[0] || {}
+      // FIXME parse callback ${param}.${option}
+      o.callback = parseAnyOrVoid(obj?.type)
+    } else {
+      // FIXME parse parameter ${param}.${option}
+      o.object = parseAnyOrVoid(parameter?.type)
+      // FIXME parse successCallback ${param}.${option}
+      o.success = voidStr
+    }
+    // FIXME parse returnType ${param}.${option}
+    const returnValue = parseAnyOrVoid(returnType)
+    if (returnValue !== voidStr) {
+      o.return = returnValue
+    }
+  }
+  return o
+}
+
+export function parseAnyOrVoid (str = '', obj: unknown = str) {
+  return anyTypes.includes(str) ? anyStr : voidTypes.includes(str) ? voidStr : obj || str
+}
+
+export function parseDefinitionJSON ({
+  apisPath = require.resolve('@tarojs/taro-h5/dist/index.esm.d.ts'),
+  componentsPath = require.resolve('@tarojs/components/dist/types/components.d.ts'),
+} = {},
+config: ts.CompilerOptions = tsconfig,
+) {
+  const apis = parseAPIs(generateDocumentation([apisPath], config))
+  const Components = generateDocumentation([componentsPath], config).find(e => e.name === 'Components')?.children || []
+  const components = parseComponents(Components)
+
+  // Note: 写入文件
+  fs.ensureDirSync('dist')
+  fs.writeJSONSync('dist/definition.json', {
+    apis,
+    components,
+  }, { spaces: 2 })
+}

package/build/rollup-plugin-export-name-only.js

@@ -0,0 +1,16 @@
+export default function exportNameOnly () {
+  const emptyMap = { mappings: '' }
+  return {
+    name: 'export-name-only',
+    renderChunk (code, chunk) {
+      const pos = chunk.exports.indexOf('default')
+      if (pos > -1) {
+        chunk.exports.splice(pos, 1)
+      }
+      return {
+        code: `module.exports = new Set(${JSON.stringify(chunk.exports)})`,
+        map: emptyMap
+      }
+    }
+  }
+}

package/build/utils/ast.ts

@@ -0,0 +1,182 @@
+import * as path from 'path'
+import ts from 'typescript'
+
+export interface DocEntry {
+  name?: string
+  kind?: ts.SyntaxKind
+  flags?: ts.SymbolFlags
+  fileName?: string
+  type?: string
+  constructors?: DocEntry[]
+  parameters?: DocEntry[]
+  returnType?: string
+  members?: DocEntry[]
+  exports?: DocEntry[]
+  children?: DocEntry[]
+  declarations?: DocEntry[]
+  symbol?: DocEntry
+}
+
+export function pathsAreEqual (path1: string, path2: string) {
+  path1 = path.resolve(path1)
+  path2 = path.resolve(path2)
+  if (process.platform === 'win32') {
+    return path1.toLowerCase() === path2.toLowerCase()
+  }
+  return path1 === path2
+}
+
+export function generateDocumentation (
+  filepaths: string[],
+  options: ts.CompilerOptions,
+  param: {
+    mapAll?: boolean
+    withDeclaration?: boolean
+  } = {},
+  output: DocEntry[] = []
+): DocEntry[] {
+  const program = ts.createProgram(filepaths, options)
+  const checker = program.getTypeChecker()
+
+  for (const sourceFile of program.getSourceFiles()) {
+    if (param.withDeclaration !== false || !sourceFile.isDeclarationFile) {
+      if (
+        (param.mapAll === true && filepaths.includes(sourceFile.fileName))
+        || pathsAreEqual(sourceFile.fileName, filepaths[0])
+      ) {
+        ts.forEachChild(sourceFile, (n) => visitAST(n, output))
+      }
+    }
+  }
+
+  return output
+
+  function visitAST (node: ts.Node, o: DocEntry[]) {
+    // Only consider exported nodes
+    if (!isNodeExported(node as ts.Declaration) || node.kind === ts.SyntaxKind.EndOfFileToken || node.kind === ts.SyntaxKind.DeclareKeyword
+        || ts.isImportDeclaration(node) || ts.isImportEqualsDeclaration(node) || ts.isImportClause(node)
+        || ts.isExportAssignment(node) || ts.isExportDeclaration(node)
+        || ts.isExpressionStatement(node) || ts.isEmptyStatement(node)
+        || ts.isStringLiteral(node)
+        || node.kind === ts.SyntaxKind.ExportKeyword) {
+      return
+    }
+
+    if (ts.isVariableDeclaration(node) || ts.isClassDeclaration(node) && node.name) {
+      const symbol = checker.getSymbolAtLocation(node)
+      symbol && o.push(serializeClass(symbol))
+    } else if (ts.isFunctionDeclaration(node)) {
+      const signature = checker.getSignatureFromDeclaration(node)
+      signature && o.push(serializeSignature(signature, node.name && ts.idText(node.name)))
+    } else if (ts.isInterfaceDeclaration(node)) {
+      const symbol = checker.getTypeAtLocation(node).getSymbol()
+      symbol && o.push(serializeType(symbol, undefined, 'InterfaceDeclaration'))
+    } else if (ts.isTypeAliasDeclaration(node)) {
+      const type = checker.getTypeAtLocation(node)
+      const symbol = type.getSymbol()
+      if (symbol) {
+        const st = serializeType(symbol, ts.idText(node.name))
+        o.push(st)
+      } else {
+        // @ts-ignore
+        const sym = node.symbol; const type = node.type?.types?.map(e => checker.typeToString(checker.getTypeFromTypeNode(e))).join(' | ')
+        o.push(
+          serializeSymbol(sym, sym.getName(), type)
+        )
+      }
+    } else if (ts.isEnumDeclaration(node)) {
+      const symbol = checker.getTypeAtLocation(node).getSymbol()
+      symbol && o.push(serializeType(symbol))
+    } else if (ts.isIdentifier(node)) {
+      const symbol = checker.getTypeAtLocation(node).getSymbol()
+      symbol && o.push(serializeType(symbol))
+    } else if (ts.isModuleDeclaration(node) || ts.isVariableStatement(node)) {
+      // This is a namespace, visitAST its children
+      ts.forEachChild(node, (n) => visitAST(n, o))
+    } else if (ts.isModuleBlock(node)) {
+      // This is a namespace, visitAST its children
+      const out: DocEntry = {
+        name: ts.isIdentifier(node.parent.name) ? ts.idText(node.parent.name) : '',
+        kind: node.kind,
+        children: []
+      }
+      ts.forEachChild(node, (n) => visitAST(n, out.children!))
+      o.push(out)
+    } else if (ts.isVariableDeclarationList(node)) {
+      node.declarations.forEach(d => {
+        // @ts-ignore
+        const symbol = d.symbol // checker.getSymbolsInScope(d, d.symbol.flags)
+        symbol && o.push(serializeType(symbol))
+      })
+    } else {
+      console.warn(`WARN: Statement kind ${node.kind} is missing parse!\n\n${node.getText()}\n\n`)
+    }
+  }
+
+  /** Serialize a symbol into a json object */
+  function serializeSymbol (symbol: ts.Symbol, name?: string, type?: string): DocEntry {
+    const declarations: DocEntry[] = [];
+    (symbol.getDeclarations() || []).map(
+      d => checker.getSignaturesOfType(checker.getTypeAtLocation(d), ts.SignatureKind.Call).map(
+        e => declarations.push(serializeSignature(e))
+      )
+    )
+
+    return {
+      name: name || symbol.getName(),
+      flags: symbol.flags,
+      type: type || checker.typeToString(
+        checker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration!)
+      ),
+      declarations
+    }
+  }
+
+  /** Serialize a class symbol information */
+  function serializeClass (symbol: ts.Symbol) {
+    const details = serializeSymbol(symbol)
+    // Get the construct signatures
+    const constructorType = checker.getTypeOfSymbolAtLocation(
+      symbol,
+      symbol.valueDeclaration!
+    )
+    const signatures = constructorType.getConstructSignatures()
+    details.constructors = signatures.map(n => serializeSignature(n))
+    return details
+  }
+
+  /** Serialize a types (type or interface) symbol information */
+  function serializeType (symbol: ts.Symbol, name?: string, type?: keyof typeof ts.SyntaxKind): DocEntry {
+    // console.log(type, Object.keys(symbol))
+    const doc: DocEntry = serializeSymbol(symbol, name, type)
+    symbol.exports && symbol.exports.forEach((value) => {
+      if (!doc.exports) doc.exports = []
+      doc.exports.push(serializeSymbol(value))
+    })
+    symbol.members && symbol.members.forEach((value) => {
+      if (!doc.members) doc.members = []
+      doc.members.push(serializeSymbol(value))
+    })
+    return doc
+  }
+
+  /** Serialize a signature (call or construct) */
+  function serializeSignature (signature: ts.Signature, name?: string) {
+    const typeParameters = signature.getTypeParameters() || []
+
+    return {
+      name,
+      parameters: signature.getParameters().map((e, i) =>
+        serializeSymbol(e, undefined, typeParameters[i] && checker.typeToString(typeParameters[i]))),
+      returnType: checker.typeToString(signature.getReturnType())
+    }
+  }
+
+  /** True if this is visible outside this file, false otherwise */
+  function isNodeExported (node: ts.Declaration): boolean {
+    return (
+      (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0 ||
+      (!!node.parent/*  && node.parent.kind === ts.SyntaxKind.SourceFile */)
+    )
+  }
+}

package/build/utils/helper.ts

@@ -0,0 +1,56 @@
+import ts from 'typescript'
+
+const SymbolFlags = Object.values(ts.SymbolFlags)
+
+export function splicing (arr: (string | undefined)[] = [], lf = '\n') {
+  return arr.filter(e => typeof e === 'string').join(lf)
+}
+
+export function parseLineFeed (s?: string, isCode = false) {
+  if (!s) return ''
+  const r = s.split('|').join('or').split('\n').join('<br />')
+  return isCode && !s.includes('|') ? `\`${r}\`` : r
+}
+
+export function isShowMembers (flags?: ts.SymbolFlags, used: ts.SymbolFlags[] = []) {
+  return [
+    ts.SymbolFlags.EnumMember,
+    ts.SymbolFlags.Function,
+    ts.SymbolFlags.Class,
+    ts.SymbolFlags.Interface,
+    ts.SymbolFlags.ValueModule,
+    ts.SymbolFlags.NamespaceModule,
+    ts.SymbolFlags.TypeLiteral,
+    ts.SymbolFlags.Method,
+    ts.SymbolFlags.TypeAlias,
+  ].some(v => {
+    const e = (flags || -1) - v
+    return e > -1 && !used.includes(v) && (e === 0 || isShowMembers(e, [...used, v]))
+  })
+}
+
+export function isShowAPI (flags?: ts.SymbolFlags): flags is ts.SymbolFlags.Property | ts.SymbolFlags.Method {
+  return [
+    ts.SymbolFlags.Property,
+    ts.SymbolFlags.Method,
+    ts.SymbolFlags.Optional + ts.SymbolFlags.Property,
+    ts.SymbolFlags.Optional + ts.SymbolFlags.Method,
+  ].includes(flags || -1)
+}
+
+export function isNotAPI (flags?: ts.SymbolFlags): flags is ts.SymbolFlags.Signature | ts.SymbolFlags.TypeParameter {
+  return [
+    -1,
+    ts.SymbolFlags.Signature,
+    ts.SymbolFlags.TypeParameter,
+  ].includes(flags || -1)
+}
+
+export function isFunction (flags?: ts.SymbolFlags): flags is ts.SymbolFlags.Function | ts.SymbolFlags.Method {
+  return SymbolFlags.includes((flags || -1) - ts.SymbolFlags.Function)
+    || SymbolFlags.includes((flags || -1) - ts.SymbolFlags.Method)
+}
+
+export function isOptional (flags?: ts.SymbolFlags): flags is ts.SymbolFlags.Optional {
+  return SymbolFlags.includes((flags || -1) - ts.SymbolFlags.Optional)
+}

package/build/utils/parser.ts

@@ -0,0 +1,43 @@
+import { isFunction } from './helper'
+
+import type { DocEntry } from './ast'
+
+export async function childrenMerge (d: DocEntry[] = [], o: DocEntry[] = []) {
+  for (const e of d) {
+    const name = e.name || 'undefined'
+    if (!o.find(v => v.name === name)) o.push(e)
+    const target = o.find(v => v.name === name) || {}
+    for (const key in e) {
+      if (e.hasOwnProperty(key) && e[key] && !['name', 'kind'].includes(key)) {
+        if (key === 'flags') {
+          if (!target.flags || !isFunction(e.flags)) target.flags = e.flags
+        } else if (key === 'children') {
+          target.children = await childrenMerge(e.children, target.children)
+        } else if (key === 'exports') {
+          target.exports = await childrenMerge(e.exports, target.exports)
+          target[key] = e[key] || target[key]
+        }
+      }
+    }
+  }
+
+  return o.map(e => {
+    if (e.children) {
+      if (!e.exports) e.exports = []
+      for (const k of e.children) {
+        const kk = e.exports!.find(kk => kk.name === k.name)
+        if (!kk) {
+          e.exports!.push(k)
+        } else {
+          for (const key in k) {
+            if (k.hasOwnProperty(key) && !kk[key]) {
+              kk[key] = k[key]
+            }
+          }
+        }
+      }
+      delete e.children
+    }
+    return e
+  })
+}