@wular/coder 0.3.18 → 0.4.0

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-HT6KKX6A.js

@@ -0,0 +1,18 @@
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire("file:///Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/package.json");
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/utils/ansi.ts
+function color(open, close) {
+  return (value) => process.stdout.isTTY && !process.env.NO_COLOR ? `${open}${value}${close}` : value;
+}
+var dim = color("\x1B[38;5;244m", "\x1B[39m");
+var bold = color("\x1B[1m", "\x1B[22m");
+var cyan = color("\x1B[36m", "\x1B[39m");
+var green = color("\x1B[32m", "\x1B[39m");
+
+export {
+  dim,
+  bold,
+  cyan,
+  green
+};

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-JESFYECC.js

@@ -0,0 +1,436 @@
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire("file:///Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/package.json");
+import {
+  isPrerendering,
+  isRuntimePrefetchPrerender,
+  setCacheComponents
+} from "./chunk-5RDEILQB.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-4P5CMIYT.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/request/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var WORK_UNIT_STORAGE = Symbol.for("pnext.workUnitStorage");
+var workUnitStorage = globalThis[WORK_UNIT_STORAGE] ??= new AsyncLocalStorage();
+function runWithWorkUnit(phase, callback) {
+  const unit = { phase, afterTasks: [], flushed: false };
+  return workUnitStorage.run(unit, callback);
+}
+function getWorkUnit() {
+  return workUnitStorage.getStore();
+}
+function setPhase(phase) {
+  const unit = workUnitStorage.getStore();
+  if (unit) unit.phase = phase;
+}
+function setWorkUnitRoute(routeKind, routeMode, responseHints) {
+  const unit = workUnitStorage.getStore();
+  if (!unit) return;
+  unit.routeKind = routeKind;
+  if (routeMode) unit.routeMode = routeMode;
+  if (responseHints) unit.responseHints = responseHints;
+}
+function queueAfterTask(task) {
+  const unit = workUnitStorage.getStore();
+  if (!unit) return false;
+  unit.afterTasks.push(task);
+  return true;
+}
+function flushWorkUnit(unit = workUnitStorage.getStore()) {
+  if (!unit || unit.flushed) return;
+  unit.flushed = true;
+  if (unit.afterTasks.length === 0) return;
+  const afterUnit = { ...unit, phase: "after" };
+  const flushing = workUnitStorage.run(afterUnit, async () => {
+    while (afterUnit.afterTasks.length) {
+      const tasks = afterUnit.afterTasks;
+      afterUnit.afterTasks = [];
+      for (const task of tasks) {
+        try {
+          await task();
+        } catch (error) {
+          console.error("after() task failed:", error);
+        }
+      }
+    }
+  });
+  pendingFlushes.add(flushing);
+  void flushing.finally(() => pendingFlushes.delete(flushing));
+}
+var pendingFlushes = /* @__PURE__ */ new Set();
+async function drainWorkUnits(timeoutMs = 1e4) {
+  if (pendingFlushes.size === 0) return;
+  await Promise.race([
+    Promise.allSettled([...pendingFlushes]),
+    new Promise((resolve) => setTimeout(resolve, timeoutMs))
+  ]);
+}
+function flushWorkUnitOnClose(response, unit, signal) {
+  if (!unit) return response;
+  if (!response.body) {
+    flushWorkUnit(unit);
+    return response;
+  }
+  if (response.headers.has("content-length")) {
+    flushWorkUnit(unit);
+    return response;
+  }
+  const reader = response.body.getReader();
+  const settle = () => {
+    signal?.removeEventListener("abort", settle);
+    flushWorkUnit(unit);
+  };
+  if (signal?.aborted) settle();
+  else signal?.addEventListener("abort", settle, { once: true });
+  const observed = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          settle();
+          controller.close();
+        } else {
+          controller.enqueue(chunk.value);
+        }
+      } catch (error) {
+        settle();
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      settle();
+      return reader.cancel(reason);
+    }
+  });
+  return new Response(observed, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+var REQUEST_STORAGE = Symbol.for("pnext.requestStorage");
+var requestStorage = globalThis[REQUEST_STORAGE] ??= new AsyncLocalStorage();
+function currentRequest() {
+  return requestStorage.getStore()?.request;
+}
+var WORK_UNIT_EXTERNAL = Symbol.for("pnext.workUnitExternal");
+function workUnitExternalStore() {
+  const request = currentRequest();
+  const type = isRuntimePrefetchPrerender() ? "prerender-runtime" : isPrerendering() || !request ? "prerender" : "request";
+  return {
+    type,
+    cookies: request?.cookies,
+    headers: request?.headers ?? new Headers()
+  };
+}
+globalThis[WORK_UNIT_EXTERNAL] = workUnitExternalStore;
+function runWithRequest(request, callback, params = {}, extras = {}) {
+  if (!request) return callback();
+  const scope = {
+    request,
+    params,
+    afterCallbacks: [],
+    responseHeaders: extras.responseHeaders
+  };
+  const result = requestStorage.run(scope, callback);
+  if (isThenable(result)) {
+    return result.then(
+      (value) => {
+        void flushAfterCallbacks(scope);
+        return value;
+      },
+      (error) => {
+        void flushAfterCallbacks(scope);
+        throw error;
+      }
+    );
+  }
+  void flushAfterCallbacks(scope);
+  return result;
+}
+async function flushAfterCallbacks(scope) {
+  while (scope.afterCallbacks?.length) {
+    const callbacks = scope.afterCallbacks;
+    scope.afterCallbacks = [];
+    for (const callback of callbacks) {
+      try {
+        await requestStorage.run(scope, callback);
+      } catch (error) {
+        console.error("after() callback failed:", error);
+      }
+    }
+  }
+}
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+var BAILOUT_PROBE = Symbol.for("pnext.dynamicBailoutProbe");
+var LEGACY_REQUEST_APIS = Symbol.for("pnext.legacyRequestAPIs");
+function setLegacyRequestAPIs(enabled) {
+  ;
+  globalThis[LEGACY_REQUEST_APIS] = enabled;
+}
+function legacyRequestAPIs() {
+  return globalThis[LEGACY_REQUEST_APIS] === true;
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/config.ts
+import { existsSync, realpathSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import path2 from "node:path";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/env.ts
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { parse } from "/Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/dotenv@16.6.1/node_modules/dotenv/lib/main.js";
+async function loadEnv(root, options = {}) {
+  const nodeEnvKey = "NODE_ENV";
+  const env = process.env;
+  if (!env[nodeEnvKey]) env[nodeEnvKey] = options.dev ? "development" : "production";
+  const mode = process.env[nodeEnvKey] ?? "production";
+  const loadedEnvFiles = [];
+  for (const file of envFilesForMode(mode)) {
+    const filePath = path.join(root, file);
+    if (!await isEnvFile(filePath)) continue;
+    const parsed = parse(await readFile(filePath, "utf8"));
+    const env2 = expandEnv(parsed);
+    for (const [key, value] of Object.entries(env2)) {
+      if (process.env[key] === void 0) process.env[key] = value;
+    }
+    loadedEnvFiles.push({ path: file, env: env2 });
+  }
+  return { mode, loadedEnvFiles };
+}
+function envFilesForMode(mode) {
+  return [
+    `.env.${mode}.local`,
+    mode === "test" ? void 0 : ".env.local",
+    `.env.${mode}`,
+    ".env"
+  ].filter((file) => Boolean(file));
+}
+async function isEnvFile(file) {
+  try {
+    const info = await stat(file);
+    return info.isFile();
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+function expandEnv(parsed) {
+  const env = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    env[key] = expandValue(value, { ...parsed, ...env });
+  }
+  return env;
+}
+function expandValue(value, parsed) {
+  let result = value;
+  for (let index = searchLastEnvReference(result), attempts = 0; index !== -1 && attempts < 100; index = searchLastEnvReference(result), attempts += 1) {
+    const match = result.slice(index).match(/^\$({?)([\w]+)(?::-([^}]*))?}?/);
+    if (!match) break;
+    const token = match[0] ?? "";
+    const braced = match[1] ?? "";
+    const key = match[2] ?? "";
+    const fallback = match[3] ?? "";
+    const hasClosingBrace = braced ? token.endsWith("}") : true;
+    if (!hasClosingBrace) break;
+    const replacement = process.env[key] || fallback || parsed[key] || "";
+    result = `${result.slice(0, index)}${replacement}${result.slice(index + token.length)}`;
+  }
+  return result.replace(/\\\$/g, "$");
+}
+function searchLastEnvReference(value) {
+  const matches = [...value.matchAll(/(?<!\\)\$/g)];
+  return matches.length > 0 ? matches.at(-1)?.index ?? -1 : -1;
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/types.ts
+var PREFETCH_MODES = ["visible", "intent", "load", false];
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/config.ts
+var DEFAULT_OUT_DIR = ".pnext";
+var defaultConfig = {
+  outDir: DEFAULT_OUT_DIR,
+  basePath: ""
+};
+var configSource;
+function registerConfigSource(source) {
+  configSource = source;
+}
+async function resolveConfigSource(config, root, options) {
+  if (!config.compat?.next) return {};
+  if (!configSource) {
+    await import("./config-UREY7XJT.js").then((module) => module.registerConfigSource());
+  }
+  if (!configSource) return {};
+  return configSource(root, options);
+}
+async function loadConfig(rootInput = process.cwd(), options = {}) {
+  const root = canonicalRoot(path2.resolve(rootInput));
+  await loadEnv(root, options);
+  const configPath = path2.join(root, "pnext.config.ts");
+  const loadedConfig = existsSync(configPath) ? await import(pathToFileHref(configPath)) : {};
+  const config = {
+    ...loadedConfig.default ?? {},
+    // eslint-disable-next-line turbo/no-undeclared-env-vars
+    ...process.env.PNEXT_COMPAT === "next" ? {
+      compat: {
+        ...loadedConfig.default?.compat ?? {},
+        // An object `next` already enables compat — keep its options rather than flattening to true.
+        next: loadedConfig.default?.compat?.next || true
+      }
+    } : {}
+  };
+  validateConfig(config);
+  setLegacyRequestAPIs(
+    typeof config.compat?.next === "object" && config.compat.next.legacyRequestAPIs === true
+  );
+  setCacheComponents(false);
+  const sourceOverrides = stripUndefined(await resolveConfigSource(config, root, options));
+  const merged = { ...defaultConfig, ...config, ...sourceOverrides };
+  const appPath = await resolveAppPath(root, config);
+  const outRootPath = path2.resolve(root, merged.outDir);
+  const workspaceRoot = canonicalRoot(
+    config.workspaceRoot ? path2.resolve(root, config.workspaceRoot) : findWorkspaceRoot(root) ?? root
+  );
+  return {
+    ...config,
+    trailingSlash: merged.trailingSlash ?? config.trailingSlash,
+    productionBrowserSourceMaps: merged.productionBrowserSourceMaps ?? config.productionBrowserSourceMaps,
+    skipTrailingSlashRedirect: merged.skipTrailingSlashRedirect ?? config.skipTrailingSlashRedirect,
+    appDir: path2.relative(root, appPath),
+    publicDir: "public",
+    outDir: merged.outDir,
+    basePath: merged.basePath,
+    // Assets are addressed under basePath (the server 404s outside it), so an
+    // app that sets basePath without an explicit assetPrefix serves assets at
+    // `${basePath}/assets/...` — Next's default (assetPrefix falls back to
+    // basePath).
+    assetPrefix: merged.assetPrefix ?? merged.basePath,
+    root,
+    workspaceRoot,
+    appPath,
+    publicPath: path2.resolve(root, "public"),
+    // Dev owns `<outRoot>/dev` exclusively so a concurrent `pnext build` — which
+    // wipes its own outputs under the out root — can never pull a running dev
+    // server's cache, manifest or assets out from under it.
+    outPath: options.dev ? path2.join(outRootPath, devOutSegment) : outRootPath,
+    outRootPath,
+    typesPath: path2.join(outRootPath, "types"),
+    checksPath: path2.join(outRootPath, "typecheck", "checks")
+  };
+}
+var enumFields = [
+  ["prefetch", PREFETCH_MODES]
+];
+function validateConfig(config) {
+  for (const [field, allowed] of enumFields) {
+    const value = config[field];
+    if (value === void 0 || allowed.includes(value)) continue;
+    const list = allowed.map((v) => typeof v === "string" ? `'${v}'` : String(v)).join(", ");
+    throw new Error(
+      `Invalid pnext config: '${field}' must be one of ${list} (received ${JSON.stringify(value)}).`
+    );
+  }
+}
+var devOutSegment = "dev";
+function canonicalRoot(dir) {
+  try {
+    return realpathSync(dir);
+  } catch {
+    return dir;
+  }
+}
+function stripUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
+}
+function pathToFileHref(filePath) {
+  return pathToFileURL(path2.resolve(filePath)).href;
+}
+function publicEnvDefines() {
+  const publicEnv = Object.fromEntries([
+    // eslint-disable-next-line turbo/no-undeclared-env-vars
+    ["NODE_ENV", process.env.NODE_ENV ?? "production"],
+    ...Object.entries(process.env).filter(
+      ([key]) => key.startsWith("NEXT_PUBLIC_") || key.startsWith("PNEXT_PUBLIC_")
+    )
+  ]);
+  return {
+    // The whole object, not just the keys that happen to be SET at build time. A browser has no
+    // `process`, so a `NEXT_PUBLIC_*` the source reads but the environment never defined would
+    // otherwise survive as a bare reference and throw ReferenceError on first evaluation - taking
+    // hydration, and every event handler on the page, down with it. Reading a missing key off this
+    // yields undefined, which is what Next inlines for one.
+    "process.env": JSON.stringify(publicEnv),
+    ...Object.fromEntries(
+      Object.entries(publicEnv).map(([key, value]) => [
+        `process.env.${key}`,
+        JSON.stringify(value)
+      ])
+    )
+  };
+}
+var frameworkRuntimeAliases;
+function frameworkRuntimeAliasEntries() {
+  frameworkRuntimeAliases ??= {
+    preact: resolveRuntimeModule("preact"),
+    "preact/hooks": resolveRuntimeModule("preact/hooks"),
+    "preact/compat": resolveRuntimeModule("preact/compat"),
+    "preact/compat/client": resolveRuntimeModule("preact/compat/client"),
+    "preact/jsx-runtime": resolveRuntimeModule("preact/jsx-runtime"),
+    "preact/jsx-dev-runtime": resolveRuntimeModule("preact/jsx-dev-runtime"),
+    "react-compiler-runtime": resolveRuntimeModule("react-compiler-runtime")
+  };
+  return frameworkRuntimeAliases;
+}
+function resolveRuntimeModule(specifier) {
+  return fileURLToPath(((specifier2) => Bun.pathToFileURL(Bun.resolveSync(specifier2, "/Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src")).href)(specifier));
+}
+function pnextAliases(target) {
+  if (target !== "client") return {};
+  return {
+    "@wular/pnext/cache": path2.resolve("/Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src", "api/client-cache.ts")
+  };
+}
+async function resolveAppPath(root, config) {
+  const rootApp = path2.join(root, "app");
+  if (config.compat?.next) {
+    const pagesPath = path2.join(root, "pages");
+    const hasPages = existsSync(pagesPath);
+    if (existsSync(rootApp)) {
+      if (hasPages) {
+        const { materializePagesApp: materializePagesApp2 } = await import("./router-JNKHLBCZ.js");
+        const hybrid = await materializePagesApp2(root);
+        if (hybrid) return hybrid;
+      }
+      return rootApp;
+    }
+    const { materializePagesApp } = await import("./router-JNKHLBCZ.js");
+    const pagesApp = await materializePagesApp(root);
+    if (pagesApp) return pagesApp;
+  } else if (existsSync(rootApp)) return rootApp;
+  return path2.join(root, "src", "app");
+}
+
+export {
+  runWithWorkUnit,
+  getWorkUnit,
+  setPhase,
+  setWorkUnitRoute,
+  queueAfterTask,
+  flushWorkUnit,
+  drainWorkUnits,
+  flushWorkUnitOnClose,
+  currentRequest,
+  runWithRequest,
+  legacyRequestAPIs,
+  registerConfigSource,
+  loadConfig,
+  pathToFileHref,
+  publicEnvDefines,
+  frameworkRuntimeAliasEntries,
+  pnextAliases
+};

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-JRPJM2XY.js

@@ -0,0 +1,15 @@
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire("file:///Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/package.json");
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/utils/decode.ts
+function safeDecode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+export {
+  safeDecode
+};

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-L2IWDUXG.js

@@ -0,0 +1,105 @@
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire("file:///Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/package.json");
+import {
+  pathToFileHref
+} from "./chunk-JESFYECC.js";
+import {
+  clientReferenceId,
+  moduleExportNames,
+  moduleExportStars
+} from "./chunk-NQE46AZN.js";
+import {
+  readText
+} from "./chunk-2HFY3DQT.js";
+import {
+  resolveImport
+} from "./chunk-4P5CMIYT.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/client/reference-stub.ts
+import path from "node:path";
+var clientReferenceRuntimeFile = path.resolve("/Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/client", "reference.ts");
+function clientReferenceModuleSource(sourceFile, exportNames, options = {}) {
+  const reference = (exportName) => `createReference({ id: ${JSON.stringify(`c-${clientReferenceId(sourceFile, exportName)}`)}, file: ${JSON.stringify(sourceFile)}, exportName: ${JSON.stringify(exportName)} })`;
+  const defaultExport = exportNames.includes("default") ? `export default ${reference("default")};` : "";
+  const namedExports = exportNames.filter((name) => name !== "default").map((name) => `export const ${name} = ${reference(name)};`);
+  const symbol = options.inlineSymbol ? `const clientReferenceSymbol = Symbol.for('pnext.clientReference');` : `import { clientReferenceSymbol } from ${JSON.stringify(pathToFileHref(clientReferenceRuntimeFile))};`;
+  return `${symbol}
+
+function createReference(reference) {
+  function ClientReference({ children }) {
+    return children ?? null;
+  }
+  ClientReference[clientReferenceSymbol] = reference;
+  return ClientReference;
+}
+
+${defaultExport}
+${namedExports.join("\n")}
+`;
+}
+async function clientReferenceExportNames(config, file, source, visited = /* @__PURE__ */ new Set()) {
+  const key = path.resolve(file);
+  if (visited.has(key)) return [];
+  visited.add(key);
+  const text = source ?? await readText(file);
+  const names = new Set(moduleExportNames(text, file));
+  if (names.size === 0) {
+    for (const match of text.matchAll(/\bexports\.([A-Za-z_$][\w$]*)\s*=/g)) {
+      if (match[1] !== "__esModule") names.add(match[1]);
+    }
+    if (/\bmodule\.exports\s*=/.test(text)) names.add("default");
+  }
+  for (const specifier of moduleExportStars(text, file)) {
+    const resolved = resolveImport(config.root, file, specifier, config.workspaceRoot);
+    if (!resolved || !isInside(config.workspaceRoot, resolved)) continue;
+    for (const name of await clientReferenceExportNames(config, resolved, void 0, visited)) {
+      if (name !== "default") names.add(name);
+    }
+  }
+  return [...names];
+}
+function hasUseClientDirective(source) {
+  const isSpace = (index) => {
+    const code = source.charCodeAt(index);
+    return code === 32 || code >= 9 && code <= 13 || code > 127 && /\s/.test(source[index]);
+  };
+  let i = 0;
+  for (; ; ) {
+    while (i < source.length && isSpace(i)) i += 1;
+    if (source.startsWith("//", i)) {
+      const newline = source.indexOf("\n", i);
+      if (newline === -1) return false;
+      i = newline + 1;
+      continue;
+    }
+    if (source.startsWith("/*", i)) {
+      const end2 = source.indexOf("*/", i + 2);
+      if (end2 === -1) return false;
+      i = end2 + 2;
+      continue;
+    }
+    const quote = source[i];
+    if (quote !== '"' && quote !== "'") return false;
+    let end = i + 1;
+    while (end < source.length) {
+      const char = source[end];
+      if (char === quote || char === "\n" || char === "\\") break;
+      end += 1;
+    }
+    if (source[end] !== quote) return false;
+    if (source.slice(i + 1, end) === "use client") return true;
+    i = end + 1;
+    while (i < source.length && isSpace(i)) i += 1;
+    if (source[i] === ";") i += 1;
+  }
+}
+function isInside(root, file) {
+  const relative = path.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+
+export {
+  clientReferenceModuleSource,
+  clientReferenceExportNames,
+  hasUseClientDirective
+};