@assistant-ui/metro 0.0.8 → 0.0.11

package/dist/index.cjs

@@ -8,6 +8,11 @@ const require$1 = (0, require("node:module").createRequire)(require("url").pathT
 */
 const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
 /**
+* Env var carrying the `backendless` option to the transformer. Metro forks its
+* transform workers after `metro.config` is evaluated, so they inherit it.
+*/
+const BACKENDLESS_ENV = "AUI_METRO_BACKENDLESS";
+/**
 * Wraps a Metro (or Expo) config so assistant-ui `"use generative"` modules are
 * compiled. Such a file colocates a tool's schema, its `execute`, and its
 * `render` via {@link https://www.assistant-ui.com/docs/tools/defining-tools | defineToolkit}.
@@ -23,7 +28,10 @@ const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
 * const { getDefaultConfig } = require("expo/metro-config");
 * const { withAui } = require("@assistant-ui/metro");
 *
-* module.exports = withAui(getDefaultConfig(__dirname));
+* module.exports = withAui({
+*   ...getDefaultConfig(__dirname),
+*   aui: { backendless: true },
+* });
 * ```
 *
 * Authoring is identical to the web: a `"use generative"` file whose default
@@ -31,10 +39,12 @@ const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
 */
 function withAui(config) {
 	const self = require$1.resolve("@assistant-ui/metro/transformer");
+	const { aui, ...baseConfig } = config;
 	const upstream = config.transformer?.babelTransformerPath;
+	if (aui?.backendless) process.env[BACKENDLESS_ENV] = "1";
 	if (upstream && upstream !== self) process.env[UPSTREAM_TRANSFORMER_ENV] = upstream;
 	return {
-		...config,
+		...baseConfig,
 		transformer: {
 			...config.transformer,
 			babelTransformerPath: self
@@ -42,6 +52,7 @@ function withAui(config) {
 	};
 }
 //#endregion
+exports.BACKENDLESS_ENV = BACKENDLESS_ENV;
 exports.UPSTREAM_TRANSFORMER_ENV = UPSTREAM_TRANSFORMER_ENV;
 exports.withAui = withAui;
 

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["require","createRequire"],"sources":["../src/index.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\n\nconst require = createRequire(import.meta.url);\n\n/**\n * The shape of a Metro / Expo config `withAui` accepts. Typed loosely so this\n * package needs no hard dependency on `metro` or `expo`; the input shape is\n * preserved and only `transformer.babelTransformerPath` is augmented.\n */\nexport type MetroConfigLike = {\n  transformer?:\n    | {\n        babelTransformerPath?: string | undefined;\n        [key: string]: unknown;\n      }\n    | undefined;\n  [key: string]: unknown;\n};\n\n/**\n * Env var the transformer reads to delegate to the project's existing\n * (Expo / React Native) babel transformer. Metro forks its transform workers\n * after `metro.config` is evaluated, so they inherit this value.\n */\nexport const UPSTREAM_TRANSFORMER_ENV = \"AUI_METRO_UPSTREAM_TRANSFORMER\";\n\n/**\n * Wraps a Metro (or Expo) config so assistant-ui `\"use generative\"` modules are\n * compiled. Such a file colocates a tool's schema, its `execute`, and its\n * `render` via {@link https://www.assistant-ui.com/docs/tools/defining-tools | defineToolkit}.\n *\n * It points Metro's `babelTransformerPath` at this package's transformer, which\n * runs the `\"use generative\"` compiler and then delegates to your project's\n * existing transformer. The device (client) build keeps each tool's `render`\n * and any frontend `execute`; a server build (an Expo Router `+api` route)\n * keeps a server `execute` instead.\n *\n * ```js\n * // metro.config.js\n * const { getDefaultConfig } = require(\"expo/metro-config\");\n * const { withAui } = require(\"@assistant-ui/metro\");\n *\n * module.exports = withAui(getDefaultConfig(__dirname));\n * ```\n *\n * Authoring is identical to the web: a `\"use generative\"` file whose default\n * export is `defineToolkit({ ... })`, registered with `Tools({ toolkit })`.\n */\nexport function withAui<T extends MetroConfigLike>(config: T): T {\n  const self = require.resolve(\"@assistant-ui/metro/transformer\");\n  const upstream = config.transformer?.babelTransformerPath;\n\n  // Guard against a double-wrap (`withAui(withAui(config))`, or a shared config\n  // already wrapped): if it already points at our transformer, keep the real\n  // upstream captured earlier rather than overwriting it with our own path,\n  // which would make `resolveUpstream()` return this transformer and recurse.\n  if (upstream && upstream !== self) {\n    process.env[UPSTREAM_TRANSFORMER_ENV] = upstream;\n  }\n\n  return {\n    ...config,\n    transformer: {\n      ...config.transformer,\n      babelTransformerPath: self,\n    },\n  };\n}\n"],"mappings":";;AAEA,MAAMA,aAAAA,wBAAUC,CAAAA,CAAAA,cAAAA,CAAAA,QAAAA,KAAAA,CAAAA,CAAAA,cAAAA,UAAAA,CAAAA,CAAAA,IAA6B;;;;;;AAsB7C,MAAa,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;AAwBxC,SAAgB,QAAmC,QAAc;CAC/D,MAAM,OAAOD,UAAQ,QAAQ,iCAAiC;CAC9D,MAAM,WAAW,OAAO,aAAa;CAMrC,IAAI,YAAY,aAAa,MAC3B,QAAQ,IAAI,4BAA4B;CAG1C,OAAO;EACL,GAAG;EACH,aAAa;GACX,GAAG,OAAO;GACV,sBAAsB;EACxB;CACF;AACF"}
+{"version":3,"file":"index.cjs","names":["require","createRequire"],"sources":["../src/index.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\n\nconst require = createRequire(import.meta.url);\n\n/**\n * The shape of a Metro / Expo config `withAui` accepts. Typed loosely so this\n * package needs no hard dependency on `metro` or `expo`; the input shape is\n * preserved and only `transformer.babelTransformerPath` is augmented.\n */\nexport type MetroConfigLike = {\n  /** assistant-ui options, stripped from the config handed back to Metro. */\n  aui?: WithAuiOptions | undefined;\n  transformer?:\n    | {\n        babelTransformerPath?: string | undefined;\n        [key: string]: unknown;\n      }\n    | undefined;\n  [key: string]: unknown;\n};\n\n/**\n * Env var the transformer reads to delegate to the project's existing\n * (Expo / React Native) babel transformer. Metro forks its transform workers\n * after `metro.config` is evaluated, so they inherit this value.\n */\nexport const UPSTREAM_TRANSFORMER_ENV = \"AUI_METRO_UPSTREAM_TRANSFORMER\";\n\n/**\n * Env var carrying the `backendless` option to the transformer. Metro forks its\n * transform workers after `metro.config` is evaluated, so they inherit it.\n */\nexport const BACKENDLESS_ENV = \"AUI_METRO_BACKENDLESS\";\n\nexport interface WithAuiOptions {\n  /**\n   * The app has no backend importing the server builds of its `\"use generative\"`\n   * modules (e.g. cloud-hosted runs). Frontend/human tool schemas then stay\n   * uploadable from the client instead of being assumed backend-known.\n   */\n  backendless?: boolean;\n}\n\n/**\n * Wraps a Metro (or Expo) config so assistant-ui `\"use generative\"` modules are\n * compiled. Such a file colocates a tool's schema, its `execute`, and its\n * `render` via {@link https://www.assistant-ui.com/docs/tools/defining-tools | defineToolkit}.\n *\n * It points Metro's `babelTransformerPath` at this package's transformer, which\n * runs the `\"use generative\"` compiler and then delegates to your project's\n * existing transformer. The device (client) build keeps each tool's `render`\n * and any frontend `execute`; a server build (an Expo Router `+api` route)\n * keeps a server `execute` instead.\n *\n * ```js\n * // metro.config.js\n * const { getDefaultConfig } = require(\"expo/metro-config\");\n * const { withAui } = require(\"@assistant-ui/metro\");\n *\n * module.exports = withAui({\n *   ...getDefaultConfig(__dirname),\n *   aui: { backendless: true },\n * });\n * ```\n *\n * Authoring is identical to the web: a `\"use generative\"` file whose default\n * export is `defineToolkit({ ... })`, registered with `Tools({ toolkit })`.\n */\nexport function withAui<T extends MetroConfigLike>(config: T): T {\n  const self = require.resolve(\"@assistant-ui/metro/transformer\");\n  // Metro validates config keys it does not recognize, so `aui` must not\n  // survive into the returned config.\n  const { aui, ...baseConfig } = config;\n  const upstream = config.transformer?.babelTransformerPath;\n\n  if (aui?.backendless) process.env[BACKENDLESS_ENV] = \"1\";\n\n  // Guard against a double-wrap (`withAui(withAui(config))`, or a shared config\n  // already wrapped): if it already points at our transformer, keep the real\n  // upstream captured earlier rather than overwriting it with our own path,\n  // which would make `resolveUpstream()` return this transformer and recurse.\n  if (upstream && upstream !== self) {\n    process.env[UPSTREAM_TRANSFORMER_ENV] = upstream;\n  }\n\n  return {\n    ...baseConfig,\n    transformer: {\n      ...config.transformer,\n      babelTransformerPath: self,\n    },\n  } as T;\n}\n"],"mappings":";;AAEA,MAAMA,aAAAA,wBAAUC,CAAAA,CAAAA,cAAAA,CAAAA,QAAAA,KAAAA,CAAAA,CAAAA,cAAAA,UAAAA,CAAAA,CAAAA,IAA6B;;;;;;AAwB7C,MAAa,2BAA2B;;;;;AAMxC,MAAa,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;AAoC/B,SAAgB,QAAmC,QAAc;CAC/D,MAAM,OAAOD,UAAQ,QAAQ,iCAAiC;CAG9D,MAAM,EAAE,KAAK,GAAG,eAAe;CAC/B,MAAM,WAAW,OAAO,aAAa;CAErC,IAAI,KAAK,aAAa,QAAQ,IAAI,mBAAmB;CAMrD,IAAI,YAAY,aAAa,MAC3B,QAAQ,IAAI,4BAA4B;CAG1C,OAAO;EACL,GAAG;EACH,aAAa;GACX,GAAG,OAAO;GACV,sBAAsB;EACxB;CACF;AACF"}

package/dist/index.d.cts

@@ -5,6 +5,8 @@
  * preserved and only `transformer.babelTransformerPath` is augmented.
  */
 type MetroConfigLike = {
+  /** assistant-ui options, stripped from the config handed back to Metro. */
+  aui?: WithAuiOptions | undefined;
   transformer?: {
     babelTransformerPath?: string | undefined;
     [key: string]: unknown;
@@ -17,6 +19,19 @@ type MetroConfigLike = {
  * after `metro.config` is evaluated, so they inherit this value.
  */
 declare const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
+/**
+ * Env var carrying the `backendless` option to the transformer. Metro forks its
+ * transform workers after `metro.config` is evaluated, so they inherit it.
+ */
+declare const BACKENDLESS_ENV = "AUI_METRO_BACKENDLESS";
+interface WithAuiOptions {
+  /**
+   * The app has no backend importing the server builds of its `"use generative"`
+   * modules (e.g. cloud-hosted runs). Frontend/human tool schemas then stay
+   * uploadable from the client instead of being assumed backend-known.
+   */
+  backendless?: boolean;
+}
 /**
  * Wraps a Metro (or Expo) config so assistant-ui `"use generative"` modules are
  * compiled. Such a file colocates a tool's schema, its `execute`, and its
@@ -33,7 +48,10 @@ declare const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
  * const { getDefaultConfig } = require("expo/metro-config");
  * const { withAui } = require("@assistant-ui/metro");
  *
- * module.exports = withAui(getDefaultConfig(__dirname));
+ * module.exports = withAui({
+ *   ...getDefaultConfig(__dirname),
+ *   aui: { backendless: true },
+ * });
  * ```
  *
  * Authoring is identical to the web: a `"use generative"` file whose default
@@ -41,5 +59,5 @@ declare const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
  */
 declare function withAui<T extends MetroConfigLike>(config: T): T;
 //#endregion
-export { MetroConfigLike, UPSTREAM_TRANSFORMER_ENV, withAui };
+export { BACKENDLESS_ENV, MetroConfigLike, UPSTREAM_TRANSFORMER_ENV, WithAuiOptions, withAui };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;KASY;EACV;IAEM;KACC;;GAGN;;;;;;;cAQU;;;;;;;;;;;;;;;;;;;;;;;iBAwBG,QAAQ,UAAU,iBAAiB,QAAQ,IAAI"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;KASY;;EAEV,MAAM;EACN;IAEM;KACC;;GAGN;;;;;;;cAQU;;;;;cAMA;UAEI;;;;;;EAMf;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4Bc,QAAQ,UAAU,iBAAiB,QAAQ,IAAI"}

package/dist/transformer.cjs

@@ -40,7 +40,7 @@ _babel_types = __toESM(_babel_types, 1);
 const DIRECTIVE = "use generative";
 //#endregion
 //#region ../x-generative-compiler/dist/package.js
-var version = "0.0.12";
+var version = "0.0.15";
 //#endregion
 //#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js
 var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -1508,6 +1508,7 @@ function isGenerativeModule(code) {
 	if (code[directiveEnd] !== quote) return false;
 	return hasDirectiveTerminator(code, directiveEnd + 1);
 }
+const isGenerativeSource = (filename, source) => /\.[cm]?[jt]sx?$/.test(filename) && isGenerativeModule(source);
 function hasDirectiveTerminator(code, start) {
 	let i = start;
 	let sawLineTerminator = false;
@@ -1590,6 +1591,7 @@ function isLineTerminator(char) {
 */
 function compileGenerative(code, options) {
 	const { target, filename } = options;
+	const backendless = options.backendless ?? false;
 	const ast = (0, _babel_parser.parse)(code, {
 		sourceType: "module",
 		plugins: parserPlugins
@@ -1616,7 +1618,7 @@ function compileGenerative(code, options) {
 		}
 		if (_babel_types.isIdentifier(callee, { name: TOOLKIT_WRAPPER })) {
 			if (!object) throw new GenerativeCompileError(`${TOOLKIT_WRAPPER}() takes an inline object literal of tools`, filename);
-			compileToolkit(object, target, generativeInstances, interactableToolImports, toolkitSpreadNames, namespaceImports, flags, filename);
+			compileToolkit(object, target, generativeInstances, interactableToolImports, toolkitSpreadNames, namespaceImports, flags, backendless, filename);
 			path.replaceWith(object);
 			path.skip();
 		}
@@ -1682,9 +1684,9 @@ function packageNameFromSpecifier(specifier) {
 }
 function resolvePackageJson(packageName, filename) {
 	const requirePath = normalizeRequirePath(filename);
-	const require = (0, node_module.createRequire)(requirePath);
+	const require$2 = (0, node_module.createRequire)(requirePath);
 	try {
-		return findPackageJson(require.resolve(packageName), packageName);
+		return findPackageJson(require$2.resolve(packageName), packageName);
 	} catch {
 		return findPackageJsonFromNodeModules(packageName, requirePath);
 	}
@@ -1777,6 +1779,15 @@ function collectGenerativeInstances(ast) {
 	}
 	return names;
 }
+/**
+* Wraps a pass-through generative entry (`generative.present()`) so the tool it
+* returns loses its `unstable_backendDefault` marker. The library stamps the
+* marker at runtime, out of this compiler's reach, so a backendless client
+* build strips it post-hoc instead of threading an option into the library.
+*/
+function stripBackendDefaultExpression(expr) {
+	return _babel_types.callExpression(_babel_types.arrowFunctionExpression([_babel_types.objectPattern([_babel_types.objectProperty(_babel_types.identifier("unstable_backendDefault"), _babel_types.identifier("_backendDefault")), _babel_types.restElement(_babel_types.identifier("tool"))])], _babel_types.identifier("tool")), [expr]);
+}
 function collectGenerativeFactoryImports(ast) {
 	const names = /* @__PURE__ */ new Set();
 	for (const statement of ast.program.body) {
@@ -2191,7 +2202,7 @@ function compileComponents(object, target, flags, filename) {
 * `generative.present()` passes through, the library having already split it.
 * Mutates the object in place and records outcomes in {@link TargetFlags}.
 */
-function compileToolkit(object, target, instances, interactableToolImports, toolkitSpreadNames, namespaceImports, flags, filename) {
+function compileToolkit(object, target, instances, interactableToolImports, toolkitSpreadNames, namespaceImports, flags, backendless, filename) {
 	if (target === "client") warnDuplicateToolkitNames(object, toolkitSpreadNames, filename);
 	const nextProperties = [];
 	for (const entry of object.properties) {
@@ -2203,6 +2214,7 @@ function compileToolkit(object, target, instances, interactableToolImports, tool
 			}
 			const raw = entryRawValue(entry);
 			if (raw && isGenerativeToolEntry(raw, instances)) {
+				if (backendless && target === "client" && _babel_types.isObjectProperty(entry)) entry.value = stripBackendDefaultExpression(raw);
 				nextProperties.push(entry);
 				continue;
 			}
@@ -2247,7 +2259,7 @@ function compileToolkit(object, target, instances, interactableToolImports, tool
 			}
 		}
 		setToolType(value, type);
-		setBackendDefault(value, target, type);
+		setBackendDefault(value, target, type, backendless);
 		nextProperties.push(entry);
 	}
 	object.properties = nextProperties;
@@ -2358,8 +2370,9 @@ function setToolType(object, type) {
 	removeMember(object, "type");
 	object.properties.push(_babel_types.objectProperty(_babel_types.identifier("type"), _babel_types.stringLiteral(type)));
 }
-function setBackendDefault(object, target, type) {
+function setBackendDefault(object, target, type, backendless) {
 	removeMember(object, "unstable_backendDefault");
+	if (backendless) return;
 	if (target !== "client" || type !== "frontend" && type !== "human") return;
 	object.properties.push(_babel_types.objectProperty(_babel_types.identifier("unstable_backendDefault"), _babel_types.objectExpression([_babel_types.objectProperty(_babel_types.identifier("parameters"), _babel_types.booleanLiteral(true))])));
 }
@@ -2443,8 +2456,6 @@ function isRemovableInit(node) {
 //#endregion
 //#region src/transformer.ts
 const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
-/** Source modules a `"use generative"` directive can appear in. */
-const SOURCE_RE = /\.[cm]?[jt]sx?$/;
 /**
 * The project's upstream babel transformer: what Metro would have used without
 * this wrapper. Taken from {@link UPSTREAM_TRANSFORMER_ENV} (set by `withAui`),
@@ -2469,11 +2480,12 @@ function isServerEnvironment(environment) {
 function transform(props) {
 	const upstream = upstreamTransformer();
 	const { filename, src, options } = props;
-	if (SOURCE_RE.test(filename) && isGenerativeModule(src)) {
+	if (isGenerativeSource(filename, src)) {
 		const { code } = compileGenerative(src, {
 			target: isServerEnvironment(options?.customTransformOptions?.environment) ? "server" : "client",
 			filename,
-			injectServerOnly: false
+			injectServerOnly: false,
+			backendless: process.env[require_index.BACKENDLESS_ENV] === "1"
 		});
 		return upstream.transform({
 			...props,
@@ -2494,7 +2506,9 @@ function selfCacheToken() {
 }
 function getCacheKey() {
 	const upstream = upstreamTransformer();
-	return `${upstream.getCacheKey ? upstream.getCacheKey() : ""}$aui-metro:${selfCacheToken()}`;
+	const base = upstream.getCacheKey ? upstream.getCacheKey() : "";
+	const backendless = process.env["AUI_METRO_BACKENDLESS"] === "1" ? ":backendless" : "";
+	return `${base}$aui-metro:${selfCacheToken()}${backendless}`;
 }
 //#endregion
 exports.getCacheKey = getCacheKey;