@absolutejs/absolute 0.20.0-beta.170 → 0.20.0-beta.172

package/dist/dev/serverBootstrap.js

@@ -739,7 +739,7 @@ var init_workspacePackages = __esm(() => {
 
 // src/dev/hot/analyze.ts
 import { dirname, extname } from "path";
-var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scriptKindFor = (tsc, path) => {
+var ANALYZER_VERSION = 2, hashText = (text) => Bun.hash(text).toString(36), scriptKindFor = (tsc, path) => {
   switch (extname(path)) {
     case ".tsx":
       return tsc.ScriptKind.TSX;
@@ -997,7 +997,23 @@ var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scri
   while (current && (tsc.isParenthesizedExpression(current) || tsc.isAsExpression(current) || tsc.isSatisfiesExpression(current)))
     current = current.expression;
   return current !== undefined && (tsc.isArrowFunction(current) || tsc.isFunctionExpression(current));
-}, IDENTIFIER, rejection = (reason) => ({
+}, IDENTIFIER, STATEFUL_FACTORIES, STATIC_IDENTIFIERS, isStaticExpression = (tsc, node) => {
+  if (tsc.isParenthesizedExpression(node) || tsc.isAsExpression(node) || tsc.isSatisfiesExpression(node) || tsc.isSpreadElement(node) || tsc.isSpreadAssignment(node))
+    return isStaticExpression(tsc, node.expression);
+  if (tsc.isStringLiteral(node) || tsc.isNumericLiteral(node) || tsc.isBigIntLiteral(node) || tsc.isNoSubstitutionTemplateLiteral(node) || tsc.isRegularExpressionLiteral(node) || node.kind === tsc.SyntaxKind.TrueKeyword || node.kind === tsc.SyntaxKind.FalseKeyword || node.kind === tsc.SyntaxKind.NullKeyword || tsc.isOmittedExpression(node))
+    return true;
+  if (tsc.isIdentifier(node))
+    return STATIC_IDENTIFIERS.has(node.text);
+  if (tsc.isPrefixUnaryExpression(node))
+    return isStaticExpression(tsc, node.operand);
+  if (tsc.isArrayLiteralExpression(node))
+    return node.elements.every((element) => isStaticExpression(tsc, element));
+  if (tsc.isObjectLiteralExpression(node))
+    return node.properties.every((property) => tsc.isSpreadAssignment(property) ? isStaticExpression(tsc, property) : tsc.isPropertyAssignment(property) && (!tsc.isComputedPropertyName(property.name) || isStaticExpression(tsc, property.name.expression)) && isStaticExpression(tsc, property.initializer));
+  if (tsc.isTemplateExpression(node))
+    return node.templateSpans.every((span) => isStaticExpression(tsc, span.expression));
+  return false;
+}, rejection = (reason) => ({
   ok: false,
   reason
 }), addImport = (scope, local, binding) => {
@@ -1008,14 +1024,23 @@ var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scri
   if (!clause || clause.isTypeOnly)
     return;
   const specifier = statement.moduleSpecifier;
-  const module = tsc.isStringLiteralLike(specifier) || tsc.isIdentifier(specifier) ? resolveImport(specifier.text) : undefined;
+  const written = tsc.isStringLiteralLike(specifier) || tsc.isIdentifier(specifier) ? specifier.text : undefined;
+  const module = written === undefined ? undefined : resolveImport(written);
   if (clause.name)
-    addImport(scope, clause.name.text, { module, name: "default" });
+    addImport(scope, clause.name.text, {
+      module,
+      name: "default",
+      specifier: written
+    });
   const bindings = clause.namedBindings;
   if (!bindings)
     return;
   if (tsc.isNamespaceImport(bindings)) {
-    addImport(scope, bindings.name.text, { module, name: "*" });
+    addImport(scope, bindings.name.text, {
+      module,
+      name: "*",
+      specifier: written
+    });
     return;
   }
   for (const element of bindings.elements) {
@@ -1023,7 +1048,8 @@ var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scri
       continue;
     addImport(scope, element.name.text, {
       module,
-      name: (element.propertyName ?? element.name).text
+      name: (element.propertyName ?? element.name).text,
+      specifier: written
     });
   }
 }, recordExportList = (tsc, scope, statement) => {
@@ -1397,8 +1423,58 @@ var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scri
       edit(node.getStart(file), node.end - node.getStart(file), replacement);
     }
   };
+  const statefulCall = (reference) => {
+    if (reference.deferred || !reference.call)
+      return;
+    const imported = imports.get(reference.name);
+    const factories = imported?.specifier ? STATEFUL_FACTORIES.get(imported.specifier) : undefined;
+    if (!imported || !factories)
+      return;
+    const viaNamespace = imported.name === "*" && reference.member !== undefined;
+    const name = viaNamespace ? reference.member : imported.name;
+    const callee = viaNamespace ? reference.node.parent : reference.node;
+    const call = callee.parent;
+    if (!name || !factories.has(name) || !call || !tsc.isCallExpression(call) || call.expression !== callee)
+      return;
+    return { call, name };
+  };
+  const ownerId = (statement, node) => {
+    const { node: root } = statement;
+    if (!tsc.isVariableStatement(root))
+      return statement.id;
+    const declaration = root.declarationList.declarations.find((item) => item.pos <= node.pos && node.end <= item.end);
+    const name = declaration ? bindingNames(tsc, declaration.name)[0] : undefined;
+    if (!name)
+      return statement.id;
+    return statement.kind === "let" ? `${statement.id}:${name}` : `v:${name}`;
+  };
+  const rewriteStatefulCalls = (statement) => {
+    if (statement.kind === "import" || statement.kind === "skip")
+      return;
+    const occurrences = new Map;
+    for (const reference of statement.refs) {
+      const found = statefulCall(reference);
+      if (!found)
+        continue;
+      const { call, name } = found;
+      const owner = ownerId(statement, call);
+      const line = file.getLineAndCharacterOfPosition(call.getStart(file)).line + 1;
+      const label = quote(`${name}(\u2026) on line ${line}`);
+      const isStatic = call.arguments.every((argument) => isStaticExpression(tsc, argument));
+      if (!isStatic && hasTopLevelAwait(tsc, call))
+        continue;
+      const textHash = hashText(call.getText(file));
+      const occurrence = occurrences.get(`${owner}#${textHash}`) ?? 0;
+      occurrences.set(`${owner}#${textHash}`, occurrence + 1);
+      const key = quote(`${owner}#${textHash}#${occurrence}`);
+      edit(call.getStart(file), 0, isStatic ? `__absH.p(${quote(owner)},${key},${label},()=>(` : `__absH.w(${quote(owner)},${key},${label},()=>(`);
+      edit(call.end, 0, "))");
+    }
+  };
   for (const statement of statements)
     rewriteStatement(statement);
+  for (const statement of statements)
+    rewriteStatefulCalls(statement);
   for (const statement of statements)
     rewriteCellReferences(statement);
   edits.sort(compareEdits);
@@ -1453,6 +1529,10 @@ var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scri
 };
 var init_analyze = __esm(() => {
   IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+  STATEFUL_FACTORIES = new Map([
+    ["@absolutejs/scoped-state", new Set(["scopedState"])]
+  ]);
+  STATIC_IDENTIFIERS = new Set(["Infinity", "NaN", "undefined"]);
 });
 
 // src/dev/hot/runtime.ts
@@ -1464,6 +1544,7 @@ var records, recordFor = (path) => {
   const created = {
     cells: {},
     generation: 0,
+    instances: new Map,
     keys: new Map,
     lastChanged: new Set,
     lastTimings: new Map,
@@ -1472,6 +1553,7 @@ var records, recordFor = (path) => {
     revisions: new Map,
     slots: new Map,
     tag: 0,
+    warned: new Set,
     watchers: new Map
   };
   records.set(path, created);
@@ -1514,6 +1596,7 @@ var records, recordFor = (path) => {
   record.generation += 1;
   const pending = {
     generation: record.generation,
+    instances: new Map,
     meta,
     reran: new Set,
     seen: new Set,
@@ -1549,6 +1632,7 @@ var records, recordFor = (path) => {
     pending.slots.set(id, { generation, value });
     return value;
   };
+  const where = (label) => `${label} of ${relative(process.cwd(), path) || path}`;
   return {
     cells: record.cells,
     c: (name, id, init) => {
@@ -1576,6 +1660,14 @@ var records, recordFor = (path) => {
         return previous.value;
       return store(id, await ownedAsync(id, factory));
     },
+    p: (owner, key, label, create) => {
+      const previous = record.instances.get(key);
+      const value = previous ? previous.value : create();
+      if (!previous && record.keys.has(owner))
+        console.log(`[hmr] ${where(label)} is new or changed, so its state starts empty`);
+      pending.instances.set(key, { owner, value });
+      return value;
+    },
     r: (id, effect) => {
       if (kept(id))
         return;
@@ -1587,6 +1679,13 @@ var records, recordFor = (path) => {
         return;
       await ownedAsync(id, effect);
       store(id, undefined);
+    },
+    w: (owner, key, label, create) => {
+      if (record.keys.has(owner) && !record.warned.has(key)) {
+        record.warned.add(key);
+        console.warn(`[hmr] ${where(label)} ran again because its statement re-ran, so the state it holds was reset. Create it in its own top-level const (const visitorState = scopedState({ \u2026 })) and pass that to .use() to keep it across edits.`);
+      }
+      return create();
     }
   };
 }, exportToken = (module, name, call) => {
@@ -1612,6 +1711,12 @@ var records, recordFor = (path) => {
   await Promise.all([...replaced.values()].map((slot) => disposeValue(slot.value).catch((error) => console.error(`[hmr] disposing a replaced value failed:`, error))));
   if (record.generation > 1)
     logDisposed(record.path, counts);
+}, keptInstances = (record, pending) => {
+  const instances = new Map(pending.instances);
+  for (const [key, instance] of record.instances)
+    if (!instances.has(key) && pending.seen.has(instance.owner) && !pending.reran.has(instance.owner))
+      instances.set(key, instance);
+  return instances;
 }, commit = (record, pending) => {
   if (record.pending !== pending)
     return;
@@ -1625,6 +1730,7 @@ var records, recordFor = (path) => {
   record.keys = pending.keys;
   record.lastChanged = pending.changedExports;
   record.lastTimings = pending.timings;
+  record.instances = keptInstances(record, pending);
   for (const name of pending.changedExports)
     record.revisions.set(name, (record.revisions.get(name) ?? 0) + 1);
   if (replaced.size === 0)