@barefootjs/test 0.10.1 → 0.12.0

package/dist/index.js

@@ -187396,6 +187396,11 @@ function applyReplacement(slice, re, replacement) {
   re.lastIndex = 0;
   return typeof replacement === "string" ? slice.replace(re, replacement) : slice.replace(re, replacement);
 }
+
+// ../shared/src/markers.ts
+var BF_SCOPE = "bf-s";
+var BF_SLOT = "bf";
+var BF_COND = "bf-c";
 // ../shared/src/dom-prop.ts
 var BOOLEAN_ATTRS = new Set([
   "checked",
@@ -190479,6 +190484,9 @@ var LOWERED_ARRAY_METHODS = new Set([
   "lastIndexOf",
   "concat"
 ]);
+function cssKebabCase(name) {
+  return name.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase()).replace(/^ms-/, "-ms-");
+}
 function parseExpression(expr) {
   const trimmed = expr.trim();
   if (!trimmed) {
@@ -194205,7 +194213,7 @@ function tryStaticStyleObjectToCss(expr) {
       return null;
     if (!import_typescript11.default.isStringLiteral(prop.initializer))
       return null;
-    const key = prop.name.text.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    const key = cssKebabCase(prop.name.text);
     parts.push(`${key}:${prop.initializer.text}`);
   }
   return parts.join(";");
@@ -195131,6 +195139,38 @@ class SourceMapGenerator {
   }
 }
 
+// ../jsx/src/module-exports.ts
+function formatParamWithType(p) {
+  const rest = p.isRest ? "..." : "";
+  const optional = p.optional ? "?" : "";
+  const typeAnnotation = p.type?.raw && p.type.raw !== "unknown" ? `: ${p.type.raw}` : "";
+  const defaultPart = p.defaultValue !== undefined ? ` = ${p.defaultValue}` : "";
+  return `${rest}${p.name}${optional}${typeAnnotation}${defaultPart}`;
+}
+function findReachableNames(primaryRefs, declarations) {
+  const allNames = new Set(declarations.map((d) => d.name));
+  const bodyMap = new Map(declarations.map((d) => [d.name, d.body]));
+  const reachable = new Set;
+  const queue = [];
+  for (const name of allNames) {
+    if (new RegExp(`\\b${name}\\b`).test(primaryRefs)) {
+      reachable.add(name);
+      queue.push(name);
+    }
+  }
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const body = bodyMap.get(current) || "";
+    for (const name of allNames) {
+      if (!reachable.has(name) && new RegExp(`\\b${name}\\b`).test(body)) {
+        reachable.add(name);
+        queue.push(name);
+      }
+    }
+  }
+  return reachable;
+}
+
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
 var import_typescript15 = __toESM(require_typescript(), 1);
 
@@ -195140,14 +195180,450 @@ var UNRESOLVED = Symbol("unresolved");
 // ../jsx/src/shared-program.ts
 init_path();
 var import_typescript17 = __toESM(require_typescript(), 1);
+// ../jsx/src/adapters/interface.ts
+class BaseAdapter {
+  renderChildren(children) {
+    return children.map((child) => this.renderNode(child)).join("");
+  }
+  renderAsync(node) {
+    return this.renderNode(node.fallback) + this.renderChildren(node.children);
+  }
+}
+// ../jsx/src/adapters/jsx-adapter.ts
+class JsxAdapter extends BaseAdapter {
+  componentName = "";
+  formatImportSpecifiers(specifiers) {
+    const defaultSpec = specifiers.find((s) => s.isDefault);
+    const namespaceSpec = specifiers.find((s) => s.isNamespace);
+    const namedSpecs = specifiers.filter((s) => !s.isDefault && !s.isNamespace);
+    const parts = [];
+    if (defaultSpec) {
+      parts.push(defaultSpec.alias || defaultSpec.name);
+    }
+    if (namespaceSpec) {
+      parts.push(`* as ${namespaceSpec.name}`);
+    }
+    if (namedSpecs.length > 0) {
+      const named = namedSpecs.map((s) => s.alias ? `${s.name} as ${s.alias}` : s.name).join(", ");
+      parts.push(`{ ${named} }`);
+    }
+    return parts.join(", ");
+  }
+  generateSignalInitializers(ir, jsxBody) {
+    const lines = [];
+    const { preserveTypes } = this.jsxConfig;
+    const primaryRefs = [jsxBody];
+    for (const signal of ir.metadata.signals) {
+      if (signal.isModule)
+        continue;
+      primaryRefs.push(signal.initialValue);
+    }
+    for (const memo of ir.metadata.memos) {
+      if (memo.isModule)
+        continue;
+      primaryRefs.push(memo.computation);
+    }
+    const primaryRefText = primaryRefs.join(`
+`);
+    const localFunctions = ir.metadata.localFunctions.filter((f) => !f.isExported);
+    const localConstants = ir.metadata.localConstants.filter((c) => !c.isExported && c.value);
+    const declarations = [
+      ...localFunctions.map((f) => ({ name: f.name, body: f.body })),
+      ...localConstants.map((c) => ({ name: c.name, body: c.value }))
+    ];
+    const reachable = findReachableNames(primaryRefText, declarations);
+    const reachableBodies = [...reachable].map((name) => {
+      const func = localFunctions.find((f) => f.name === name);
+      if (func)
+        return func.body;
+      const constant = localConstants.find((c) => c.name === name);
+      return constant?.value ?? "";
+    }).join(`
+`);
+    const setterRefText = primaryRefText + `
+` + reachableBodies;
+    for (const signal of ir.metadata.signals) {
+      if (signal.isModule)
+        continue;
+      const rawInitialValue = preserveTypes ? signal.typedInitialValue ?? signal.initialValue : signal.initialValue;
+      const initialValue = rawInitialValue.trim().startsWith("{") ? `(${rawInitialValue})` : rawInitialValue;
+      const needsTypeAssertion = preserveTypes && !signal.typedInitialValue && signal.type.kind !== "unknown" && signal.type.kind !== "primitive";
+      if (needsTypeAssertion) {
+        lines.push(`  const ${signal.getter} = () => ${initialValue} as ${signal.type.raw}`);
+      } else {
+        lines.push(`  const ${signal.getter} = () => ${initialValue}`);
+      }
+      if (signal.setter) {
+        const setterUsed = new RegExp(`\\b${signal.setter}\\b`).test(setterRefText);
+        if (setterUsed) {
+          lines.push(`  const ${signal.setter} = (..._args: any[]) => {}`);
+        }
+      }
+    }
+    for (const memo of ir.metadata.memos) {
+      if (memo.isModule)
+        continue;
+      const computation = preserveTypes ? memo.typedComputation ?? memo.computation : memo.computation;
+      lines.push(`  const ${memo.name} = ${computation}`);
+    }
+    for (const constant of ir.metadata.localConstants) {
+      if (constant.isExported)
+        continue;
+      const keyword = constant.declarationKind ?? "const";
+      if (!constant.value) {
+        lines.push(`  ${keyword} ${constant.name}`);
+        continue;
+      }
+      const value = constant.value.trim();
+      if (/^createContext\b/.test(value) || /^new WeakMap\b/.test(value))
+        continue;
+      if (!reachable.has(constant.name))
+        continue;
+      const constValue = preserveTypes ? constant.typedValue ?? constant.value : constant.value;
+      lines.push(`  ${keyword} ${constant.name} = ${constValue}`);
+    }
+    for (const func of localFunctions) {
+      if (!reachable.has(func.name))
+        continue;
+      const params = preserveTypes && func.typedParams !== undefined ? func.typedParams : func.params.map(formatParamWithType).join(", ");
+      const returnAnnotation = preserveTypes && func.typedReturnType ? `: ${func.typedReturnType}` : "";
+      const body = preserveTypes ? func.typedBody ?? func.body : func.body;
+      const asyncKw = func.isAsync ? "async " : "";
+      lines.push(`  ${asyncKw}function ${func.name}(${params})${returnAnnotation} ${body}`);
+    }
+    return lines.join(`
+`);
+  }
+  renderNodeRaw(node) {
+    if (node.type === "expression") {
+      if (node.expr === "null" || node.expr === "undefined") {
+        return "null";
+      }
+      return node.expr;
+    }
+    return this.renderNode(node);
+  }
+  renderScopeMarker(instanceIdExpr) {
+    return `${BF_SCOPE}={${instanceIdExpr}}`;
+  }
+  renderSlotMarker(slotId) {
+    return `${BF_SLOT}="${slotId}"`;
+  }
+  renderCondMarker(condId) {
+    return `${BF_COND}="${condId}"`;
+  }
+}
+
 // ../jsx/src/adapters/template-imports.ts
 var CLIENT_PACKAGE_SOURCES = new Set([
   "@barefootjs/client",
   "@barefootjs/client/runtime"
 ]);
+function rewriteImportsForTemplate(imports, shimSource, rewriteRelative) {
+  const remap = (imp) => {
+    if (!rewriteRelative || !imp.source.startsWith("."))
+      return imp;
+    const next = rewriteRelative(imp.source);
+    return next === imp.source ? imp : { ...imp, source: next };
+  };
+  if (!shimSource) {
+    return imports.filter((imp) => !CLIENT_PACKAGE_SOURCES.has(imp.source)).map(remap);
+  }
+  const merged = new Map;
+  const result = [];
+  for (const imp of imports) {
+    if (!CLIENT_PACKAGE_SOURCES.has(imp.source)) {
+      result.push(remap(imp));
+      continue;
+    }
+    const existing = merged.get(shimSource);
+    if (existing) {
+      const seen = new Set(existing.specifiers.map(specKey));
+      for (const spec of imp.specifiers) {
+        if (!seen.has(specKey(spec))) {
+          existing.specifiers.push(spec);
+          seen.add(specKey(spec));
+        }
+      }
+      existing.isTypeOnly = existing.isTypeOnly && imp.isTypeOnly;
+    } else {
+      const rewritten = {
+        ...imp,
+        source: shimSource,
+        specifiers: imp.specifiers.map((s) => ({ ...s }))
+      };
+      merged.set(shimSource, rewritten);
+      result.push(rewritten);
+    }
+  }
+  return result;
+}
+function specKey(s) {
+  return `${s.isDefault ? "d" : ""}${s.isNamespace ? "n" : ""}:${s.name}:${s.alias ?? ""}`;
+}
+
+// ../jsx/src/adapters/test-adapter.ts
+class TestAdapter extends JsxAdapter {
+  name = "test";
+  extension = ".test.tsx";
+  jsxConfig = { preserveTypes: false };
+  generate(ir) {
+    this.componentName = ir.metadata.componentName;
+    const imports = this.generateImports(ir);
+    const types2 = this.generateTypes(ir);
+    const component = this.generateComponent(ir);
+    const defaultExport = ir.metadata.hasDefaultExport ? `
+export default ${this.componentName}` : "";
+    const sections = {
+      imports,
+      types: types2 || "",
+      component,
+      defaultExport
+    };
+    const template = [imports, types2, component].filter(Boolean).join(`
+
+`) + defaultExport;
+    return {
+      template,
+      sections,
+      types: types2 || undefined,
+      extension: this.extension
+    };
+  }
+  generateImports(ir) {
+    const lines = [];
+    const templateImports = rewriteImportsForTemplate(ir.metadata.templateImports, undefined);
+    for (const imp of templateImports) {
+      if (imp.specifiers.length === 0) {
+        if (!imp.isTypeOnly) {
+          lines.push(`import '${imp.source}'`);
+        }
+        continue;
+      }
+      if (imp.isTypeOnly) {
+        lines.push(`import type ${this.formatImportSpecifiers(imp.specifiers)} from '${imp.source}'`);
+      } else {
+        lines.push(`import ${this.formatImportSpecifiers(imp.specifiers)} from '${imp.source}'`);
+      }
+    }
+    return lines.join(`
+`);
+  }
+  generateTypes(ir) {
+    const lines = [];
+    for (const typeDef of ir.metadata.typeDefinitions) {
+      lines.push(typeDef.definition);
+    }
+    const propsTypeName = ir.metadata.propsType?.raw;
+    if (propsTypeName && !ir.metadata.propsObjectName) {
+      lines.push("");
+      lines.push(`type ${this.componentName}PropsWithHydration = ${propsTypeName} & {`);
+      lines.push("  __instanceId?: string");
+      lines.push("  __bfScope?: string");
+      lines.push("}");
+    }
+    return lines.length > 0 ? lines.join(`
+`) : null;
+  }
+  generateComponent(ir) {
+    const name = ir.metadata.componentName;
+    const propsTypeName = ir.metadata.propsType?.raw;
+    const hasClientInteractivity = ir.metadata.signals.length > 0 || ir.metadata.memos.length > 0;
+    const typeAnnotation = propsTypeName ? `: ${name}PropsWithHydration` : ": { __instanceId?: string; __bfScope?: string }";
+    const jsxBody = this.renderNode(ir.root);
+    const signalInits = this.generateSignalInitializers(ir, jsxBody);
+    const scopeIdLine = hasClientInteractivity ? `(/_s\\d/.test(__bfScope || '') ? __bfScope : null) || __instanceId` : `__bfScope || __instanceId`;
+    const bodyRefText = [jsxBody, signalInits, scopeIdLine].join(`
+`);
+    const bfScopeAlias = /\b__bfScope\b/.test(bodyRefText) ? "__bfScope" : "__bfScope: _bfScope";
+    const propsParams = ir.metadata.propsParams.map((p) => p.defaultValue ? `${p.name} = ${p.defaultValue}` : p.name).join(", ");
+    const restPropsName = ir.metadata.restPropsName;
+    const hydrationProps = `__instanceId, ${bfScopeAlias}`;
+    const parts = [];
+    if (propsParams) {
+      parts.push(propsParams);
+    }
+    parts.push(hydrationProps);
+    if (restPropsName) {
+      parts.push(`...${restPropsName}`);
+    }
+    const fullPropsDestructure = `{ ${parts.join(", ")} }`;
+    const hasRequiredProps = ir.metadata.propsParams.some((p) => !p.optional && p.defaultValue === undefined && !p.isRest);
+    const propsTypeExpr = typeAnnotation.replace(/^:\s*/, "");
+    const noArgDefault = hasRequiredProps ? "" : ` = {} as ${propsTypeExpr}`;
+    const lines = [];
+    const exportPrefix = ir.metadata.isExported === false ? "" : "export ";
+    lines.push(`${exportPrefix}function ${name}(${fullPropsDestructure}${typeAnnotation}${noArgDefault}) {`);
+    if (hasClientInteractivity) {
+      lines.push(`  const __scopeId = (/_s\\d/.test(__bfScope || '') ? __bfScope : null) || __instanceId || \`${name}_\${Math.random().toString(36).slice(2, 8)}\``);
+    } else {
+      lines.push(`  const __scopeId = __bfScope || __instanceId || \`${name}_\${Math.random().toString(36).slice(2, 8)}\``);
+    }
+    if (signalInits) {
+      lines.push(signalInits);
+    }
+    lines.push("");
+    lines.push(`  return (`);
+    lines.push(`    ${jsxBody}`);
+    lines.push(`  )`);
+    lines.push(`}`);
+    return lines.join(`
+`);
+  }
+  renderNode(node) {
+    switch (node.type) {
+      case "element":
+        return this.renderElement(node);
+      case "text":
+        return node.value;
+      case "expression":
+        return this.renderExpression(node);
+      case "conditional":
+        return this.renderConditional(node);
+      case "loop":
+        return this.renderLoop(node);
+      case "component":
+        return this.renderComponent(node);
+      case "fragment":
+        return this.renderFragment(node);
+      case "slot":
+        return "{children}";
+      default:
+        return "";
+    }
+  }
+  renderElement(element) {
+    const tag = element.tag;
+    const attrs = this.renderAttributes(element);
+    const children = this.renderChildren(element.children);
+    let hydrationAttrs = "";
+    if (element.needsScope) {
+      hydrationAttrs += " bf-s={__scopeId}";
+    }
+    if (element.slotId) {
+      hydrationAttrs += ` bf="${element.slotId}"`;
+    }
+    if (children) {
+      return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
+    } else {
+      return `<${tag}${attrs}${hydrationAttrs} />`;
+    }
+  }
+  renderExpression(expr) {
+    if (expr.expr === "null" || expr.expr === "undefined") {
+      return "null";
+    }
+    if (expr.reactive && expr.slotId) {
+      return `{bfText("${expr.slotId}")}{${expr.expr}}{bfTextEnd()}`;
+    }
+    return `{${expr.expr}}`;
+  }
+  renderConditional(cond) {
+    const whenTrue = this.renderNodeRaw(cond.whenTrue);
+    let whenFalse = this.renderNodeRaw(cond.whenFalse);
+    if (!whenFalse || whenFalse === "" || whenFalse === "null") {
+      whenFalse = "null";
+    }
+    return `{${cond.condition} ? ${whenTrue} : ${whenFalse}}`;
+  }
+  renderLoop(loop) {
+    const indexParam = loop.index ? `, ${loop.index}` : "";
+    const children = this.renderChildren(loop.children);
+    const safeChildren = children.startsWith("{") ? `<>${children}</>` : children;
+    return `{${loop.array}.map((${loop.param}${indexParam}) => ${safeChildren})}`;
+  }
+  renderComponent(comp) {
+    const props = this.renderComponentProps(comp);
+    const children = this.renderChildren(comp.children);
+    const scopeAttr = " __bfScope={__scopeId}";
+    if (children) {
+      return `<${comp.name}${props}${scopeAttr}>${children}</${comp.name}>`;
+    } else {
+      return `<${comp.name}${props}${scopeAttr} />`;
+    }
+  }
+  renderFragment(fragment) {
+    const children = this.renderChildren(fragment.children);
+    return `<>${children}</>`;
+  }
+  renderAttributes(element) {
+    const parts = [];
+    for (const attr of element.attrs) {
+      const attrName = attr.name === "class" ? "className" : attr.name;
+      switch (attr.value.kind) {
+        case "spread":
+          parts.push(`{...${attr.value.expr}}`);
+          break;
+        case "boolean-attr":
+          parts.push(attrName);
+          break;
+        case "expression":
+          parts.push(`${attrName}={${attr.value.expr}}`);
+          break;
+        case "template":
+          parts.push(`${attrName}={${this.flattenTemplate(attr.value)}}`);
+          break;
+        case "literal":
+          parts.push(`${attrName}="${attr.value.value}"`);
+          break;
+        case "boolean-shorthand":
+        case "jsx-children":
+          break;
+      }
+    }
+    for (const event of element.events) {
+      const handlerName = event.originalAttr ?? `on${event.name.charAt(0).toUpperCase()}${event.name.slice(1)}`;
+      parts.push(`${handlerName}={() => {}}`);
+    }
+    return parts.length > 0 ? " " + parts.join(" ") : "";
+  }
+  flattenTemplate(value) {
+    const v = value;
+    return "`" + v.parts.map((p) => {
+      if (p.type === "string")
+        return p.value;
+      if (p.type === "ternary")
+        return `\${${p.condition} ? '${p.whenTrue}' : '${p.whenFalse}'}`;
+      return `\${(${JSON.stringify(p.cases)})[${p.key}]}`;
+    }).join("") + "`";
+  }
+  renderComponentProps(comp) {
+    const parts = [];
+    for (const prop of comp.props) {
+      switch (prop.value.kind) {
+        case "jsx-children": {
+          const rendered = prop.value.children.map((c) => this.renderNode(c)).join("");
+          parts.push(`${prop.name}={<>${rendered}</>}`);
+          break;
+        }
+        case "spread":
+          parts.push(`{...${prop.value.expr}}`);
+          break;
+        case "expression":
+          parts.push(`${prop.name}={${prop.value.expr}}`);
+          break;
+        case "template":
+          parts.push(`${prop.name}={${this.flattenTemplate(prop.value)}}`);
+          break;
+        case "boolean-shorthand":
+          parts.push(prop.name);
+          break;
+        case "literal":
+          parts.push(`${prop.name}="${prop.value.value}"`);
+          break;
+        case "boolean-attr":
+          parts.push(prop.name);
+          break;
+      }
+    }
+    return parts.length > 0 ? " " + parts.join(" ") : "";
+  }
+}
+var testAdapter = new TestAdapter;
 // ../jsx/src/combine-client-js.ts
 var import_typescript18 = __toESM(require_typescript(), 1);
 // ../jsx/src/debug.ts
+var import_typescript19 = __toESM(require_typescript(), 1);
 function escapeForIdBoundary(name) {
   return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -195238,8 +195714,10 @@ function resolveSetters(handler, setterToSignal, fnSetters) {
   }
   return refs;
 }
+// ../jsx/src/profiler.ts
+var import_typescript20 = __toESM(require_typescript(), 1);
 // ../jsx/src/augment-inherited-props.ts
-var import_typescript19 = __toESM(require_typescript(), 1);
+var import_typescript21 = __toESM(require_typescript(), 1);
 // src/test-node.ts
 class TestNode {
   tag;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/test",
-  "version": "0.10.1",
+  "version": "0.12.0",
   "description": "Test utilities for BarefootJS - IR-based component testing without a browser",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "directory": "packages/test"
   },
   "dependencies": {
-    "@barefootjs/jsx": "0.10.1"
+    "@barefootjs/jsx": "0.12.0"
   },
   "devDependencies": {
     "typescript": "^5.0.0"