@firsthandjs/compiler 0.8.0 → 0.9.1

package/dist/{chunk-NFKHWAYO.js → chunk-GUVVHV7H.js}

@@ -86,6 +86,7 @@ function eventName(attribute) {
 
 // packages/compiler/src/transform.ts
 var RUNTIME = "@firsthandjs/dom/internal";
+var SERVER_RUNTIME = "@firsthandjs/server/internal";
 var CORE = "@firsthandjs/core";
 var CHILD_THUNK = /* @__PURE__ */ Symbol("firsthand.childThunk");
 var GENERATED = /* @__PURE__ */ Symbol("firsthand.generated");
@@ -112,10 +113,14 @@ function firsthandPlugin(_api, options = {}) {
             moduleId: stableId(options.packageName ?? "app", state.filename ?? "module"),
             views: /* @__PURE__ */ new Map(),
             viewNodes: /* @__PURE__ */ new Set(),
-            runs: /* @__PURE__ */ new Map()
+            runs: /* @__PURE__ */ new Map(),
+            ssr: options.ssr === true,
+            hydratable: options.hydratable === true && options.ssr !== true
           };
           collectViews(path, state);
-          collectRuns(path, state);
+          if (options.ssr !== true) {
+            collectRuns(path, state);
+          }
         },
         exit(path, state) {
           const { imports, templates, views } = state.firsthand;
@@ -142,18 +147,22 @@ function firsthandPlugin(_api, options = {}) {
       // component's children, a dynamic expression) are re-visited later, by
       // which time they are no longer inside JSX.
       JSXElement(path, state) {
-        rewriteKeyedMaps(path, state);
+        if (!state.firsthand.ssr) {
+          rewriteKeyedMaps(path, state);
+        }
         path.replaceWith(compileNode(path, state));
       },
       JSXFragment(path, state) {
-        rewriteKeyedMaps(path, state);
+        if (!state.firsthand.ssr) {
+          rewriteKeyedMaps(path, state);
+        }
         path.replaceWith(compileNode(path, state));
       },
       CallExpression(path, state) {
         annotateComponent(path, state, options);
       },
       VariableDeclarator(path, state) {
-        if (options.devtools === true) {
+        if (options.devtools === true && options.ssr !== true) {
           nameCell(path, state);
         }
       }
@@ -175,7 +184,10 @@ function groupBySource(imports) {
   }
   return grouped;
 }
-function runtime(state, name, source = RUNTIME) {
+function runtime(state, name, source) {
+  return runtimeFrom(state, name, source ?? (state.firsthand.ssr ? SERVER_RUNTIME : RUNTIME));
+}
+function runtimeFrom(state, name, source) {
   const key = `${source}#${name}`;
   let local = state.firsthand.imports.get(key);
   if (local === void 0) {
@@ -624,7 +636,7 @@ function compileNode(path, state) {
   if (isComponentTag(node)) {
     return compileComponent(path, state);
   }
-  return compileTemplate(path, state);
+  return state.firsthand.ssr ? compileMarkup(path, state) : compileTemplate(path, state);
 }
 function collectViews(program, state) {
   const { views, viewNodes } = state.firsthand;
@@ -892,16 +904,28 @@ function compileComponent(path, state) {
     }
     const name = attributeName(attribute);
     const value = attributeValue(attribute);
+    if (state.firsthand.ssr && name === "key") {
+      continue;
+    }
     if (value === null || isStaticValue(value)) {
       properties.push(t.objectProperty(propertyKey(name), value ?? t.booleanLiteral(true)));
     } else {
       const held = dependsOnRun(value, run, path) ? throughCell(value) : value;
-      const read = t.returnStatement(held);
-      takePosition(read, value);
-      properties.push(t.objectMethod("get", propertyKey(name), [], t.blockStatement([read])));
+      if (state.firsthand.ssr && isPure(value)) {
+        properties.push(t.objectProperty(propertyKey(name), held));
+      } else {
+        const read = t.returnStatement(held);
+        takePosition(read, value);
+        properties.push(t.objectMethod("get", propertyKey(name), [], t.blockStatement([read])));
+      }
     }
   }
-  const children = compileChildren(node.children, state);
+  const throughRunCell = (value) => t.callExpression(throughCell(t.arrowFunctionExpression([], value)), []);
+  const children = compileChildren(node.children, state, {
+    depends: (value) => dependsOnRun(value, run, path),
+    cell: throughRunCell,
+    value: throughCell
+  });
   if (children.length === 1) {
     properties.push(
       t.objectMethod(
@@ -927,6 +951,9 @@ function compileComponent(path, state) {
     return keptChild(state, run, make, cells);
   }
   if (isLocalView(path, state)) {
+    if (state.firsthand.ssr) {
+      return make;
+    }
     const parent = path.parentPath;
     if (parent.isArrowFunctionExpression() && parent.node.body === node && CHILD_THUNK in parent.node) {
       return make;
@@ -973,6 +1000,40 @@ function keptChild(state, run, make, cells) {
   ];
   return t.callExpression(generated(t.arrowFunctionExpression([], t.blockStatement(body))), []);
 }
+function isPure(node) {
+  switch (node.type) {
+    case "Identifier":
+    case "ThisExpression":
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+    case "NullLiteral":
+    case "BigIntLiteral":
+    case "RegExpLiteral":
+      return true;
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return isPure(node.object) && (!node.computed || isPure(node.property));
+    case "UnaryExpression":
+      return node.operator !== "delete" && isPure(node.argument);
+    case "BinaryExpression":
+      return isPure(node.left) && isPure(node.right);
+    case "LogicalExpression":
+      return isPure(node.left) && isPure(node.right);
+    case "ConditionalExpression":
+      return isPure(node.test) && isPure(node.consequent) && isPure(node.alternate);
+    case "TemplateLiteral":
+      return node.expressions.every((one) => t.isExpression(one) && isPure(one));
+    case "ArrayExpression":
+      return node.elements.every((one) => one === null || t.isExpression(one) && isPure(one));
+    case "ObjectExpression":
+      return node.properties.every(
+        (one) => t.isObjectProperty(one) && !one.computed && t.isExpression(one.value) && isPure(one.value)
+      );
+    default:
+      return false;
+  }
+}
 function propertyKey(name) {
   return t.isValidIdentifier(name) ? t.identifier(name) : t.stringLiteral(name);
 }
@@ -996,6 +1057,120 @@ function attributeValue(attribute) {
 function isStaticValue(value) {
   return t.isStringLiteral(value) || t.isNumericLiteral(value) || t.isBooleanLiteral(value) || t.isNullLiteral(value);
 }
+function pushText(markup, text) {
+  markup.parts[markup.parts.length - 1] = markup.parts[markup.parts.length - 1] + text;
+}
+function pushHole(markup, value) {
+  markup.values.push(value);
+  markup.parts.push("");
+}
+function compileMarkup(path, state) {
+  const markup = { parts: [""], values: [] };
+  emitMarkupElement(path.node, markup, state);
+  if (markup.values.length === 0) {
+    return t.callExpression(runtime(state, "ssr"), [
+      t.arrayExpression([t.stringLiteral(markup.parts[0])])
+    ]);
+  }
+  return t.callExpression(runtime(state, "ssr"), [
+    t.arrayExpression(markup.parts.map((part) => t.stringLiteral(part))),
+    ...markup.values
+  ]);
+}
+function emitMarkupElement(node, markup, state) {
+  const name = node.openingElement.name;
+  if (!t.isJSXIdentifier(name)) {
+    const namespaced = name;
+    throw new Error(
+      `Namespaced element names are not supported: <${namespaced.namespace.name}:${namespaced.name.name}>. Write the element without a namespace; SVG children are resolved by the parser.`
+    );
+  }
+  const tag = name.name;
+  pushText(markup, `<${tag}`);
+  for (const attribute of node.openingElement.attributes) {
+    emitMarkupAttribute(attribute, markup, state);
+  }
+  pushText(markup, ">");
+  emitMarkupChildren(node.children, markup, state);
+  if (!VOID_ELEMENTS.has(tag)) {
+    pushText(markup, `</${tag}>`);
+  }
+}
+function emitMarkupAttribute(attribute, markup, state) {
+  if (t.isJSXSpreadAttribute(attribute)) {
+    pushHole(markup, t.callExpression(runtime(state, "spread"), [attribute.argument]));
+    return;
+  }
+  const name = attributeName(attribute);
+  const value = attributeValue(attribute);
+  if (name === "ref" || name.startsWith("on") && name.length > 2 && /[A-Z:]/.test(name[2])) {
+    return;
+  }
+  if (name === "key") {
+    return;
+  }
+  if (value === null) {
+    pushText(markup, ` ${name}=""`);
+    return;
+  }
+  if (isStaticValue(value)) {
+    if (t.isBooleanLiteral(value) && !value.value) {
+      return;
+    }
+    if (t.isNullLiteral(value)) {
+      return;
+    }
+    const literal = t.isStringLiteral(value) ? value.value : t.isNumericLiteral(value) ? String(value.value) : "";
+    pushText(markup, ` ${name}="${escapeAttribute(literal)}"`);
+    return;
+  }
+  pushHole(markup, markupAttributeCall(name, value, state));
+}
+function markupAttributeCall(name, value, state) {
+  if (name.startsWith("prop:")) {
+    return t.callExpression(runtime(state, "setProperty"), [t.stringLiteral(name.slice(5)), value]);
+  }
+  if (name.startsWith("attr:")) {
+    return t.callExpression(runtime(state, "setAttribute"), [
+      t.stringLiteral(name.slice(5)),
+      value
+    ]);
+  }
+  if (name === "class" || name === "className") {
+    return t.callExpression(runtime(state, "setClass"), [value]);
+  }
+  if (name === "style") {
+    return t.callExpression(runtime(state, "setStyle"), [value]);
+  }
+  if (BOOLEAN_PROPERTIES.has(name)) {
+    return t.callExpression(runtime(state, "setBoolean"), [t.stringLiteral(name), value]);
+  }
+  if (DOM_PROPERTIES.has(name)) {
+    return t.callExpression(runtime(state, "setProperty"), [t.stringLiteral(name), value]);
+  }
+  return t.callExpression(runtime(state, "setAttribute"), [t.stringLiteral(name), value]);
+}
+function emitMarkupChildren(children, markup, state) {
+  const entries = planChildren(children);
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (entry.kind === "text") {
+      pushText(markup, escapeText(entry.text));
+      continue;
+    }
+    if (entry.kind === "element") {
+      emitMarkupElement(entry.element, markup, state);
+      continue;
+    }
+    if (entries.length > 1) {
+      pushText(markup, "<!--[-->");
+    }
+    pushHole(markup, t.callExpression(runtime(state, "child"), [entry.expression]));
+    if (i !== entries.length - 1) {
+      pushText(markup, "<!---->");
+    }
+  }
+}
 function compileTemplate(path, state) {
   let names = 0;
   const statements = [];
@@ -1404,7 +1579,7 @@ function emitChildren(children, build, self, state) {
     const id = build.next();
     build.statements.push(
       t.variableDeclaration("const", [
-        t.variableDeclarator(id, navigate(self, previous, previousIndex, index))
+        t.variableDeclarator(id, navigate(self, previous, previousIndex, index, state))
       ])
     );
     previous = id;
@@ -1490,18 +1665,21 @@ function needsReference(element) {
   }
   return false;
 }
-function navigate(self, previous, previousIndex, index) {
+function navigate(self, previous, previousIndex, index, state) {
+  const hydratable = state.firsthand.hydratable;
+  const first = hydratable ? runtime(state, "first") : null;
+  const next = hydratable ? runtime(state, "next") : null;
   let expression;
   let steps;
   if (previous === null) {
-    expression = t.memberExpression(t.cloneNode(self), t.identifier("firstChild"));
+    expression = hydratable ? t.callExpression(first, [t.cloneNode(self)]) : t.memberExpression(t.cloneNode(self), t.identifier("firstChild"));
     steps = index;
   } else {
     expression = t.cloneNode(previous);
     steps = index - previousIndex;
   }
   for (let i = 0; i < steps; i++) {
-    expression = t.memberExpression(expression, t.identifier("nextSibling"));
+    expression = hydratable ? t.callExpression(next, [expression]) : t.memberExpression(expression, t.identifier("nextSibling"));
   }
   return expression;
 }
@@ -1560,23 +1738,37 @@ function cleanText(value) {
   }
   return kept.join(" ");
 }
-function compileChildren(children, state) {
+function compileChildren(children, state, kept) {
   const result = [];
   for (const entry of planChildren(children)) {
     if (entry.kind === "text") {
       result.push(t.stringLiteral(entry.text));
     } else if (entry.kind === "element") {
       result.push(entry.element);
+    } else if (state.firsthand.ssr) {
+      result.push(entry.expression);
     } else if (entry.kind === "list") {
-      result.push(t.callExpression(runtime(state, "part"), [entry.expression]));
+      const list = entry.expression;
+      keepReading(list, kept);
+      result.push(t.callExpression(runtime(state, "part"), [list]));
     } else {
-      result.push(
-        t.callExpression(runtime(state, "part"), [thunk(entry.expression)])
-      );
+      const value = entry.expression;
+      const read = kept !== void 0 && kept.depends(value) ? kept.cell(value) : value;
+      result.push(t.callExpression(runtime(state, "part"), [thunk(read)]));
     }
   }
   return result;
 }
+function keepReading(list, kept) {
+  const each = list.arguments[0];
+  if (kept === void 0 || !t.isArrowFunctionExpression(each) || !t.isExpression(each.body)) {
+    return;
+  }
+  if (!kept.depends(each.body)) {
+    return;
+  }
+  each.body = kept.value(each.body);
+}
 function thunk(expression) {
   const arrow = t.arrowFunctionExpression([], expression);
   arrow[CHILD_THUNK] = true;
@@ -1637,7 +1829,9 @@ function buildPlugins(options) {
     {
       packageName: options.packageName,
       strictReactivity: options.strictReactivity,
-      devtools: options.devtools
+      devtools: options.devtools,
+      ssr: options.ssr,
+      hydratable: options.hydratable
     }
   ]);
   return plugins;

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   firsthandPlugin,
   stableId,
   transform
-} from "./chunk-NFKHWAYO.js";
+} from "./chunk-GUVVHV7H.js";
 export {
   compileModule,
   firsthandPlugin,

package/dist/transform.d.ts

@@ -22,6 +22,10 @@ type FirsthandState = {
     views: Map<string, t.Identifier>;
     /** Every function markup was written inside, for resolving tags locally. */
     viewNodes: Set<t.Node>;
+    /** Whether this module is being compiled for a server render. */
+    ssr: boolean;
+    /** Whether this module's output has to be able to adopt server markup. */
+    hydratable: boolean;
     /** Functions that run again as a whole, and where each keeps its sites. */
     runs: Map<t.Node, RunContext>;
 };
@@ -71,6 +75,26 @@ export type FirsthandPluginOptions = {
      * production build emits nothing.
      */
     devtools?: boolean;
+    /**
+     * Compile for a server render.
+     *
+     * The same source, emitted against `@firsthandjs/server/internal` instead of
+     * `@firsthandjs/dom/internal`: markup is built as a string rather than as
+     * nodes, and the things a server cannot do — listeners, refs, retained
+     * sites — are not emitted at all.
+     *
+     * The Vite plugin sets this from the bundler's own `ssr` flag, so an
+     * application configures nothing.
+     */
+    ssr?: boolean;
+    /**
+     * Emit navigation that can walk server markup.
+     *
+     * An application that hydrates needs it; one that does not should leave it
+     * off, because it turns two property reads per dynamic position into two
+     * calls. The Vite plugin sets it for a project that has a server build.
+     */
+    hydratable?: boolean;
 };
 export default function firsthandPlugin(_api: unknown, options?: FirsthandPluginOptions): PluginObject;
 export {};

package/dist/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,aAAa,CAAC;AAE5D,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAelC,KAAK,cAAc,GAAG;IACpB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;IACnC,SAAS,EAAE,CAAC,CAAC,kBAAkB,EAAE,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;IACjC,4EAA4E;IAC5E,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACvB,2EAA2E;IAC3E,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;CAC/B,CAAC;AAEF;;;;;;;;;GASG;AACH,KAAK,UAAU,GAAG;IAChB,6EAA6E;IAC7E,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC;IACb,KAAK,EAAE,CAAC,CAAC,UAAU,CAAC;IACpB,IAAI,EAAE,MAAM,MAAM,CAAC;CACpB,CAAC;AAyBF,OAAO,QAAQ,aAAa,CAAC;IAC3B,UAAU,UAAU;QAClB,SAAS,EAAE,cAAc,CAAC;KAC3B;CACF;AA2BD,MAAM,MAAM,sBAAsB,GAAG;IACnC,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,sBAA2B,GACnC,YAAY,CAmEd"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,aAAa,CAAC;AAE5D,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAgBlC,KAAK,cAAc,GAAG;IACpB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;IACnC,SAAS,EAAE,CAAC,CAAC,kBAAkB,EAAE,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;IACjC,4EAA4E;IAC5E,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACvB,iEAAiE;IACjE,GAAG,EAAE,OAAO,CAAC;IACb,0EAA0E;IAC1E,UAAU,EAAE,OAAO,CAAC;IACpB,2EAA2E;IAC3E,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;CAC/B,CAAC;AAEF;;;;;;;;;GASG;AACH,KAAK,UAAU,GAAG;IAChB,6EAA6E;IAC7E,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC;IACb,KAAK,EAAE,CAAC,CAAC,UAAU,CAAC;IACpB,IAAI,EAAE,MAAM,MAAM,CAAC;CACpB,CAAC;AAyBF,OAAO,QAAQ,aAAa,CAAC;IAC3B,UAAU,UAAU;QAClB,SAAS,EAAE,cAAc,CAAC;KAC3B;CACF;AA2BD,MAAM,MAAM,sBAAsB,GAAG;IACnC,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;;;;OAUG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;IACd;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,sBAA2B,GACnC,YAAY,CAiFd"}

package/dist/vite.d.ts

@@ -7,7 +7,9 @@ export type VitePluginLike = {
     configResolved(config: {
         command: string;
     }): void;
-    transform(code: string, id: string): {
+    transform(code: string, id: string, options?: {
+        ssr?: boolean | undefined;
+    }): {
         code: string;
         map: SourceMap | null;
     } | null;

package/dist/vite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../src/vite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAE7D,0FAA0F;AAC1F,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,KAAK,CAAC;IACf,cAAc,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAClD,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;CACrF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,sBAAsB,GAAG;IAC1D;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,wBAAgB,SAAS,CAAC,OAAO,GAAE,oBAAyB,GAAG,cAAc,CAkC5E"}
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../src/vite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAE7D,0FAA0F;AAC1F,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,KAAK,CAAC;IACf,cAAc,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAClD,SAAS,CACP,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EAIV,OAAO,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KAAE,GACtC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;CACnD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,sBAAsB,GAAG;IAC1D;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,wBAAgB,SAAS,CAAC,OAAO,GAAE,oBAAyB,GAAG,cAAc,CAsC5E"}

package/dist/vite.js

@@ -1,6 +1,6 @@
 import {
   compileModule
-} from "./chunk-NFKHWAYO.js";
+} from "./chunk-GUVVHV7H.js";
 
 // packages/compiler/src/vite.ts
 function firsthand(options = {}) {
@@ -11,7 +11,7 @@ function firsthand(options = {}) {
     configResolved(config) {
       serving = config.command === "serve";
     },
-    transform(code, id) {
+    transform(code, id, hook) {
       const file = id.split("?")[0];
       if (!file.endsWith(".tsx") && !file.endsWith(".jsx")) {
         return null;
@@ -27,7 +27,11 @@ function firsthand(options = {}) {
         typescript: file.endsWith(".tsx"),
         devtools: serving,
         sourceMaps: true,
-        ...options
+        ...options,
+        // The bundler already knows which build this is. An explicit `ssr`
+        // option still wins, because a project that compiles a module by hand
+        // has its own reasons.
+        ssr: options.ssr ?? hook?.ssr === true
       });
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firsthandjs/compiler",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Build-time TSX transform for Firsthand: static markup into templates, dynamic expressions into DOM parts.",
   "license": "MIT",
   "type": "module",