@wular/coder 0.4.2 → 0.4.4

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-v1ags1na.js

@@ -0,0 +1,132 @@
+// @bun
+// src/compat/ppr/root-params-scan.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import path from "path";
+var LAYOUT_BASENAMES = ["layout.tsx", "layout.ts", "layout.jsx", "layout.js"];
+function isRootLayoutSource(source) {
+  return /<html[\s>]/.test(source);
+}
+function paramNameOfSegment(segment) {
+  const optional = /^\[\[\.\.\.(.+)\]\]$/.exec(segment);
+  if (optional)
+    return optional[1];
+  const catchAll = /^\[\.\.\.(.+)\]$/.exec(segment);
+  if (catchAll)
+    return catchAll[1];
+  const dynamic = /^\[(.+)\]$/.exec(segment);
+  if (dynamic)
+    return dynamic[1];
+  return;
+}
+function findLayoutFile(dir) {
+  for (const base of LAYOUT_BASENAMES) {
+    const candidate = path.join(dir, base);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return;
+}
+function scanRootParams(appPath) {
+  const rootParams = new Set;
+  if (!existsSync(appPath))
+    return rootParams;
+  const walk = (dir, paramsAbove) => {
+    const layoutFile = findLayoutFile(dir);
+    if (layoutFile) {
+      let source = "";
+      try {
+        source = readFileSync(layoutFile, "utf8");
+      } catch {
+        source = "";
+      }
+      if (isRootLayoutSource(source)) {
+        for (const name of paramsAbove)
+          rootParams.add(name);
+      }
+    }
+    let children = [];
+    try {
+      children = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const child of children) {
+      const childPath = path.join(dir, child);
+      let isDir = false;
+      try {
+        isDir = statSync(childPath).isDirectory();
+      } catch {
+        isDir = false;
+      }
+      if (!isDir)
+        continue;
+      if (child.startsWith("@"))
+        continue;
+      const param = paramNameOfSegment(child);
+      walk(childPath, param ? [...paramsAbove, param] : paramsAbove);
+    }
+  };
+  walk(appPath, []);
+  return rootParams;
+}
+function scanRootParamTypes(appPath) {
+  const roots = [];
+  if (!existsSync(appPath))
+    return new Map;
+  const walk = (dir, paramsAbove) => {
+    const layoutFile = findLayoutFile(dir);
+    if (layoutFile) {
+      let source = "";
+      try {
+        source = readFileSync(layoutFile, "utf8");
+      } catch {
+        source = "";
+      }
+      if (isRootLayoutSource(source)) {
+        const params = new Map;
+        for (const { name, segment } of paramsAbove) {
+          params.set(name, segment.startsWith("[[...") ? ["string[]", "undefined"] : segment.startsWith("[...") ? ["string[]"] : ["string"]);
+        }
+        roots.push(params);
+      }
+    }
+    let children = [];
+    try {
+      children = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const child of children) {
+      const childPath = path.join(dir, child);
+      let isDir = false;
+      try {
+        isDir = statSync(childPath).isDirectory();
+      } catch {
+        isDir = false;
+      }
+      if (!isDir)
+        continue;
+      if (child.startsWith("@"))
+        continue;
+      const param = paramNameOfSegment(child);
+      walk(childPath, param ? [...paramsAbove, { name: param, segment: child }] : paramsAbove);
+    }
+  };
+  walk(appPath, []);
+  const combined = new Map;
+  for (const params of roots) {
+    for (const [name, types] of params) {
+      const set = combined.get(name) ?? new Set;
+      for (const type of types)
+        set.add(type);
+      combined.set(name, set);
+    }
+  }
+  for (const [name, set] of combined) {
+    if (roots.some((params) => !params.has(name)))
+      set.add("undefined");
+  }
+  return combined;
+}
+
+export { scanRootParams, scanRootParamTypes };

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-vmr35jjw.js

@@ -0,0 +1,170 @@
+// @bun
+import {
+  rewriteFacts
+} from "./index-x9c55pzy.js";
+import {
+  loadNative
+} from "./index-7wc9n8be.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/compat/next/link-transform.ts
+var parseSync = (...args) => loadNative(() => __require("oxc-parser")).parseSync(...args);
+var marker = "__pnextLegacyChildKind";
+function rewriteLegacyLinkValidation(source, file) {
+  if (!source.includes("Link") && !source.includes("legacyBehavior"))
+    return source;
+  const imports = rewriteFacts(file, source).imports;
+  const directLink = imports.some((statement) => statement.specifier === "next/link") && source.includes("legacyBehavior");
+  const asyncLinkWrapper = imports.some((statement) => statement.bindings.some((binding) => !binding.type && binding.local.endsWith("Link"))) && /<[A-Za-z_$][\w$]*Link\b/.test(source) && /\basync\s+function\b/.test(source);
+  if (!directLink && !asyncLinkWrapper)
+    return source;
+  const program = parseSync(file, source, { lang: langForFile(file) }).program;
+  const linkNames = new Set;
+  const asyncNames = new Set;
+  const functionNames = new Set;
+  const lazyNames = new Set;
+  const edits = [];
+  const isClient = program.body.some((statement) => statement.type === "ExpressionStatement" && statement.directive === "use client");
+  for (const statement of program.body) {
+    if (statement.type === "ImportDeclaration" && sourceValue(statement) === "next/link") {
+      for (const specifier of statement.specifiers ?? []) {
+        const local = identifierName(specifier.local);
+        if (!local)
+          continue;
+        if (specifier.type === "ImportDefaultSpecifier")
+          linkNames.add(local);
+        else if (identifierName(specifier.imported) === "Link")
+          linkNames.add(local);
+      }
+    }
+    if (statement.type === "FunctionDeclaration") {
+      const name = identifierName(statement.id);
+      if (name) {
+        functionNames.add(name);
+        if (statement.async === true)
+          asyncNames.add(name);
+      }
+    }
+    if (statement.type === "VariableDeclaration") {
+      for (const declarator of statement.declarations ?? []) {
+        const name = identifierName(declarator.id);
+        const init = declarator.init;
+        if (!name || !init)
+          continue;
+        if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") {
+          functionNames.add(name);
+          if (init.async === true)
+            asyncNames.add(name);
+        }
+        if (isLazyCall(init))
+          lazyNames.add(name);
+      }
+    }
+  }
+  walk(program.body, (node) => {
+    if (node.type !== "JSXElement")
+      return;
+    const element = node;
+    if (element.closingElement === null)
+      return;
+    annotate(element);
+  });
+  function annotate(element) {
+    const opening = element.openingElement;
+    if (opening.name.type !== "JSXIdentifier" || hasMarker(opening))
+      return;
+    const parent = opening.name.name ?? "";
+    const isLink = linkNames.has(parent);
+    if (!isLink && !parent.endsWith("Link"))
+      return;
+    const children = element.children.filter(isMeaningfulChild);
+    if (children.length !== 1)
+      return;
+    const kind = childKind(children[0]);
+    if (!kind || !isLink && kind !== "server-async")
+      return;
+    const annotatedKind = !isLink ? "server-async-through-client" : isClient && kind === "lazy" ? "client-lazy" : kind;
+    edits.push({ at: opening.name.end, text: ` ${marker}="${annotatedKind}"` });
+  }
+  function childKind(child) {
+    let name;
+    if (child.type === "JSXElement") {
+      const opening = child.openingElement;
+      if (opening.name.type === "JSXIdentifier")
+        name = opening.name.name;
+    } else if (child.type === "JSXExpressionContainer") {
+      const expression = child.expression;
+      if (expression?.type === "Identifier")
+        name = expression.name;
+    }
+    if (!name)
+      return;
+    if (lazyNames.has(name))
+      return "lazy";
+    if (asyncNames.has(name))
+      return "server-async";
+    if (!isClient && functionNames.has(name))
+      return "server-sync";
+    return;
+  }
+  if (edits.length === 0)
+    return source;
+  let output = source;
+  for (const edit of edits.sort((a, b) => b.at - a.at)) {
+    output = output.slice(0, edit.at) + edit.text + output.slice(edit.at);
+  }
+  return output;
+}
+function isMeaningfulChild(child) {
+  if (child.type === "JSXText") {
+    return typeof child.value === "string" && child.value.trim().length > 0;
+  }
+  if (child.type === "JSXExpressionContainer") {
+    return child.expression?.type !== "JSXEmptyExpression";
+  }
+  return true;
+}
+function hasMarker(opening) {
+  return opening.attributes.some((attribute) => attribute.type === "JSXAttribute" && attribute.name?.name === marker);
+}
+function isLazyCall(expression) {
+  if (expression.type !== "CallExpression")
+    return false;
+  const callee = expression.callee;
+  if (!callee)
+    return false;
+  if (callee.type === "Identifier")
+    return callee.name === "lazy";
+  return callee.type === "MemberExpression" && identifierName(callee.property) === "lazy";
+}
+function identifierName(node) {
+  const named = node;
+  return typeof named?.name === "string" ? named.name : undefined;
+}
+function sourceValue(statement) {
+  const literal = statement.source;
+  return typeof literal?.value === "string" ? literal.value : undefined;
+}
+function walk(node, visit) {
+  if (Array.isArray(node)) {
+    for (const item of node)
+      walk(item, visit);
+    return;
+  }
+  if (!node || typeof node !== "object")
+    return;
+  const candidate = node;
+  if (typeof candidate.type === "string")
+    visit(candidate);
+  for (const key in candidate) {
+    if (key !== "type")
+      walk(candidate[key], visit);
+  }
+}
+function langForFile(file) {
+  return /\.[cm]?ts$/.test(file) ? "ts" : "tsx";
+}
+
+export { rewriteLegacyLinkValidation };

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-vz0km5qk.js

@@ -0,0 +1,33 @@
+// @bun
+// src/utils/trace-flags.ts
+function parseTraceFlags(raw) {
+  const scopes = new Map;
+  for (const entry of raw?.split(",") ?? []) {
+    const trimmed = entry.trim();
+    if (!trimmed)
+      continue;
+    const eq = trimmed.indexOf("=");
+    const name = eq === -1 ? trimmed : trimmed.slice(0, eq).trim();
+    if (!name)
+      continue;
+    scopes.set(name === "1" ? "boot" : name, eq === -1 ? "" : trimmed.slice(eq + 1).trim());
+  }
+  return scopes;
+}
+var scopes;
+var all = false;
+function flags() {
+  if (!scopes) {
+    scopes = parseTraceFlags(process.env.PNEXT_TRACE);
+    all = scopes.has("all");
+  }
+  return scopes;
+}
+function traceEnabled(scope) {
+  return flags().has(scope) || all;
+}
+function traceValue(scope) {
+  return flags().get(scope) || undefined;
+}
+
+export { traceEnabled, traceValue };

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-w6h8m6vp.js

@@ -0,0 +1,138 @@
+// @bun
+import {
+  wrapComponentForPrimitiveThrows
+} from "./index-79ngvam8.js";
+
+// src/compat/react/parity.ts
+import { options } from "preact";
+var reactForwardRefSymbol = Symbol.for("react.forward_ref");
+var react19RefCompatInstalled = Symbol.for("pnext.react19-ref-compat-installed");
+var reactTextSeparatorSymbol = /* @__PURE__ */ Symbol.for("pnext.react-text-separator");
+var reactCompatActive = true;
+function setReactCompatActive(active) {
+  reactCompatActive = active;
+}
+var suspenseParity;
+function setSuspenseParity(pass) {
+  suspenseParity = pass;
+}
+var pnextOptions = options;
+if (!pnextOptions[react19RefCompatInstalled]) {
+  const previousVNode = options.vnode?.bind(options);
+  options.vnode = (vnode) => {
+    previousVNode?.(vnode);
+    if (!reactCompatActive)
+      return;
+    applyReact19RefProp(vnode);
+    suspenseParity?.beforeThrowSafety(vnode);
+    applyPrimitiveThrowSafety(vnode);
+    suspenseParity?.afterThrowSafety(vnode);
+    applyStrayDocumentChildren(vnode);
+    applyReactTextSeparators(vnode);
+  };
+  pnextOptions[react19RefCompatInstalled] = true;
+  if (typeof window !== "undefined" && typeof MessageChannel !== "undefined") {
+    const queue = [];
+    const channel = new MessageChannel;
+    channel.port1.onmessage = () => {
+      for (const callback of queue.splice(0))
+        callback();
+    };
+    options.requestAnimationFrame = (callback) => {
+      queue.push(callback);
+      channel.port2.postMessage(null);
+    };
+  }
+}
+function applyStrayDocumentChildren(vnode) {
+  if (typeof window !== "undefined")
+    return;
+  if (vnode.type !== "html")
+    return;
+  const props = vnode.props;
+  const children = props.children;
+  if (!Array.isArray(children))
+    return;
+  const kept = [];
+  const stray = [];
+  let body;
+  for (const child of children) {
+    const type = isElementVNode(child) ? child.type : undefined;
+    if (type === "body")
+      body = child;
+    if (type === "head" || type === "body" || !mayRenderContent(child)) {
+      kept.push(child);
+      continue;
+    }
+    stray.push(child);
+  }
+  if (!body || stray.length === 0)
+    return;
+  const bodyProps = body.props;
+  const bodyChildren = bodyProps.children;
+  bodyProps.children = [
+    ...stray,
+    ...Array.isArray(bodyChildren) ? bodyChildren : [bodyChildren]
+  ];
+  props.children = kept;
+}
+function isElementVNode(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+function mayRenderContent(child) {
+  if (child == null || typeof child === "boolean")
+    return false;
+  return typeof child === "string" ? child.trim() !== "" : true;
+}
+function applyReactTextSeparators(vnode) {
+  if (typeof window !== "undefined")
+    return;
+  const props = vnode.props;
+  const children = props.children;
+  if (!Array.isArray(children) || children.length < 2)
+    return;
+  const values = children;
+  const separated = [];
+  let changed = false;
+  for (let index = 0;index < values.length; index += 1) {
+    const child = values[index];
+    separated.push(child);
+    if (!mayRenderText(child) || !mayRenderText(values[index + 1]))
+      continue;
+    separated.push({
+      type: reactTextSeparatorSymbol,
+      props: { UNSTABLE_comment: " " }
+    });
+    changed = true;
+  }
+  if (changed)
+    props.children = separated;
+}
+function mayRenderText(value) {
+  if (typeof value === "string" || typeof value === "number")
+    return true;
+  if (!value || typeof value !== "object" || !("type" in value))
+    return false;
+  return typeof value.type !== "string";
+}
+function applyPrimitiveThrowSafety(vnode) {
+  if (typeof window === "undefined")
+    return;
+  if (typeof vnode.type !== "function")
+    return;
+  vnode.type = wrapComponentForPrimitiveThrows(vnode.type);
+}
+function applyReact19RefProp(vnode) {
+  if (!vnode.ref || typeof vnode.type !== "function")
+    return;
+  const component = vnode.type;
+  if (component.prototype?.render || component.$$typeof === reactForwardRefSymbol)
+    return;
+  vnode.props = {
+    ...vnode.props,
+    ref: vnode.ref
+  };
+  vnode.ref = null;
+}
+
+export { setReactCompatActive, setSuspenseParity };

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-web361b8.js

@@ -0,0 +1,138 @@
+// @bun
+import {
+  restoreWithExtensionHost
+} from "./index-zqpqyg8p.js";
+
+// src/render/hooks.ts
+function nextCompatEnabled(config) {
+  return Boolean(config.compat?.next);
+}
+function reactCompatEnabled(config) {
+  return Boolean(config.compat?.next || config.compat?.react || config.compat?.reactCompiler);
+}
+var fontExtensions = {
+  runWithFontScope: (callback) => callback(),
+  collectFontAssets: () => Promise.resolve({ css: "", preloads: [] }),
+  prewarmFontAssets: () => Promise.resolve(),
+  releaseFonts: () => Promise.resolve({})
+};
+function getFontExtensions() {
+  return fontExtensions;
+}
+function setFontExtensions(overrides) {
+  Object.assign(fontExtensions, overrides);
+}
+var suspenseExtensions = {
+  ensureCompatSuspense: () => Promise.resolve(),
+  compatSuspenseType: () => {
+    return;
+  }
+};
+function getSuspenseExtensions() {
+  return suspenseExtensions;
+}
+function setSuspenseExtensions(overrides) {
+  Object.assign(suspenseExtensions, overrides);
+}
+var streamRouteExtensions = {
+  canStreamRoute: () => true,
+  inlineSuspenseStream: () => false
+};
+function getStreamRouteExtensions() {
+  return streamRouteExtensions;
+}
+function setStreamRouteExtensions(overrides) {
+  Object.assign(streamRouteExtensions, overrides);
+}
+var streamBoundaryExtensions = {
+  onStreamBoundaryError: () => {
+    return;
+  }
+};
+function setStreamBoundaryExtensions(overrides) {
+  Object.assign(streamBoundaryExtensions, overrides);
+}
+function reportStreamBoundaryError(error) {
+  try {
+    const result = streamBoundaryExtensions.onStreamBoundaryError(error);
+    if (isThenable(result)) {
+      Promise.resolve(result).catch((reportError) => {
+        console.error("stream boundary error hook failed:", reportError);
+      });
+    }
+  } catch (reportError) {
+    console.error("stream boundary error hook failed:", reportError);
+  }
+}
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+var metadataExtensions = {};
+function getActiveMetadataExtensions(config) {
+  return metadataExtensions.enabled?.(config) ? metadataExtensions : {};
+}
+function setMetadataExtensions(overrides) {
+  Object.assign(metadataExtensions, overrides);
+}
+var documentScriptExtensions = {
+  stylesheetPrecedence: () => {
+    return;
+  },
+  documentBodyScripts: () => ""
+};
+function getDocumentScriptExtensions() {
+  return documentScriptExtensions;
+}
+function setDocumentScriptExtensions(overrides) {
+  Object.assign(documentScriptExtensions, overrides);
+}
+var staticParamsExtensions = {
+  normalizeModule: (module) => typeof module.params === "function" || typeof module.generateStaticParams !== "function" ? module : { ...module, params: module.generateStaticParams }
+};
+function getStaticParamsExtensions() {
+  return staticParamsExtensions;
+}
+function setStaticParamsExtensions(overrides) {
+  Object.assign(staticParamsExtensions, overrides);
+}
+var actionModuleExtensions = {
+  tagActionModulesForRender: () => Promise.resolve(),
+  tagActionModuleExports: () => {
+    return;
+  }
+};
+function getActionModuleExtensions() {
+  return actionModuleExtensions;
+}
+function setActionModuleExtensions(overrides) {
+  Object.assign(actionModuleExtensions, overrides);
+}
+var renderSpanExtensions = {
+  withRenderBodySpan: (_route, fn) => fn(),
+  withFindPageComponentsSpan: (_route, fn) => fn(),
+  emitResolveSegmentSpan: () => {
+    return;
+  },
+  withRouteHandlerSpan: (_route, fn) => fn()
+};
+function getRenderSpanExtensions() {
+  return renderSpanExtensions;
+}
+function setRenderSpanExtensions(overrides) {
+  Object.assign(renderSpanExtensions, overrides);
+}
+for (const registry of [
+  fontExtensions,
+  suspenseExtensions,
+  streamRouteExtensions,
+  streamBoundaryExtensions,
+  metadataExtensions,
+  documentScriptExtensions,
+  staticParamsExtensions,
+  actionModuleExtensions,
+  renderSpanExtensions
+]) {
+  restoreWithExtensionHost(registry);
+}
+
+export { nextCompatEnabled, reactCompatEnabled, getFontExtensions, setFontExtensions, getSuspenseExtensions, setSuspenseExtensions, getStreamRouteExtensions, setStreamRouteExtensions, setStreamBoundaryExtensions, reportStreamBoundaryError, getActiveMetadataExtensions, setMetadataExtensions, getDocumentScriptExtensions, setDocumentScriptExtensions, getStaticParamsExtensions, setStaticParamsExtensions, getActionModuleExtensions, setActionModuleExtensions, getRenderSpanExtensions, setRenderSpanExtensions };