@tapcue/extension-sdk 0.1.0

package/src/jsx-runtime.ts

@@ -0,0 +1,118 @@
+/**
+ * The automatic-JSX factory. `tsconfig` points `jsxImportSource` here, so `<Detail/>` compiles
+ * to `jsx(Detail, props)` and this builds a `ViewNode` (view.ts). This is not React: there is no
+ * component instance, no VDOM, no reconciler — the factory reads each component's `__tag`,
+ * walks props through `toWire`, and returns a serializable tree of bindings.
+ */
+
+import { For, Fragment, Show } from "./components.js";
+import { itemIndex, itemProxy, toWire } from "./reactive.js";
+import type { PropValue, ViewNode } from "./view.js";
+
+export { Fragment };
+
+function tagOf(type: unknown): string | null {
+  if ((typeof type === "function" || typeof type === "object") && type !== null) {
+    const tag = (type as { __tag?: unknown }).__tag;
+    if (typeof tag === "string") return tag;
+  }
+  return null;
+}
+
+function isViewNode(value: unknown): value is ViewNode {
+  return typeof value === "object" && value !== null && typeof (value as ViewNode).type === "string";
+}
+
+function normalizeChildren(children: unknown): ViewNode[] {
+  const out: ViewNode[] = [];
+  const visit = (child: unknown): void => {
+    if (child === null || child === undefined || child === false || child === true) return;
+    if (Array.isArray(child)) {
+      for (const nested of child) visit(nested);
+      return;
+    }
+    if (isViewNode(child)) {
+      // A fragment carries no node of its own: splice its children into the parent.
+      if (child.type === "fragment") {
+        for (const grandchild of child.children ?? []) out.push(grandchild);
+        return;
+      }
+      out.push(child);
+    }
+    // Raw strings/numbers have no semantic home as children (content is a prop, e.g.
+    // `<Markdown text=…/>`); they are dropped rather than guessed at.
+  };
+  visit(children);
+  return out;
+}
+
+function withKey(node: ViewNode, key: unknown): ViewNode {
+  if (typeof key === "string" && key.length > 0) node.key = key;
+  return node;
+}
+
+function createNode(type: unknown, rawProps: Record<string, unknown> | null, key: unknown): ViewNode {
+  const props = rawProps ?? {};
+  const tag = tagOf(type);
+  if (tag === null) {
+    throw new Error("JSX type is not a Tapcue component — only the exported component set may be used");
+  }
+
+  if (type === Fragment || tag === "fragment") {
+    return { type: "fragment", children: normalizeChildren(props.children) };
+  }
+
+  // `<For each={…}>{(item, index) => …}</For>`: the child render function is called once with a
+  // proxy item so the shell can instantiate the template per element without waking the isolate.
+  if (type === For) {
+    const render = props.children as ((item: unknown, index: number) => ViewNode) | undefined;
+    if (typeof render !== "function") {
+      throw new Error("<For> expects a single render-function child");
+    }
+    const template = render(itemProxy(), itemIndex);
+    return withKey({ type: "for", props: { each: toWire(props.each) }, children: [template] }, key);
+  }
+
+  // `<Show when={…} fallback={…}>…</Show>`: `when` is a bound boolean; the fallback is a subtree,
+  // carried in `slots` rather than wired as a value.
+  if (type === Show) {
+    const node: ViewNode = { type: "show", props: { when: toWire(props.when) } };
+    const children = normalizeChildren(props.children);
+    if (children.length > 0) node.children = children;
+    if (isViewNode(props.fallback)) node.slots = { fallback: props.fallback };
+    return withKey(node, key);
+  }
+
+  const { children, fallback: _fallback, ...rest } = props;
+  const wired: Record<string, PropValue> = {};
+  for (const [name, value] of Object.entries(rest)) {
+    if (value === undefined) continue;
+    wired[name] = toWire(value);
+  }
+  const node: ViewNode = { type: tag };
+  if (Object.keys(wired).length > 0) node.props = wired;
+  const kids = normalizeChildren(children);
+  if (kids.length > 0) node.children = kids;
+  return withKey(node, key);
+}
+
+export function jsx(type: unknown, props: Record<string, unknown>, key?: unknown): ViewNode {
+  return createNode(type, props, key);
+}
+
+export const jsxs = jsx;
+
+/** The development runtime entry (`jsx: "react-jsxdev"`, which is what Vite/Vitest default to). */
+export function jsxDEV(type: unknown, props: Record<string, unknown>, key?: unknown): ViewNode {
+  return createNode(type, props, key);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace JSX {
+  export type Element = ViewNode;
+  export interface ElementChildrenAttribute {
+    children: Record<string, never>;
+  }
+  // Only the exported component set is renderable — no lowercase intrinsic tags.
+  export type IntrinsicElements = Record<string, never>;
+}