transone-cli 0.3.0 → 0.4.0

package/dist/{index-40bkmdrf.js → index-m455xjw2.js}

@@ -1,4 +1,7 @@
 // @bun
+import {
+  loadTypescript
+} from "./index-k1qfvp0y.js";
 import {
   __require
 } from "./index-yb2wsc7f.js";
@@ -9,6 +12,7 @@ var TARGET_TYPES = [
   "mp-weixin",
   "mp-alipay",
   "mp-bytedance",
+  "mp-xiaohongshu",
   "app-ios",
   "app-android",
   "app-harmony"
@@ -19,8 +23,17 @@ function isTargetType(value) {
 var MP_TARGET_TYPES = [
   "mp-weixin",
   "mp-alipay",
-  "mp-bytedance"
+  "mp-bytedance",
+  "mp-xiaohongshu"
+];
+var APP_TARGET_TYPES = [
+  "app-ios",
+  "app-android",
+  "app-harmony"
 ];
+function isAppTargetType(value) {
+  return typeof value === "string" && APP_TARGET_TYPES.includes(value);
+}
 function isMpTargetType(value) {
   return typeof value === "string" && MP_TARGET_TYPES.includes(value);
 }
@@ -72,7 +85,8 @@ async function resolveConfig(options = {}) {
     includeEntry: false,
     allowRoot: true
   }) : pages;
-  const mpEnabled = config.mp !== undefined || target === "mp-weixin";
+  const mpEnabled = config.mp !== undefined || isMpTargetType(target);
+  const appConfig = pickAppConfig(config.app, target);
   return {
     root,
     ...loadedConfig.exists ? { configFile } : {},
@@ -92,13 +106,40 @@ async function resolveConfig(options = {}) {
     ...config.library ? { library: resolveLibrary(root, config.library) } : {},
     ...mpEnabled ? {
       mp: resolveMiniProgram(root, options.mpOutDir, mpConfig ?? {}, mpPages, target)
-    } : {}
+    } : {},
+    ...isAppTargetType(target) ? { app: await resolveApp(root, options.outDir, appConfig ?? {}, target, pages) } : {}
+  };
+}
+function isAppConfigMap(value) {
+  return isRecord(value) && APP_TARGET_TYPES.some((platform) => (platform in value));
+}
+function pickAppConfig(app, target) {
+  if (app === undefined) {
+    return;
+  }
+  if (isAppConfigMap(app)) {
+    return isAppTargetType(target) ? app[target] : undefined;
+  }
+  return app;
+}
+async function resolveApp(root, outDirOverride, app, target, fallbackPages) {
+  return {
+    appName: app.appName ?? "TransOne",
+    bundleId: app.bundleId ?? "com.transone.app",
+    outDir: resolve(root, outDirOverride ?? app.outDir ?? `dist/build/${target}`),
+    minPlatformVersion: app.minPlatformVersion ?? "16.0",
+    publicDir: resolve(root, app.publicDir ?? "public"),
+    pages: app.pages ? await resolvePages(root, resolve(root, app.pages["/"] ?? "src/main.ts"), app.pages, {
+      includeEntry: false,
+      allowRoot: true
+    }) : fallbackPages
   };
 }
 var MP_DEFAULT_OUT_DIRS = {
   "mp-weixin": "dist/build/mp-weixin",
   "mp-alipay": "dist/build/mp-alipay",
-  "mp-bytedance": "dist/build/mp-bytedance"
+  "mp-bytedance": "dist/build/mp-bytedance",
+  "mp-xiaohongshu": "dist/build/mp-xiaohongshu"
 };
 function isMpConfigMap(value) {
   return isRecord(value) && MP_TARGET_TYPES.some((platform) => (platform in value));
@@ -154,7 +195,7 @@ function resolveTarget(target) {
   if (isTargetType(target)) {
     return target;
   }
-  throw new Error(`Unknown build target "${String(target)}". ` + "Available targets: web, mp-weixin, mp-alipay, mp-bytedance, " + "app-ios, app-android, app-harmony.");
+  throw new Error(`Unknown build target "${String(target)}". ` + "Available targets: web, mp-weixin, mp-alipay, mp-bytedance, mp-xiaohongshu, " + "app-ios, app-android, app-harmony.");
 }
 async function resolvePages(root, entry, pages, options = {}) {
   const resolved = options.includeEntry === false ? {} : { "/": entry };
@@ -231,7 +272,8 @@ function mergeConfig(...configs) {
         directoryPages: build?.directoryPages ?? merged.build.directoryPages
       },
       library: config.library ?? merged.library,
-      mp: config.mp ?? merged.mp
+      mp: config.mp ?? merged.mp,
+      app: config.app ?? merged.app
     };
   }, DEFAULT_CONFIG);
 }
@@ -255,6 +297,36 @@ function validateUserConfig(config) {
   if (config.mp !== undefined) {
     validateMpConfig(config.mp);
   }
+  if (config.app !== undefined) {
+    validateAppConfig(config.app);
+  }
+}
+function validateAppConfig(app) {
+  assertRecord(app, "Config app");
+  if (isAppConfigMap(app)) {
+    const flatKeys = ["appName", "bundleId", "outDir", "minPlatformVersion", "publicDir", "pages"];
+    if (flatKeys.some((key) => (key in app))) {
+      throw new Error("Config app cannot mix flat fields with platform keys");
+    }
+    for (const platform of APP_TARGET_TYPES) {
+      if (app[platform] !== undefined) {
+        validateSingleAppConfig(app[platform], `Config app.${platform}`);
+      }
+    }
+    return;
+  }
+  validateSingleAppConfig(app, "Config app");
+}
+function validateSingleAppConfig(app, label) {
+  assertRecord(app, label);
+  for (const key of ["appName", "bundleId", "outDir", "minPlatformVersion", "publicDir"]) {
+    if (app[key] !== undefined && typeof app[key] !== "string") {
+      throw new Error(`${label}.${key} must be a string`);
+    }
+  }
+  if (app.pages !== undefined) {
+    validatePagesConfig(app.pages, `${label}.pages`);
+  }
 }
 function validateMpConfig(mp) {
   assertRecord(mp, "Config mp");
@@ -707,6 +779,35 @@ var MP_BYTEDANCE_DIALECT = {
     usingComponents
   })
 };
+var MP_XIAOHONGSHU_DIALECT = {
+  id: "mp-xiaohongshu",
+  label: "\u5C0F\u7EA2\u4E66\u5C0F\u7A0B\u5E8F\u539F\u751F\u5DE5\u7A0B\uFF08XHSML / CSS / JS \u9759\u6001\u8F6C\u6362\uFF09",
+  templateExt: "xhsml",
+  styleExt: "css",
+  appStyleFile: "app.css",
+  directivePrefix: "xhs:",
+  bindEvent: (event) => `bind${event}`,
+  catchEvent: (event) => `catch${event}`,
+  projectConfigFile: "project.config.json",
+  buildProjectConfig: (mp, projectName) => ({
+    appid: mp.appId,
+    projectname: projectName,
+    compileType: "miniprogram"
+  }),
+  windowDefaults: (title) => ({
+    navigationBarTitleText: title,
+    navigationBarBackgroundColor: "#ffffff",
+    navigationBarTextStyle: "black",
+    backgroundTextStyle: "light"
+  }),
+  appJsonExtras: () => ({}),
+  sitemap: false,
+  componentJson: (usingComponents) => ({
+    component: true,
+    multipleSlots: true,
+    usingComponents
+  })
+};
 
 // src/target/mp-target.ts
 class MpTarget {
@@ -724,30 +825,428 @@ class MpTarget {
     if (!config.mp) {
       throw new Error("Mini program build requires config.mp\uFF08\u8BF7\u5728 transone.config.ts \u914D\u7F6E mp \u5B57\u6BB5\uFF0C" + "\u5982 appId / pages / outDir\uFF09");
     }
-    const { buildMiniProgram } = await import("./build-mp-kcnx989m.js");
+    const { buildMiniProgram } = await import("./build-mp-6j38wf4r.js");
     return buildMiniProgram(config, this.dialect);
   }
 }
 var mpWeixinTarget = new MpTarget(MP_WEIXIN_DIALECT);
 var mpAlipayTarget = new MpTarget(MP_ALIPAY_DIALECT);
 var mpBytedanceTarget = new MpTarget(MP_BYTEDANCE_DIALECT);
+var mpXiaohongshuTarget = new MpTarget(MP_XIAOHONGSHU_DIALECT);
 
-// src/target/placeholder-target.ts
-class PlaceholderTarget {
-  type;
-  label;
-  plannedMilestone;
-  constructor(type, label, plannedMilestone) {
-    this.type = type;
-    this.label = label;
-    this.plannedMilestone = plannedMilestone;
+// src/app/build-app.ts
+import { cp, mkdir as mkdir2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname3, join, resolve as resolve4 } from "path";
+
+// src/app/errors.ts
+import { basename } from "path";
+function nativeError(filePath, message) {
+  return new Error(`[transone app] ${basename(filePath)}: ${message}`);
+}
+
+// src/app/analyze.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+var CONTAINERS = new Set(["view", "main", "div"]);
+var TEXT = new Set(["text", "span", "p", "h1"]);
+var STYLE_KEYS = new Set(["color", "backgroundColor", "fontSize", "fontWeight", "padding", "margin", "width", "height", "borderRadius", "textAlign"]);
+async function analyzeNativeScreen(entry) {
+  if (!existsSync2(entry))
+    throw nativeError(entry, "\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728");
+  const ts = await loadTypescript();
+  const source = ts.createSourceFile(entry, readFileSync(entry, "utf8"), ts.ScriptTarget.Latest, true);
+  const component = source.statements.find((s) => ts.isClassDeclaration(s));
+  if (!component)
+    throw nativeError(entry, "\u672A\u627E\u5230 Component \u7C7B");
+  const state = readState(ts, component, entry);
+  const actions = new Map;
+  for (const member of component.members)
+    if (ts.isMethodDeclaration(member) && ts.isIdentifier(member.name)) {
+      const action = readAction(ts, member, entry);
+      if (action)
+        actions.set(member.name.text, action);
+    }
+  const render = component.members.find((m) => ts.isMethodDeclaration(m) && m.name.getText(source) === "render");
+  const value = render?.body?.statements.find(ts.isReturnStatement)?.expression;
+  if (!value || !ts.isObjectLiteralExpression(value))
+    throw nativeError(entry, "render() \u5FC5\u987B\u8FD4\u56DE\u9759\u6001 VNode \u5BF9\u8C61");
+  const root = readNode(ts, value, entry, new Set(state.map((item) => item.key)), actions);
+  if (root.kind !== "container")
+    throw nativeError(entry, "\u6839\u8282\u70B9\u5FC5\u987B\u662F\u5BB9\u5668\u8282\u70B9");
+  return { name: component.name?.text ?? "App", state, root };
+}
+function readState(ts, component, file) {
+  const method = component.members.find((m) => ts.isMethodDeclaration(m) && m.name.getText() === "initState");
+  const value = method?.body?.statements.find(ts.isReturnStatement)?.expression;
+  if (!value)
+    return [];
+  if (!ts.isObjectLiteralExpression(value))
+    throw nativeError(file, "initState() \u5FC5\u987B\u8FD4\u56DE\u5BF9\u8C61\u5B57\u9762\u91CF");
+  return value.properties.map((item) => {
+    if (!ts.isPropertyAssignment(item) || !ts.isIdentifier(item.name))
+      throw nativeError(file, "state \u5FC5\u987B\u4F7F\u7528\u6807\u8BC6\u7B26\u5C5E\u6027");
+    const literal = literalValue(ts, item.initializer);
+    if (literal === undefined)
+      throw nativeError(file, `state.${item.name.text} \u5FC5\u987B\u662F\u5B57\u9762\u91CF`);
+    return { key: item.name.text, value: literal };
+  });
+}
+function readAction(ts, method, file) {
+  const expression = method.body?.statements[0];
+  if (!expression || !ts.isExpressionStatement(expression) || !ts.isBinaryExpression(expression.expression))
+    return;
+  const binary = expression.expression;
+  if (!ts.isPropertyAccessExpression(binary.left) || !ts.isPropertyAccessExpression(binary.left.expression) || binary.left.expression.expression.kind !== ts.SyntaxKind.ThisKeyword || binary.left.expression.name.text !== "state")
+    return;
+  const value = literalValue(ts, binary.right);
+  const key = binary.left.name.text;
+  if ((binary.operatorToken.kind === ts.SyntaxKind.PlusEqualsToken || binary.operatorToken.kind === ts.SyntaxKind.MinusEqualsToken) && typeof value === "number")
+    return { kind: "increment", key, by: binary.operatorToken.kind === ts.SyntaxKind.MinusEqualsToken ? -value : value };
+  if (binary.operatorToken.kind === ts.SyntaxKind.EqualsToken && value !== undefined)
+    return { kind: "set-literal", key, value };
+  throw nativeError(file, `\u65B9\u6CD5 ${method.name.getText()} \u4E0D\u652F\u6301\u539F\u751F\u7F16\u8BD1`);
+}
+function readNode(ts, node, file, state, actions) {
+  const tag = stringValue(ts, get(ts, node, "tag"), file, "VNode tag");
+  const style = readStyle(ts, get(ts, node, "props"), file);
+  const children = get(ts, node, "children");
+  const childNodes = children && ts.isArrayLiteralExpression(children) ? [...children.elements].filter(ts.isExpression) : [];
+  if (CONTAINERS.has(tag))
+    return { kind: "container", children: childNodes.map((child) => {
+      if (!ts.isObjectLiteralExpression(child))
+        throw nativeError(file, "\u5BB9\u5668 children \u53EA\u652F\u6301\u9759\u6001 VNode");
+      return readNode(ts, child, file, state, actions);
+    }), ...style ? { style } : {} };
+  const parts = childNodes.flatMap((child) => readText(ts, child, file, state));
+  if (TEXT.has(tag))
+    return { kind: "text", parts, ...style ? { style } : {} };
+  if (tag === "button")
+    return { kind: "button", parts, action: readClick(ts, get(ts, node, "listeners"), file, actions), ...style ? { style } : {} };
+  throw nativeError(file, `\u4E0D\u652F\u6301\u7684\u539F\u751F\u8282\u70B9: ${tag}`);
+}
+function readText(ts, expression, file, state) {
+  const value = literalValue(ts, expression);
+  if (typeof value !== "string")
+    throw nativeError(file, "\u6587\u672C children \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u5B57\u9762\u91CF");
+  const result = [];
+  const matcher = /{{([^}]+)}}/g;
+  let cursor = 0;
+  let match;
+  while (match = matcher.exec(value)) {
+    if (match.index > cursor)
+      result.push({ kind: "literal", value: value.slice(cursor, match.index) });
+    const key = match[1];
+    if (!/^[A-Za-z_$][\w$]*$/.test(key) || !state.has(key))
+      throw nativeError(file, "\u53EA\u652F\u6301\u5DF2\u58F0\u660E state \u7684 {{key}} \u7ED1\u5B9A");
+    result.push({ kind: "state", key });
+    cursor = matcher.lastIndex;
+  }
+  if (cursor < value.length || result.length === 0)
+    result.push({ kind: "literal", value: value.slice(cursor) });
+  return result;
+}
+function readClick(ts, listeners, file, actions) {
+  if (!listeners || !ts.isObjectLiteralExpression(listeners))
+    throw nativeError(file, "button \u5FC5\u987B\u58F0\u660E listeners.click");
+  const handler = get(ts, listeners, "click");
+  const body = handler && ts.isArrowFunction(handler) ? handler.body : undefined;
+  const expression = body && ts.isCallExpression(body) ? body : body && ts.isBlock(body) && ts.isExpressionStatement(body.statements[0]) ? body.statements[0].expression : undefined;
+  if (!expression || !ts.isCallExpression(expression) || !ts.isPropertyAccessExpression(expression.expression) || expression.expression.expression.kind !== ts.SyntaxKind.ThisKeyword)
+    throw nativeError(file, "click \u53EA\u652F\u6301\u8C03\u7528 this.method()");
+  const action = actions.get(expression.expression.name.text);
+  if (!action)
+    throw nativeError(file, `click \u65B9\u6CD5 ${expression.expression.name.text} \u4E0D\u652F\u6301\u539F\u751F\u7F16\u8BD1`);
+  return action;
+}
+function readStyle(ts, props, file) {
+  if (!props || !ts.isObjectLiteralExpression(props))
+    return;
+  const style = get(ts, props, "style");
+  if (!style || !ts.isObjectLiteralExpression(style))
+    return;
+  const out = {};
+  for (const item of style.properties) {
+    if (!ts.isPropertyAssignment(item) || !ts.isIdentifier(item.name) || !STYLE_KEYS.has(item.name.text))
+      throw nativeError(file, "\u4E0D\u652F\u6301\u7684\u539F\u751F\u6837\u5F0F\u5C5E\u6027");
+    const value = literalValue(ts, item.initializer);
+    const keyword = item.name.text === "color" || item.name.text === "backgroundColor" || item.name.text === "fontWeight" || item.name.text === "textAlign";
+    if (keyword && (typeof value === "string" || typeof value === "number")) {
+      out[item.name.text] = value;
+      continue;
+    }
+    if (typeof value !== "number" && !(typeof value === "string" && /^\d+(\.\d+)?px$/.test(value)))
+      throw nativeError(file, `\u6837\u5F0F ${item.name.text} \u53EA\u652F\u6301\u6570\u5B57\u6216 px`);
+    out[item.name.text] = typeof value === "string" ? Number.parseFloat(value) : value;
+  }
+  return out;
+}
+function get(ts, node, name) {
+  const item = node.properties.find((p) => ts.isPropertyAssignment(p) && p.name.getText().replace(/['"]/g, "") === name);
+  return item && ts.isPropertyAssignment(item) ? item.initializer : undefined;
+}
+function stringValue(ts, expression, file, label) {
+  const value = expression && literalValue(ts, expression);
+  if (typeof value !== "string")
+    throw nativeError(file, `${label} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+  return value;
+}
+function literalValue(ts, value) {
+  if (ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value))
+    return value.text;
+  if (ts.isNumericLiteral(value))
+    return Number(value.text);
+  if (value.kind === ts.SyntaxKind.TrueKeyword)
+    return true;
+  if (value.kind === ts.SyntaxKind.FalseKeyword)
+    return false;
+  return;
+}
+
+// src/app/build-app.ts
+async function buildNativeApp(config, dialect) {
+  if (!config.app)
+    throw new Error("Native app build requires config.app");
+  const entries = Object.values(config.app.pages);
+  if (entries.length !== 1)
+    throw nativeError(config.entry, "\u9996\u671F\u539F\u751F App \u53EA\u652F\u6301\u4E00\u4E2A\u9875\u9762");
+  const screen = await analyzeNativeScreen(entries[0]);
+  const files = dialect.generateProject(screen, config.app);
+  await rm2(config.app.outDir, { recursive: true, force: true });
+  const assetsBuilt = [];
+  for (const [relative3, content] of Object.entries(files).sort(([a], [b]) => a.localeCompare(b))) {
+    const target = join(config.app.outDir, relative3);
+    await mkdir2(dirname3(target), { recursive: true });
+    await writeFile2(target, content, "utf8");
+    assetsBuilt.push(target);
+  }
+  if (existsSync3(config.app.publicDir))
+    await cp(config.app.publicDir, join(config.app.outDir, dialect.resourceDirectory), { recursive: true });
+  return { root: config.root, outDir: resolve4(config.app.outDir), assetsBuilt };
+}
+
+// src/target/app-target.ts
+class AppTarget {
+  dialect;
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  get type() {
+    return this.dialect.id;
+  }
+  get label() {
+    return this.dialect.label;
   }
-  async build(_config, _options) {
-    const available = ["web"].map((target) => `'${target}'`).join(", ");
-    throw new Error(`Target "${this.type}" (${this.label}) \u5C1A\u672A\u5B9E\u73B0\uFF0C\u9884\u8BA1\u5728 ${this.plannedMilestone} \u843D\u5730\u3002` + `\u5F53\u524D\u53EF\u7528\u76EE\u6807\u7AEF\uFF1A${available}\u3002`);
+  build(config, _options) {
+    return buildNativeApp(config, this.dialect);
   }
 }
 
+// src/app/dialects.ts
+function text(parts, language) {
+  if (language === "swift") {
+    const value = parts.map((part) => part.kind === "literal" ? part.value : `\\(${part.key})`).join("");
+    return `"${value.replace(/"/g, "\\\"")}"`;
+  }
+  if (language === "kotlin") {
+    return JSON.stringify(parts.map((part) => part.kind === "literal" ? part.value : `$${part.key}`).join(""));
+  }
+  return parts.map((part) => part.kind === "literal" ? JSON.stringify(part.value) : `this.${part.key}`).join(" + ") || '""';
+}
+function action(node, language) {
+  const { action: action2 } = node;
+  const target = language === "ark" ? `this.${action2.key}` : action2.key;
+  return action2.kind === "increment" ? `${target} ${action2.by >= 0 ? "+=" : "-="} ${Math.abs(action2.by)}` : `${target} = ${typeof action2.value === "string" ? JSON.stringify(action2.value) : action2.value}`;
+}
+function swiftNode(node, indent = "    ") {
+  if (node.kind === "container")
+    return `${indent}VStack {
+${node.children.map((child) => swiftNode(child, `${indent}  `)).join(`
+`)}
+${indent}}`;
+  if (node.kind === "text")
+    return `${indent}Text(${text(node.parts, "swift")})`;
+  return `${indent}Button(${text(node.parts, "swift")}) { ${action(node, "swift")} }`;
+}
+function kotlinNode(node, indent = "    ") {
+  if (node.kind === "container")
+    return `${indent}Column {
+${node.children.map((child) => kotlinNode(child, `${indent}  `)).join(`
+`)}
+${indent}}`;
+  if (node.kind === "text")
+    return `${indent}Text(${text(node.parts, "kotlin")})`;
+  return `${indent}Button(onClick = { ${action(node, "kotlin")} }) { Text(${text(node.parts, "kotlin")}) }`;
+}
+function arkNode(node, indent = "    ") {
+  if (node.kind === "container")
+    return `${indent}Column() {
+${node.children.map((child) => arkNode(child, `${indent}  `)).join(`
+`)}
+${indent}}`;
+  if (node.kind === "text")
+    return `${indent}Text(${text(node.parts, "ark")})`;
+  return `${indent}Button(${text(node.parts, "ark")}).onClick(() => { ${action(node, "ark")} })`;
+}
+function swiftState(screen) {
+  return screen.state.map((item) => `  @State private var ${item.key}: ${typeof item.value === "number" ? "Int" : typeof item.value === "boolean" ? "Bool" : "String"} = ${JSON.stringify(item.value)}`).join(`
+`);
+}
+function kotlinState(screen) {
+  return screen.state.map((item) => `    var ${item.key} by remember { mutableStateOf(${JSON.stringify(item.value)}) }`).join(`
+`);
+}
+function arkState(screen) {
+  return screen.state.map((item) => `  @State ${item.key}: ${typeof item.value === "number" ? "number" : typeof item.value === "boolean" ? "boolean" : "string"} = ${JSON.stringify(item.value)}`).join(`
+`);
+}
+var IOS_DIALECT = {
+  id: "app-ios",
+  label: "iOS \u539F\u751F App\uFF08SwiftUI\uFF09",
+  resourceDirectory: "TransOneApp/Assets",
+  generateProject(screen, config) {
+    return {
+      "TransOneApp/TransOneApp.swift": `import SwiftUI
+
+@main struct TransOneApp: App { var body: some Scene { WindowGroup { ContentView() } } }
+`,
+      "TransOneApp/ContentView.swift": `import SwiftUI
+
+struct ContentView: View {
+${swiftState(screen)}
+  var body: some View {
+${swiftNode(screen.root)}
+  }
+}
+`,
+      "TransOneApp.xcodeproj/project.pbxproj": xcodeProject(config),
+      "TransOneApp/Assets.xcassets/Contents.json": `{"info":{"author":"xcode","version":1}}
+`
+    };
+  }
+};
+function xcodeProject(config) {
+  const escapedName = config.appName.replace(/"/g, "\\\"");
+  return `// !$*UTF8*$!
+{
+  archiveVersion = 1;
+  classes = {};
+  objectVersion = 56;
+  objects = {
+
+/* Begin PBXBuildFile section */
+    A00100000000000000000001 /* TransOneApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = A00100000000000000000011 /* TransOneApp.swift */; };
+    A00100000000000000000002 /* ContentView.swift in Sources */ = {isa = PBXBuildFile; fileRef = A00100000000000000000012 /* ContentView.swift */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+    A00100000000000000000011 /* TransOneApp.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TransOneApp.swift; sourceTree = "<group>"; };
+    A00100000000000000000012 /* ContentView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ContentView.swift; sourceTree = "<group>"; };
+    A00100000000000000000013 /* TransOneApp.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = TransOneApp.app; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXGroup section */
+    A00100000000000000000021 = {isa = PBXGroup; children = (A00100000000000000000022 /* TransOneApp */, A00100000000000000000023 /* Products */, ); sourceTree = "<group>"; };
+    A00100000000000000000022 /* TransOneApp */ = {isa = PBXGroup; children = (A00100000000000000000011 /* TransOneApp.swift */, A00100000000000000000012 /* ContentView.swift */, ); path = TransOneApp; sourceTree = "<group>"; };
+    A00100000000000000000023 /* Products */ = {isa = PBXGroup; children = (A00100000000000000000013 /* TransOneApp.app */, ); name = Products; sourceTree = "<group>"; };
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+    A00100000000000000000031 /* TransOneApp */ = {isa = PBXNativeTarget; buildConfigurationList = A00100000000000000000041 /* Build configuration list for PBXNativeTarget "TransOneApp" */; buildPhases = (A00100000000000000000032 /* Sources */, A00100000000000000000033 /* Frameworks */, A00100000000000000000034 /* Resources */, ); buildRules = (); dependencies = (); name = TransOneApp; productName = TransOneApp; productReference = A00100000000000000000013 /* TransOneApp.app */; productType = "com.apple.product-type.application"; };
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+    A00100000000000000000051 /* Project object */ = {isa = PBXProject; attributes = { LastUpgradeCheck = 2700; TargetAttributes = { A00100000000000000000031 = { CreatedOnToolsVersion = 27.0; }; }; }; buildConfigurationList = A00100000000000000000052 /* Build configuration list for PBXProject "TransOneApp" */; compatibilityVersion = "Xcode 14.0"; developmentRegion = en; hasScannedForEncodings = 0; knownRegions = (en, Base, ); mainGroup = A00100000000000000000021; productRefGroup = A00100000000000000000023; projectDirPath = ""; projectRoot = ""; targets = (A00100000000000000000031 /* TransOneApp */, ); };
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+    A00100000000000000000034 /* Resources */ = {isa = PBXResourcesBuildPhase; buildActionMask = 2147483647; files = (); runOnlyForDeploymentPostprocessing = 0; };
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+    A00100000000000000000032 /* Sources */ = {isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = (A00100000000000000000001 /* TransOneApp.swift in Sources */, A00100000000000000000002 /* ContentView.swift in Sources */, ); runOnlyForDeploymentPostprocessing = 0; };
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXFrameworksBuildPhase section */
+    A00100000000000000000033 /* Frameworks */ = {isa = PBXFrameworksBuildPhase; buildActionMask = 2147483647; files = (); runOnlyForDeploymentPostprocessing = 0; };
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+    A00100000000000000000061 /* Debug */ = {isa = XCBuildConfiguration; buildSettings = { CLANG_ENABLE_MODULES = YES; SWIFT_VERSION = 5.0; }; name = Debug; };
+    A00100000000000000000062 /* Release */ = {isa = XCBuildConfiguration; buildSettings = { CLANG_ENABLE_MODULES = YES; SWIFT_VERSION = 5.0; }; name = Release; };
+    A00100000000000000000063 /* Debug */ = {isa = XCBuildConfiguration; buildSettings = { ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; CODE_SIGNING_ALLOWED = NO; GENERATE_INFOPLIST_FILE = YES; IPHONEOS_DEPLOYMENT_TARGET = ${config.minPlatformVersion}; PRODUCT_BUNDLE_IDENTIFIER = ${config.bundleId}; PRODUCT_NAME = "${escapedName}"; SDKROOT = iphoneos; SWIFT_VERSION = 5.0; TARGETED_DEVICE_FAMILY = "1,2"; }; name = Debug; };
+    A00100000000000000000064 /* Release */ = {isa = XCBuildConfiguration; buildSettings = { ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; CODE_SIGNING_ALLOWED = NO; GENERATE_INFOPLIST_FILE = YES; IPHONEOS_DEPLOYMENT_TARGET = ${config.minPlatformVersion}; PRODUCT_BUNDLE_IDENTIFIER = ${config.bundleId}; PRODUCT_NAME = "${escapedName}"; SDKROOT = iphoneos; SWIFT_VERSION = 5.0; TARGETED_DEVICE_FAMILY = "1,2"; }; name = Release; };
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+    A00100000000000000000041 /* Build configuration list for PBXNativeTarget "TransOneApp" */ = {isa = XCConfigurationList; buildConfigurations = (A00100000000000000000063 /* Debug */, A00100000000000000000064 /* Release */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; };
+    A00100000000000000000052 /* Build configuration list for PBXProject "TransOneApp" */ = {isa = XCConfigurationList; buildConfigurations = (A00100000000000000000061 /* Debug */, A00100000000000000000062 /* Release */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; };
+/* End XCConfigurationList section */
+  };
+  rootObject = A00100000000000000000051 /* Project object */;
+}
+`;
+}
+var ANDROID_DIALECT = {
+  id: "app-android",
+  label: "Android \u539F\u751F App\uFF08Jetpack Compose\uFF09",
+  resourceDirectory: "app/src/main/assets",
+  generateProject(screen, config) {
+    const pkg = config.bundleId.replace(/[^A-Za-z0-9_.]/g, "_");
+    const path = pkg.replace(/\./g, "/");
+    return {
+      "settings.gradle.kts": `rootProject.name = "${config.appName}"
+include(":app")
+`,
+      "build.gradle.kts": `plugins { }
+`,
+      "app/build.gradle.kts": `plugins { id("com.android.application") version "8.5.0" apply false }
+`,
+      "app/src/main/AndroidManifest.xml": `<manifest package="${pkg}" xmlns:android="http://schemas.android.com/apk/res/android"><application android:label="${config.appName}"><activity android:name=".MainActivity" android:exported="true"><intent-filter><action android:name="android.intent.action.MAIN"/><category android:name="android.intent.category.LAUNCHER"/></intent-filter></activity></application></manifest>
+`,
+      [`app/src/main/java/${path}/MainActivity.kt`]: `package ${pkg}
+
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.runtime.*
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material3.*
+
+class MainActivity : ComponentActivity() { override fun onCreate(savedInstanceState: android.os.Bundle?) { super.onCreate(savedInstanceState); setContent {
+${kotlinState(screen)}
+${kotlinNode(screen.root)}
+} } }
+`
+    };
+  }
+};
+var HARMONY_DIALECT = {
+  id: "app-harmony",
+  label: "HarmonyOS \u539F\u751F App\uFF08ArkUI\uFF09",
+  resourceDirectory: "entry/src/main/resources/rawfile",
+  generateProject(screen, config) {
+    return {
+      "AppScope/app.json5": `{ "app": { "bundleName": "${config.bundleId}", "vendor": "TransOne", "versionCode": 1, "versionName": "1.0.0" } }
+`,
+      "AppScope/resources/base/element/string.json": `{ "string": [{ "name": "app_name", "value": "${config.appName}" }] }
+`,
+      "entry/src/main/module.json5": `{ "module": { "name": "entry", "type": "entry", "mainElement": "EntryAbility" } }
+`,
+      "entry/src/main/ets/entryability/EntryAbility.ets": `import UIAbility from '@ohos.app.ability.UIAbility';
+export default class EntryAbility extends UIAbility {}
+`,
+      "entry/src/main/ets/pages/Index.ets": `@Entry
+@Component
+struct Index {
+${arkState(screen)}
+  build() {
+${arkNode(screen.root)}
+  }
+}
+`
+    };
+  }
+};
+
 // src/target/registry.ts
 class TargetRegistry {
   targets = new Map;
@@ -756,9 +1255,10 @@ class TargetRegistry {
     this.register(mpWeixinTarget);
     this.register(mpAlipayTarget);
     this.register(mpBytedanceTarget);
-    this.register(new PlaceholderTarget("app-ios", "iOS \u539F\u751F App", "\u8FDC\u671F"));
-    this.register(new PlaceholderTarget("app-android", "Android \u539F\u751F App", "\u8FDC\u671F"));
-    this.register(new PlaceholderTarget("app-harmony", "\u9E3F\u8499\u539F\u751F App\uFF08ArkUI\uFF09", "\u8FDC\u671F"));
+    this.register(mpXiaohongshuTarget);
+    this.register(new AppTarget(IOS_DIALECT));
+    this.register(new AppTarget(ANDROID_DIALECT));
+    this.register(new AppTarget(HARMONY_DIALECT));
   }
   register(target) {
     this.targets.set(target.type, target);
@@ -777,8 +1277,8 @@ class TargetRegistry {
 var targetRegistry = new TargetRegistry;
 
 // src/build.ts
-import { mkdir as mkdir2, rm as rm2 } from "fs/promises";
-import { dirname as dirname3, resolve as resolve4 } from "path";
+import { mkdir as mkdir3, rm as rm3 } from "fs/promises";
+import { dirname as dirname4, resolve as resolve5 } from "path";
 async function build(options = {}) {
   const config = await resolveConfig(options);
   if (options.library) {
@@ -792,8 +1292,8 @@ async function buildLibrary(config) {
   if (!library) {
     throw new Error("TransOne library build requires config.library");
   }
-  await rm2(library.outDir, { recursive: true, force: true });
-  await mkdir2(library.outDir, { recursive: true });
+  await rm3(library.outDir, { recursive: true, force: true });
+  await mkdir3(library.outDir, { recursive: true });
   if (library.dts) {
     for (const tsconfig of library.tsconfigs) {
       await runTsc(config.root, tsconfig);
@@ -803,7 +1303,7 @@ async function buildLibrary(config) {
   const result = await Bun.build({
     entrypoints: [library.entry],
     outdir: library.outDir,
-    root: dirname3(library.entry),
+    root: dirname4(library.entry),
     target: "browser",
     format: "esm",
     sourcemap: library.sourcemap ? "linked" : undefined,
@@ -817,7 +1317,7 @@ async function buildLibrary(config) {
 ${result.logs.map((log) => log.message).join(`
 `)}`);
   }
-  const assetsBuilt = result.outputs.map((output) => resolve4(output.path));
+  const assetsBuilt = result.outputs.map((output) => resolve5(output.path));
   return { root: config.root, outDir: library.outDir, assetsBuilt };
 }
 async function runTsc(root, tsconfig) {
@@ -833,23 +1333,23 @@ async function runTsc(root, tsconfig) {
 }
 
 // src/create.ts
-import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
-import { basename, join } from "path";
-var TRANSONE_FRAMEWORK_VERSION = "0.3.0";
-var TRANSONE_CLI_VERSION = "0.3.0";
+import { existsSync as existsSync4, mkdirSync, writeFileSync } from "fs";
+import { basename as basename2, join as join2 } from "path";
+var TRANSONE_FRAMEWORK_VERSION = "0.4.0";
+var TRANSONE_CLI_VERSION = "0.4.0";
 var GITHUB_URL = "https://github.com/geektech-team/transone";
 function createProject(options = {}) {
   const root = options.root ?? process.cwd();
-  const name = options.name ?? basename(root);
+  const name = options.name ?? basename2(root);
   const files = scaffoldFiles(name);
-  const existing = files.filter((file) => existsSync2(join(root, file.path)));
+  const existing = files.filter((file) => existsSync4(join2(root, file.path)));
   if (existing.length > 0) {
     throw new Error(`Refusing to overwrite existing TransOne project files: ${existing.map((file) => file.path).join(", ")}`);
   }
-  mkdirSync(join(root, "src"), { recursive: true });
+  mkdirSync(join2(root, "src"), { recursive: true });
   const created = [];
   for (const file of files) {
-    writeFileSync(join(root, file.path), file.content, "utf8");
+    writeFileSync(join2(root, file.path), file.content, "utf8");
     created.push(file.path);
   }
   return { root, files: created };
@@ -991,11 +1491,11 @@ app.mount();
 // src/server.ts
 import { randomUUID } from "crypto";
 import {
-  basename as basename2,
+  basename as basename3,
   extname,
   isAbsolute as isAbsolute4,
   relative as relative4,
-  resolve as resolve5,
+  resolve as resolve6,
   sep as sep3
 } from "path";
 
@@ -1084,7 +1584,7 @@ function filterHeaders(source) {
 // src/watch.ts
 import { watch } from "fs";
 import { readdir, stat } from "fs/promises";
-import { isAbsolute as isAbsolute3, join as join2, relative as relative3 } from "path";
+import { isAbsolute as isAbsolute3, join as join3, relative as relative3 } from "path";
 var RECURSIVE_WATCH_UNSUPPORTED_ERROR = "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
 var DEFAULT_DEBOUNCE_MS = 100;
 var DEFAULT_POLL_INTERVAL_MS = 300;
@@ -1195,7 +1695,7 @@ async function collectRelevantFiles(root, isRelevant, output) {
     if (relativeDirectory === undefined) {
       break;
     }
-    const absoluteDirectory = join2(root, relativeDirectory);
+    const absoluteDirectory = join3(root, relativeDirectory);
     let entries;
     try {
       entries = await readdir(absoluteDirectory, { withFileTypes: true });
@@ -1212,7 +1712,7 @@ async function collectRelevantFiles(root, isRelevant, output) {
         continue;
       }
       try {
-        const info = await stat(join2(root, relativePath));
+        const info = await stat(join3(root, relativePath));
         output.set(relativePath, { mtimeMs: info.mtimeMs, size: info.size });
       } catch {}
     }
@@ -1311,11 +1811,11 @@ async function createServerInstance(options, watch2) {
   for (const [route, entry] of Object.entries(config.pages)) {
     await renderProjectHtml(config, {}, entry, route);
   }
-  const developmentOutDir = resolve5(config.root, "dist", "dev", "h5");
+  const developmentOutDir = resolve6(config.root, "dist", "dev", "h5");
   await assertSafeSubdirectory(config.root, developmentOutDir, INVALID_DEVELOPMENT_DIRECTORY_MESSAGE);
   const proxy = createProxyHandler(config.server.proxy);
   const sessionId = createGenerationId();
-  const sessionOutDir = resolve5(developmentOutDir, sessionId);
+  const sessionOutDir = resolve6(developmentOutDir, sessionId);
   const artifacts = new Map;
   const buildProject = createDevelopmentBuilder(sessionId, sessionOutDir);
   const liveReload = watch2 ? createLiveReloadHub() : undefined;
@@ -1550,11 +2050,11 @@ function isWatchedFile(instance, relativePath) {
   if (segments.some((segment) => IGNORED_WATCH_SEGMENTS.has(segment))) {
     return false;
   }
-  const absolutePath = resolve5(instance.config.root, relativePath);
+  const absolutePath = resolve6(instance.config.root, relativePath);
   if (isWithinOrEqual(instance.config.build.outDir, absolutePath)) {
     return false;
   }
-  const base = basename2(absolutePath);
+  const base = basename3(absolutePath);
   if (base.startsWith(".") && absolutePath !== instance.config.configFile) {
     return false;
   }
@@ -1581,7 +2081,7 @@ function createDevelopmentBuilder(sessionId, sessionOutDir) {
 }
 async function buildProjectBundle(entry, sessionId, sessionOutDir) {
   const generationId = createGenerationId();
-  const generationOutDir = resolve5(sessionOutDir, generationId);
+  const generationOutDir = resolve6(sessionOutDir, generationId);
   const generationUrl = `${DEVELOPMENT_URL_PREFIX}/${sessionId}/${generationId}`;
   const buildOptions = {
     entrypoints: [entry],
@@ -1645,7 +2145,7 @@ function publishDevelopmentBundle(bundle, artifacts) {
   }
 }
 function createDevelopmentOutput(generationOutDir, generationUrl, output) {
-  const filePath = resolve5(output.path);
+  const filePath = resolve6(output.path);
   const pathFromGeneration = relative4(generationOutDir, filePath);
   if (pathFromGeneration === "" || pathFromGeneration === ".." || pathFromGeneration.startsWith(`..${sep3}`) || isAbsolute4(pathFromGeneration)) {
     throw new Error(`Development output must not escape outside its generation directory: ${output.path}`);
@@ -1667,7 +2167,7 @@ function buildFailureResponse() {
   });
 }
 
-export { TARGET_TYPES, isTargetType, MP_TARGET_TYPES, isMpTargetType, defineConfig, resolveConfig, WebTarget, MpTarget, mpWeixinTarget, mpAlipayTarget, mpBytedanceTarget, PlaceholderTarget, TargetRegistry, targetRegistry, build, createProject, startDevServer };
+export { TARGET_TYPES, isTargetType, MP_TARGET_TYPES, isMpTargetType, defineConfig, resolveConfig, WebTarget, MpTarget, mpWeixinTarget, mpAlipayTarget, mpBytedanceTarget, mpXiaohongshuTarget, TargetRegistry, targetRegistry, build, createProject, startDevServer };
 
-//# debugId=20702718C87A6CDF64756E2164756E21
-//# sourceMappingURL=index-40bkmdrf.js.map
+//# debugId=4621705A1E76309564756E2164756E21
+//# sourceMappingURL=index-m455xjw2.js.map