transone-cli 0.1.2 → 0.2.0

package/dist/{build-mp-skmdzgyc.js → build-mp-kcnx989m.js}

@@ -6,7 +6,7 @@ import {
 // src/mp/build-mp.ts
 import { cp, mkdir, readdir, rm, writeFile } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { basename, dirname as dirname2, join as join2, relative, resolve as resolve2 } from "path";
+import { basename, dirname as dirname3, join as join3, relative, resolve as resolve2 } from "path";
 
 // src/mp/ts-loader.ts
 var tsModule = null;
@@ -371,43 +371,116 @@ function isComponentSubclass(context, classSource) {
   return false;
 }
 function resolveImportedClass(context, from, localName, binding) {
-  if (!binding.specifier.startsWith(".")) {
-    throw mpError(from.filePath, `\u65E0\u6CD5\u89E3\u6790\u7EC4\u4EF6\u6765\u6E90 "${binding.specifier}"\uFF08\u4EC5\u652F\u6301\u76F8\u5BF9\u8DEF\u5F84\u5BFC\u5165\u7684\u7EC4\u4EF6\uFF09`);
+  if (binding.specifier.startsWith(".")) {
+    const targetPath = resolveImportPath(from.filePath, binding.specifier);
+    if (!targetPath) {
+      throw mpError(from.filePath, `\u627E\u4E0D\u5230\u5BFC\u5165\u6587\u4EF6 "${binding.specifier}"\uFF08\u76F8\u5BF9 ${from.filePath}\uFF09`);
+    }
+    const source = readSource(context, targetPath);
+    const importedName = binding.importedName;
+    const found = findExportedClass(context, source, importedName, new Set);
+    if (!found) {
+      throw mpError(targetPath, `\u627E\u4E0D\u5230\u5BFC\u51FA\u7684\u7EC4\u4EF6\u7C7B "${importedName}"\uFF08\u4ECE ${localName} \u5BFC\u5165\uFF09`);
+    }
+    return {
+      filePath: found.filePath,
+      source: readSource(context, found.filePath),
+      declaration: found.declaration,
+      className: importedName
+    };
+  }
+  return resolvePackageClass(context, from, localName, binding);
+}
+function resolvePackageClass(context, from, localName, binding) {
+  const packageInfo = findPackageInfo(from.filePath, binding.specifier);
+  if (!packageInfo) {
+    throw mpError(from.filePath, `\u65E0\u6CD5\u89E3\u6790\u7EC4\u4EF6\u6765\u6E90 "${binding.specifier}"\uFF1A\u627E\u4E0D\u5230 node_modules \u5305\uFF08\u4EC5\u652F\u6301\u76F8\u5BF9\u8DEF\u5F84\u6216\u5DF2\u5B89\u88C5\u7684\u5305\uFF09`);
+  }
+  const sourceField = packageInfo.source;
+  if (typeof sourceField !== "string" || sourceField.length === 0) {
+    throw mpError(from.filePath, `\u5305 "${binding.specifier}" \u7F3A\u5C11 "source" \u5B57\u6BB5\uFF1A\u5C0F\u7A0B\u5E8F\u7F16\u8BD1\u9700\u8981\u53EF\u5206\u6790\u7684 TS \u6E90\u7801\u5165\u53E3\uFF08\u5728 package.json \u58F0\u660E "source": "./lib/index.ts"\uFF09`);
   }
-  const targetPath = resolveImportPath(from.filePath, binding.specifier);
+  const targetPath = resolvePackageSource(packageInfo.dir, sourceField);
   if (!targetPath) {
-    throw mpError(from.filePath, `\u627E\u4E0D\u5230\u5BFC\u5165\u6587\u4EF6 "${binding.specifier}"\uFF08\u76F8\u5BF9 ${from.filePath}\uFF09`);
+    throw mpError(from.filePath, `\u5305 "${binding.specifier}" \u7684 "source" \u6307\u5411\u7684\u6587\u4EF6\u4E0D\u5B58\u5728: ${sourceField}`);
   }
   const source = readSource(context, targetPath);
   const importedName = binding.importedName;
-  const declaration = findExportedClass(context, source, importedName);
-  if (!declaration) {
-    throw mpError(targetPath, `\u627E\u4E0D\u5230\u5BFC\u51FA\u7684\u7EC4\u4EF6\u7C7B "${importedName}"\uFF08\u4ECE ${localName} \u5BFC\u5165\uFF09`);
+  const found = findExportedClass(context, source, importedName, new Set);
+  if (!found) {
+    throw mpError(targetPath, `\u627E\u4E0D\u5230\u5BFC\u51FA\u7684\u7EC4\u4EF6\u7C7B "${importedName}"\uFF08\u4ECE ${localName} \u5BFC\u5165\uFF0C\u5305 "${binding.specifier}"\uFF09`);
   }
   return {
-    filePath: targetPath,
-    source,
-    declaration,
+    filePath: found.filePath,
+    source: readSource(context, found.filePath),
+    declaration: found.declaration,
     className: importedName
   };
 }
-function findExportedClass(context, source, name) {
+function findPackageInfo(fromFile, specifier) {
+  const segments = specifier.split("/");
+  const packageJsonRelative = join("node_modules", ...segments, "package.json");
+  let current = dirname(fromFile);
+  for (;; ) {
+    const candidate = join(current, packageJsonRelative);
+    if (existsSync(candidate)) {
+      try {
+        const json = JSON.parse(readFileSync(candidate, "utf8"));
+        return { dir: join(current, "node_modules", ...segments), source: json.source };
+      } catch {
+        return;
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return;
+    }
+    current = parent;
+  }
+}
+function resolvePackageSource(packageDir, sourceField) {
+  const base = resolve(packageDir, sourceField);
+  const candidates = [base, `${base}.ts`, `${base}.tsx`];
+  return candidates.find((candidate) => existsSync(candidate));
+}
+function findExportedClass(context, source, name, seen) {
   const { ts } = context;
+  if (seen.has(source.fileName)) {
+    return;
+  }
+  seen.add(source.fileName);
   for (const statement of source.statements) {
     if (ts.isClassDeclaration(statement) && statement.name?.text === name) {
       if (isExported(ts, statement)) {
-        return statement;
+        return { filePath: source.fileName, declaration: statement };
       }
     }
   }
   for (const statement of source.statements) {
     if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
       for (const element of statement.exportClause.elements) {
-        if (element.name.text === name) {
-          const local = collectLocalClasses(ts, source).get(name);
-          if (local) {
-            return local;
-          }
+        if (element.name.text !== name) {
+          continue;
+        }
+        const local = collectLocalClasses(ts, source).get(name);
+        if (local) {
+          return { filePath: source.fileName, declaration: local };
+        }
+        if (!statement.moduleSpecifier) {
+          continue;
+        }
+        const specifier = statement.moduleSpecifier.getText().replace(/['"]/g, "");
+        if (!specifier.startsWith(".")) {
+          continue;
+        }
+        const targetPath = resolveImportPath(source.fileName, specifier);
+        if (!targetPath) {
+          continue;
+        }
+        const targetSource = readSource(context, targetPath);
+        const reExported = findExportedClass(context, targetSource, element.propertyName?.text ?? element.name.text, seen);
+        if (reExported) {
+          return reExported;
         }
       }
     }
@@ -865,6 +938,9 @@ var TAG_KEYS = new Set([
   "key",
   "directions"
 ]);
+function notUndefined(ts, expression) {
+  return expression !== undefined && !(ts.isIdentifier(expression) && expression.text === "undefined");
+}
 function isEventProp(key) {
   return /^on[A-Z]/.test(key) || /^on[a-z]/.test(key);
 }
@@ -1027,8 +1103,8 @@ function compileElementCall(context, classSource, node, env, depth) {
     } else {
       propsExpr = args[1];
       childrenExpr = args[2];
-      listenersExpr = args[3];
-      directionsExpr = args[5];
+      listenersExpr = notUndefined(ts, args[3]) ? args[3] : undefined;
+      directionsExpr = notUndefined(ts, args[5]) ? args[5] : undefined;
     }
   } else {
     tagExpr = ts.factory.createStringLiteral(kebabCase(name));
@@ -1327,16 +1403,22 @@ function compileComponent(context, classSource, classExpr, propsExpr, childrenEx
       throw mpError(classSource.filePath, "emitters \u5FC5\u987B\u662F\u5BF9\u8C61\u5B57\u9762\u91CF");
     }
     for (const property of emittersExpr.properties) {
-      if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+      if (!ts.isPropertyAssignment(property)) {
+        throw mpError(classSource.filePath, "emitters \u53EA\u652F\u6301\u9759\u6001\u4E8B\u4EF6\u540D");
+      }
+      const eventName = ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) ? property.name.text : undefined;
+      if (eventName === undefined) {
         throw mpError(classSource.filePath, "emitters \u53EA\u652F\u6301\u9759\u6001\u4E8B\u4EF6\u540D");
       }
       const usage = compileEmitterHandler(context, classSource, property.initializer);
       if (!usage) {
         throw mpError(classSource.filePath, "emitters \u5904\u7406\u5668\u53EA\u652F\u6301 () => this.method() \u6216 (value) => this.method(value)");
       }
-      usage.event = property.name.text;
+      usage.event = eventName;
+      const key = `__transone_emitter_${eventName}_${env.builder.emitters.length}`;
+      usage.key = key;
       env.builder.emitters.push(usage);
-      attrs.push(`bind:${property.name.text}="__transone_emitter_${property.name.text}"`);
+      attrs.push(`bind:${eventName}="${key}"`);
     }
   }
   if (directionsExpr !== undefined) {
@@ -1403,7 +1485,7 @@ function compileEmitterHandler(context, _classSource, handlerExpr) {
   const { ts } = context;
   handlerExpr = unwrapParentheses(ts, handlerExpr);
   if (ts.isPropertyAccessExpression(handlerExpr) && isThisExpression(ts, handlerExpr.expression)) {
-    return { event: "pending", method: handlerExpr.name.text, passArgs: true };
+    return { event: "pending", method: handlerExpr.name.text, passArgs: true, key: "" };
   }
   if (!ts.isArrowFunction(handlerExpr)) {
     return;
@@ -1413,11 +1495,11 @@ function compileEmitterHandler(context, _classSource, handlerExpr) {
     return;
   }
   if (call.args.length === 0) {
-    return { event: "pending", method: call.method, passArgs: false };
+    return { event: "pending", method: call.method, passArgs: false, key: "" };
   }
   const arg = call.args.length === 1 ? unwrapTypeAssertions(ts, call.args[0]) : undefined;
   if (call.args.length === 1 && handlerExpr.parameters.length === 1 && ts.isIdentifier(handlerExpr.parameters[0].name) && arg !== undefined && ts.isIdentifier(arg) && handlerExpr.parameters[0].name.text === arg.text) {
-    return { event: "pending", method: call.method, passArgs: true };
+    return { event: "pending", method: call.method, passArgs: true, key: "" };
   }
   return;
 }
@@ -1503,13 +1585,37 @@ function compileStyleAttr(context, classSource, value, env) {
     }
     const cssKey = property.name.text.replace(/([A-Z])/g, "-$1").toLowerCase();
     const folded = foldExpression(ts, property.initializer, env.scope.consts);
-    if (typeof folded !== "string" && typeof folded !== "number") {
-      throw mpError(classSource.filePath, `style \u5C5E\u6027\u503C\u53EA\u652F\u6301\u9759\u6001\u5B57\u9762\u91CF: ${property.name.text}`);
+    if (typeof folded === "string" || typeof folded === "number") {
+      declarations.push(`${cssKey}: ${String(folded)};`);
+    } else {
+      const unitSplit = splitUnitExpression(ts, property.initializer);
+      if (unitSplit) {
+        declarations.push(`${cssKey}: {{${toBinding(bindingContext(context, classSource, env), unitSplit.expr)}}}${unitSplit.unit};`);
+      } else {
+        declarations.push(`${cssKey}: {{${toBinding(bindingContext(context, classSource, env), property.initializer)}}};`);
+      }
     }
-    declarations.push(`${cssKey}: ${String(folded)};`);
   }
   return `style="${escapeAttr(declarations.join(" "))}"`;
 }
+function splitUnitExpression(ts, expr) {
+  expr = unwrapParentheses(ts, expr);
+  if (!ts.isBinaryExpression(expr)) {
+    return;
+  }
+  if (expr.operatorToken.kind !== ts.SyntaxKind.PlusToken) {
+    return;
+  }
+  const right = unwrapParentheses(ts, expr.right);
+  if (!ts.isStringLiteral(right)) {
+    return;
+  }
+  const unit = right.text;
+  if (!/^[a-z%]+$/i.test(unit)) {
+    return;
+  }
+  return { expr: expr.left, unit };
+}
 function compileGenericAttr(context, classSource, key, value, env) {
   const { ts } = context;
   const attrName = wxmlAttrName(key);
@@ -2291,6 +2397,104 @@ function collectModuleConsts4(context, classSource) {
   return consts;
 }
 
+// src/mp/inline.ts
+import { dirname as dirname2, join as join2 } from "path";
+function collectInlineModules(context, classSource) {
+  const { ts } = context;
+  const output = [];
+  const seen = new Set;
+  const stack = new Set;
+  const walk = (source) => {
+    const filePath = source.fileName;
+    if (seen.has(filePath)) {
+      return;
+    }
+    for (const statement of source.statements) {
+      if (!ts.isImportDeclaration(statement)) {
+        continue;
+      }
+      const specifier = statement.moduleSpecifier;
+      if (!ts.isStringLiteral(specifier)) {
+        continue;
+      }
+      const target = resolveRelativeModule(context, filePath, specifier.text);
+      if (!target) {
+        continue;
+      }
+      if (stack.has(target)) {
+        warn(context, `\u6A21\u5757\u5FAA\u73AF\u5F15\u7528\u5DF2\u8DF3\u8FC7: ${target}`);
+        continue;
+      }
+      stack.add(target);
+      walk(readSource(context, target));
+      stack.delete(target);
+    }
+    seen.add(filePath);
+    output.push(compileInlineModule(context, source));
+  };
+  walk(classSource.source);
+  return output;
+}
+function resolveRelativeModule(context, fromFile, specifier) {
+  if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+    return null;
+  }
+  const base = specifier.endsWith(".ts") ? specifier : `${specifier}.ts`;
+  const resolved = join2(dirname2(fromFile), base);
+  if (isComponentFile(context, resolved)) {
+    return null;
+  }
+  return resolved;
+}
+function isComponentFile(context, filePath) {
+  const { ts } = context;
+  const source = readSource(context, filePath);
+  for (const statement of source.statements) {
+    if (!ts.isClassDeclaration(statement)) {
+      continue;
+    }
+    const name = statement.name?.text;
+    if (!name) {
+      continue;
+    }
+    const isExported2 = statement.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+    if (!isExported2) {
+      continue;
+    }
+    const heritage = statement.heritageClauses?.some((clause) => clause.types.some((type) => {
+      const expr = type.expression;
+      if (!ts.isIdentifier(expr)) {
+        return false;
+      }
+      return expr.text === "Component" || expr.text.endsWith("Component");
+    }));
+    if (heritage) {
+      return true;
+    }
+  }
+  return false;
+}
+function compileInlineModule(context, source) {
+  const { ts } = context;
+  const kept = [];
+  for (const statement of source.statements) {
+    if (ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement) || ts.isExportAssignment(statement) || ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) {
+      continue;
+    }
+    kept.push(statement);
+  }
+  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  const printed = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(kept), source);
+  const transpiled = ts.transpileModule(printed, {
+    compilerOptions: {
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ES2015
+    },
+    reportDiagnostics: false
+  });
+  return transpiled.outputText.replace(/^export\s+/gm, "").trim();
+}
+
 // src/mp/compile.ts
 function compileUnit(context, classSource, options) {
   const { kind, name } = options;
@@ -2313,10 +2517,11 @@ function compileUnit(context, classSource, options) {
       usedNames.add(emitter.method);
     }
     const customEvents = new Set;
+    const inlineModules = collectInlineModules(context, classSource);
     const compiledMethods = compileMethods(context, classSource, usedNames, kind, customEvents);
     const methods = [...compiledMethods.methods];
     for (const emitter of builder.emitters) {
-      const key = `__transone_emitter_${emitter.event}`;
+      const key = emitter.key ?? `__transone_emitter_${emitter.event}`;
       const fn = emitter.passArgs ? `function(e) { this.${emitter.method}(...e.detail.args); }` : `function() { this.${emitter.method}(); }`;
       methods.push({ key, fn });
     }
@@ -2337,7 +2542,8 @@ function compileUnit(context, classSource, options) {
       methods,
       lifecycle: compiledMethods.lifecycle,
       customEvents: [...customEvents],
-      usingComponents
+      usingComponents,
+      inlineModules
     };
     if (kind === "component") {
       context.components.set(name, unit);
@@ -2370,14 +2576,25 @@ function finalizeComponentProperties(context) {
 
 // src/mp/jsgen.ts
 var GENERATED_HEADER = (dialectId) => `// \u7531 transone build --target ${dialectId} \u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91`;
+function inlinePreamble(unit) {
+  if (unit.inlineModules.length === 0) {
+    return "";
+  }
+  return unit.inlineModules.join(`
+
+`) + `
+
+`;
+}
 function generatePageJs(unit, dialect) {
   const parts = [
     GENERATED_HEADER(dialect.id),
+    inlinePreamble(unit),
     "Page({",
     `  data: ${embedData(unit.data)},`
   ];
   for (const entry of [...unit.methods, ...unit.lifecycle]) {
-    parts.push(`  ${entry.key}: ${entry.fn},`);
+    parts.push(`  ${JSON.stringify(entry.key)}: ${entry.fn},`);
   }
   parts.push("});");
   return parts.join(`
@@ -2385,18 +2602,22 @@ function generatePageJs(unit, dialect) {
 `;
 }
 function generateComponentJs(unit, dialect) {
-  const parts = [GENERATED_HEADER(dialect.id), "Component({"];
+  const parts = [
+    GENERATED_HEADER(dialect.id),
+    inlinePreamble(unit),
+    "Component({"
+  ];
   parts.push(`  properties: ${generatePropertiesSource(unit.properties)},`);
   parts.push(`  data: ${embedData(unit.data)},`);
   parts.push("  methods: {");
   for (const entry of unit.methods) {
-    parts.push(`    ${entry.key}: ${entry.fn},`);
+    parts.push(`    ${JSON.stringify(entry.key)}: ${entry.fn},`);
   }
   parts.push("  },");
   if (unit.lifecycle.length > 0) {
     parts.push("  lifetimes: {");
     for (const entry of unit.lifecycle) {
-      parts.push(`    ${entry.key}: ${entry.fn},`);
+      parts.push(`    ${JSON.stringify(entry.key)}: ${entry.fn},`);
     }
     parts.push("  },");
   }
@@ -2462,8 +2683,8 @@ async function buildMiniProgram(config, dialect) {
   await mkdir(outDir, { recursive: true });
   const assetsBuilt = [];
   const write = async (path, content) => {
-    const target = join2(outDir, path);
-    await mkdir(dirname2(target), { recursive: true });
+    const target = join3(outDir, path);
+    await mkdir(dirname3(target), { recursive: true });
     await writeFile(target, content, "utf8");
     assetsBuilt.push(target);
   };
@@ -2520,9 +2741,9 @@ async function buildMiniProgram(config, dialect) {
   }
   if (existsSync2(mp.publicDir)) {
     for (const file of await listFiles(mp.publicDir)) {
-      const target = join2(outDir, file);
+      const target = join3(outDir, file);
       if (!existsSync2(target)) {
-        await cp(join2(mp.publicDir, file), target, {
+        await cp(join3(mp.publicDir, file), target, {
           recursive: true,
           force: true,
           errorOnExist: false
@@ -2557,7 +2778,7 @@ async function listFiles(root, dir = root) {
   const out = [];
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const abs = join2(dir, entry.name);
+    const abs = join3(dir, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listFiles(root, abs));
     } else {
@@ -2570,5 +2791,5 @@ export {
   buildMiniProgram
 };
 
-//# debugId=E7E46438C9491C1264756E2164756E21
-//# sourceMappingURL=build-mp-skmdzgyc.js.map
+//# debugId=1B46276CC3CBABAA64756E2164756E21
+//# sourceMappingURL=build-mp-kcnx989m.js.map