@wular/coder 0.4.3 → 0.4.5

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

@@ -0,0 +1,311 @@
+// @bun
+import {
+  getNextConfig
+} from "./index-m63czgq5.js";
+
+// src/compat/bundler/config.ts
+var PREDEFINED_SERVER_EXTERNAL_PACKAGES = [
+  "sharp",
+  "sqlite3",
+  "better-sqlite3",
+  "canvas",
+  "@node-rs/argon2",
+  "@node-rs/bcrypt"
+];
+var NEXT_SERVER_EXTERNAL_PACKAGES = new Set([
+  "@alinea/generated",
+  "@appsignal/nodejs",
+  "@aws-sdk/client-s3",
+  "@aws-sdk/s3-presigned-post",
+  "@blockfrost/blockfrost-js",
+  "@highlight-run/node",
+  "@huggingface/transformers",
+  "@jpg-store/lucid-cardano",
+  "@libsql/client",
+  "@mikro-orm/core",
+  "@mikro-orm/knex",
+  "@node-rs/argon2",
+  "@node-rs/bcrypt",
+  "@prisma/client",
+  "@react-pdf/renderer",
+  "@sentry/profiling-node",
+  "@sparticuz/chromium",
+  "@sparticuz/chromium-min",
+  "@statsig/statsig-node-core",
+  "@swc/core",
+  "@xenova/transformers",
+  "@zenstackhq/runtime",
+  "argon2",
+  "autoprefixer",
+  "aws-crt",
+  "bcrypt",
+  "better-sqlite3",
+  "canvas",
+  "chromadb-default-embed",
+  "config",
+  "cpu-features",
+  "cypress",
+  "dd-trace",
+  "eslint",
+  "express",
+  "firebase-admin",
+  "htmlrewriter",
+  "import-in-the-middle",
+  "isolated-vm",
+  "jest",
+  "jsdom",
+  "keyv",
+  "libsql",
+  "mdx-bundler",
+  "mongodb",
+  "mongoose",
+  "newrelic",
+  "next-mdx-remote",
+  "next-seo",
+  "node-cron",
+  "node-pty",
+  "node-web-audio-api",
+  "onnxruntime-node",
+  "oslo",
+  "pg",
+  "pino",
+  "pino-pretty",
+  "pino-roll",
+  "playwright",
+  "playwright-core",
+  "postcss",
+  "prettier",
+  "prisma",
+  "puppeteer",
+  "puppeteer-core",
+  "ravendb",
+  "require-in-the-middle",
+  "rimraf",
+  "sharp",
+  "shiki",
+  "sqlite3",
+  "thread-stream",
+  "ts-morph",
+  "ts-node",
+  "typescript",
+  "vscode-oniguruma",
+  "webpack",
+  "websocket",
+  "zeromq"
+]);
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function serverExternalPackages() {
+  const config = getNextConfig();
+  return new Set([
+    ...PREDEFINED_SERVER_EXTERNAL_PACKAGES,
+    ...stringArray(config.serverExternalPackages)
+  ]);
+}
+function deploymentId() {
+  const configured = getNextConfig().deploymentId;
+  if (typeof configured === "string" && configured.length > 0)
+    return configured;
+  const fromEnv = process.env.NEXT_DEPLOYMENT_ID;
+  return fromEnv && fromEnv.length > 0 ? fromEnv : undefined;
+}
+function builtInServerExternalPackages() {
+  return NEXT_SERVER_EXTERNAL_PACKAGES;
+}
+function publicRuntimeConfig() {
+  const config = getNextConfig().publicRuntimeConfig;
+  return config && typeof config === "object" ? config : {};
+}
+function transpilePackages() {
+  return stringArray(getNextConfig().transpilePackages);
+}
+function modularizeImports() {
+  const raw = getNextConfig().modularizeImports;
+  if (!raw || typeof raw !== "object")
+    return {};
+  const out = {};
+  for (const [specifier, value] of Object.entries(raw)) {
+    if (value && typeof value === "object" && typeof value.transform === "string") {
+      const rule = value;
+      out[specifier] = {
+        transform: rule.transform,
+        skipDefaultConversion: Boolean(rule.skipDefaultConversion)
+      };
+    }
+  }
+  return out;
+}
+function optimizePackageImports() {
+  const experimental = getNextConfig().experimental;
+  return stringArray(experimental?.optimizePackageImports);
+}
+function relayCompilerConfig() {
+  const compiler = getNextConfig().compiler;
+  const relay = compiler?.relay;
+  if (!relay || typeof relay !== "object" || typeof relay.src !== "string")
+    return;
+  const language = relay.language;
+  return {
+    src: relay.src,
+    artifactDirectory: typeof relay.artifactDirectory === "string" ? relay.artifactDirectory : undefined,
+    language: language === "typescript" || language === "flow" || language === "javascript" ? language : "javascript"
+  };
+}
+function esmExternals() {
+  const experimental = getNextConfig().experimental;
+  return experimental?.esmExternals ?? true;
+}
+function resolveExtensions() {
+  const config = getNextConfig();
+  const turbopack = config.turbopack;
+  const experimental = config.experimental;
+  for (const value of [
+    config.resolveExtensions,
+    turbopack?.resolveExtensions,
+    experimental?.turbo?.resolveExtensions
+  ]) {
+    const list = stringArray(value);
+    if (list.length > 0)
+      return list;
+  }
+  return;
+}
+function tsconfigPath() {
+  const ts = getNextConfig().typescript;
+  return typeof ts?.tsconfigPath === "string" ? ts.tsconfigPath : undefined;
+}
+function normalizeDefineMap(value) {
+  if (!value || typeof value !== "object")
+    return {};
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw === "string")
+      out[key] = JSON.stringify(raw);
+    else if (typeof raw === "number" || typeof raw === "boolean")
+      out[key] = String(raw);
+  }
+  return out;
+}
+function compilerDefines() {
+  const compiler = getNextConfig().compiler;
+  return {
+    define: normalizeDefineMap(compiler?.define),
+    defineServer: normalizeDefineMap(compiler?.defineServer)
+  };
+}
+var CONSOLE_METHODS = [
+  "assert",
+  "clear",
+  "count",
+  "countReset",
+  "debug",
+  "dir",
+  "dirxml",
+  "error",
+  "group",
+  "groupCollapsed",
+  "groupEnd",
+  "info",
+  "log",
+  "table",
+  "time",
+  "timeEnd",
+  "timeLog",
+  "trace",
+  "warn"
+];
+function removeConsoleTargets() {
+  const compiler = getNextConfig().compiler;
+  const removeConsole = compiler?.removeConsole;
+  if (!removeConsole)
+    return;
+  const exclude = new Set(typeof removeConsole === "object" ? stringArray(removeConsole.exclude) : []);
+  return CONSOLE_METHODS.filter((method) => !exclude.has(method)).map((method) => `console.${method}`);
+}
+function cacheComponentsEnabled() {
+  const config = getNextConfig();
+  const experimental = config.experimental;
+  return Boolean(config.cacheComponents ?? experimental?.cacheComponents);
+}
+function swcEnvUsageMode() {
+  const experimental = getNextConfig().experimental;
+  const mode = experimental?.swcEnvOptions?.mode;
+  return mode === "usage" || mode === "entry" ? mode : undefined;
+}
+function reactCompilerEnabled() {
+  const config = getNextConfig();
+  const experimental = config.experimental;
+  return Boolean(config.reactCompiler ?? experimental?.reactCompiler);
+}
+function turbopackLoaderRules() {
+  const config = getNextConfig();
+  const turbopack = config.turbopack;
+  const rules = turbopack?.rules;
+  if (!rules || typeof rules !== "object")
+    return [];
+  const out = [];
+  for (const [glob, raw] of Object.entries(rules))
+    collectLoaderRuleEntries(glob, raw, out);
+  return out;
+}
+function collectLoaderRuleEntries(glob, raw, out) {
+  if (Array.isArray(raw)) {
+    if (raw.every((item) => typeof item === "string")) {
+      const loaders = stringArray(raw);
+      if (loaders.length > 0)
+        out.push({ glob, loaders });
+      return;
+    }
+    for (const item of raw) {
+      if (item && typeof item === "object")
+        pushLoaderRuleObject(glob, item, out);
+    }
+    return;
+  }
+  if (raw && typeof raw === "object")
+    pushLoaderRuleObject(glob, raw, out);
+}
+function pushLoaderRuleObject(glob, entry, out) {
+  const loaders = stringArray(entry.loaders);
+  const as = typeof entry.as === "string" ? entry.as : undefined;
+  const condition = parseRuleCondition(entry.condition);
+  if (loaders.length > 0) {
+    out.push({ glob, loaders, as, ...condition ? { condition } : {} });
+    return;
+  }
+  const assetType = parseAssetRuleType(entry.type);
+  if (assetType)
+    out.push({ glob, loaders: [], as, assetType });
+}
+function parseRuleCondition(value) {
+  if (!value || typeof value !== "object")
+    return;
+  const query = value.query;
+  if (typeof query === "string" || query instanceof RegExp)
+    return { query };
+  return;
+}
+function parseAssetRuleType(value) {
+  if (value === "asset" || value === "asset/resource")
+    return "resource";
+  if (value === "bytes")
+    return "bytes";
+  if (value === "asset/source")
+    return "source";
+  return;
+}
+function turbopackResolveAlias() {
+  const turbopack = getNextConfig().turbopack;
+  const alias = turbopack?.resolveAlias;
+  if (!alias || typeof alias !== "object")
+    return {};
+  const out = {};
+  for (const [key, value] of Object.entries(alias)) {
+    if (typeof value === "string")
+      out[key] = value;
+  }
+  return out;
+}
+
+export { serverExternalPackages, deploymentId, builtInServerExternalPackages, publicRuntimeConfig, transpilePackages, modularizeImports, optimizePackageImports, relayCompilerConfig, esmExternals, resolveExtensions, tsconfigPath, compilerDefines, removeConsoleTargets, cacheComponentsEnabled, swcEnvUsageMode, reactCompilerEnabled, turbopackLoaderRules, turbopackResolveAlias };

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

@@ -0,0 +1,283 @@
+// @bun
+// src/compat/segment/vary-params.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// src/compat/segment/vary-key.ts
+var SEARCH_PARAMS_SENTINEL = "?";
+
+// src/compat/segment/vary-params.ts
+function createSegmentVaryParamsAccumulator(kind = "page") {
+  const accumulator = {
+    kind,
+    varyParams: new Set,
+    status: "pending",
+    value: new Set,
+    then(onfulfilled) {
+      if (!onfulfilled)
+        return;
+      if (accumulator.status === "pending")
+        accumulator.resolvers.push(onfulfilled);
+      else
+        onfulfilled(accumulator.value);
+    },
+    resolvers: []
+  };
+  return accumulator;
+}
+var emptySet = new Set;
+var emptyVaryParamsAccumulator = {
+  kind: "page",
+  varyParams: emptySet,
+  status: "fulfilled",
+  value: emptySet,
+  then(onfulfilled) {
+    if (onfulfilled)
+      onfulfilled(emptySet);
+  },
+  resolvers: []
+};
+function createResponseVaryParamsAccumulator() {
+  return {
+    head: createSegmentVaryParamsAccumulator("head"),
+    rootParams: createSegmentVaryParamsAccumulator("root"),
+    segments: new Set
+  };
+}
+var VARY_PARAMS_GLOBALS = Symbol.for("pnext.compat.varyParamsGlobals");
+function varyGlobal(name, create) {
+  const root = globalThis;
+  const container = root[VARY_PARAMS_GLOBALS] ??= {};
+  if (!(name in container))
+    container[name] = create();
+  return container[name];
+}
+var varyStorage = varyGlobal("storage", () => new AsyncLocalStorage);
+function createVaryParamsAccumulator(kind = "page") {
+  const response = varyStorage.getStore();
+  if (!response)
+    return null;
+  const accumulator = createSegmentVaryParamsAccumulator(kind);
+  response.segments.add(accumulator);
+  return accumulator;
+}
+function getMetadataVaryParamsAccumulator() {
+  return varyStorage.getStore()?.head ?? null;
+}
+function getRootParamsVaryParamsAccumulator() {
+  return varyStorage.getStore()?.rootParams ?? null;
+}
+function accumulateVaryParam(accumulator, paramName) {
+  if (accumulator === emptyVaryParamsAccumulator)
+    return;
+  accumulator.varyParams.add(paramName);
+}
+function accumulateRootVaryParam(paramName) {
+  const accumulator = getRootParamsVaryParamsAccumulator();
+  if (accumulator !== null)
+    accumulateVaryParam(accumulator, paramName);
+}
+var VARY_TRACKING = Symbol.for("pnext.compat.varyTracking");
+function markVaryTracking(target, info) {
+  Object.defineProperty(target, VARY_TRACKING, {
+    value: info,
+    enumerable: false,
+    configurable: true
+  });
+}
+function varyTrackingInfo(value) {
+  if (typeof value !== "object" || value === null)
+    return null;
+  const info = value[VARY_TRACKING];
+  return info ?? null;
+}
+function createVaryingParams(accumulator, params, optionalCatchAllParamName = null) {
+  const originalParams = normalizeOptionalCatchAllParams(params, optionalCatchAllParamName);
+  const info = {
+    raw: originalParams,
+    kind: "params",
+    optionalCatchAllParam: optionalCatchAllParamName
+  };
+  if (optionalCatchAllParamName !== null) {
+    return new Proxy(originalParams, {
+      get(target, prop, receiver) {
+        if (prop === VARY_TRACKING)
+          return info;
+        if (typeof prop === "string" && (prop === optionalCatchAllParamName || Object.prototype.hasOwnProperty.call(target, prop))) {
+          accumulateVaryParam(accumulator, prop);
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      has(target, prop) {
+        if (prop === optionalCatchAllParamName) {
+          accumulateVaryParam(accumulator, optionalCatchAllParamName);
+        }
+        return Reflect.has(target, prop);
+      },
+      ownKeys(target) {
+        accumulateVaryParam(accumulator, optionalCatchAllParamName);
+        return Reflect.ownKeys(target);
+      }
+    });
+  }
+  const tracked = {};
+  for (const paramName in originalParams) {
+    Object.defineProperty(tracked, paramName, {
+      get() {
+        accumulateVaryParam(accumulator, paramName);
+        return originalParams[paramName];
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+  markVaryTracking(tracked, info);
+  return tracked;
+}
+function normalizeOptionalCatchAllParams(params, optionalCatchAllParamName) {
+  if (optionalCatchAllParamName === null)
+    return params;
+  const value = params[optionalCatchAllParamName];
+  if (!Array.isArray(value) || value.length > 0)
+    return params;
+  const { [optionalCatchAllParamName]: _empty, ...rest } = params;
+  return rest;
+}
+function createVaryingSearchParams(accumulator, originalSearchParams) {
+  const info = {
+    raw: originalSearchParams,
+    kind: "searchParams",
+    optionalCatchAllParam: null
+  };
+  return new Proxy(originalSearchParams, {
+    get(target, prop, receiver) {
+      if (prop === VARY_TRACKING)
+        return info;
+      if (typeof prop === "string" && !isPromiseProbe(target, prop)) {
+        accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL);
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    has(target, prop) {
+      if (typeof prop === "string")
+        accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL);
+      return Reflect.has(target, prop);
+    },
+    ownKeys(target) {
+      accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL);
+      return Reflect.ownKeys(target);
+    }
+  });
+}
+function isPromiseProbe(target, prop) {
+  return prop === "then" && !Object.prototype.hasOwnProperty.call(target, prop);
+}
+function finishAccumulatingVaryParams(response) {
+  const rootVaryParams = response.rootParams.varyParams;
+  finishSegmentAccumulator(response.head, rootVaryParams);
+  for (const segment of response.segments)
+    finishSegmentAccumulator(segment, rootVaryParams);
+  finishSegmentAccumulator(response.rootParams, emptySet);
+}
+function finishSegmentAccumulator(accumulator, rootVaryParams) {
+  if (accumulator.status !== "pending")
+    return;
+  const merged = new Set(accumulator.varyParams);
+  for (const param of rootVaryParams)
+    merged.add(param);
+  accumulator.value = merged;
+  accumulator.status = "fulfilled";
+  const resolvers = accumulator.resolvers;
+  accumulator.resolvers = [];
+  for (const resolve of resolvers)
+    resolve(merged);
+}
+function collectResponseVaryParams(response) {
+  finishAccumulatingVaryParams(response);
+  const body = new Set;
+  const page = new Set;
+  const layout = new Set;
+  for (const segment of response.segments) {
+    const target = segment.kind === "layout" ? layout : page;
+    for (const name of segment.value) {
+      body.add(name);
+      target.add(name);
+    }
+  }
+  const head = new Set(response.head.value);
+  return {
+    params: sortedParamNames(body),
+    page: sortedParamNames(page),
+    layout: sortedParamNames(layout),
+    head: sortedParamNames(head),
+    root: sortedParamNames(response.rootParams.value),
+    search: body.has(SEARCH_PARAMS_SENTINEL),
+    pageSearch: page.has(SEARCH_PARAMS_SENTINEL),
+    layoutSearch: layout.has(SEARCH_PARAMS_SENTINEL),
+    headSearch: head.has(SEARCH_PARAMS_SENTINEL)
+  };
+}
+function sortedParamNames(set) {
+  return [...set].filter((name) => name !== SEARCH_PARAMS_SENTINEL).sort();
+}
+async function withVaryParamsTracking(produce) {
+  const outer = varyStorage.getStore();
+  if (outer)
+    return { value: await produce(), vary: collectResponseVaryParams(outer) };
+  const response = createResponseVaryParamsAccumulator();
+  const value = await varyStorage.run(response, produce);
+  return { value, vary: collectResponseVaryParams(response) };
+}
+function encodeVaryNames(names, search) {
+  return search ? [...names, SEARCH_PARAMS_SENTINEL] : [...names];
+}
+function responseVaryParamsFromWire(wire) {
+  const split = (names) => ({
+    names: (names ?? []).filter((name) => name !== SEARCH_PARAMS_SENTINEL),
+    search: (names ?? []).includes(SEARCH_PARAMS_SENTINEL)
+  });
+  const body = split(wire.vary);
+  const layout = split(wire.layoutVary);
+  const page = split(wire.pageVary);
+  return {
+    params: body.names,
+    page: page.names,
+    layout: layout.names,
+    head: [],
+    root: [],
+    search: body.search,
+    pageSearch: page.search,
+    layoutSearch: layout.search,
+    headSearch: false
+  };
+}
+function varyNamesFor(vary, kind) {
+  switch (kind) {
+    case "head":
+      return encodeVaryNames(vary.head, vary.headSearch);
+    case "page":
+      return encodeVaryNames(vary.page, vary.pageSearch);
+    case "layout":
+      return encodeVaryNames(vary.layout, vary.layoutSearch);
+    default:
+      return encodeVaryNames(vary.params, vary.search);
+  }
+}
+
+// src/compat/static-params.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var GSP_SCOPE = Symbol.for("pnext.generateStaticParamsScope");
+var globals = globalThis;
+var gspScope = globals[GSP_SCOPE] ??= new AsyncLocalStorage2;
+function generateStaticParamsScope() {
+  return gspScope.getStore();
+}
+function aliasGenerateStaticParams(module) {
+  if (typeof module.params === "function" || typeof module.generateStaticParams !== "function") {
+    return module;
+  }
+  const generate = module.generateStaticParams;
+  const params = (args) => gspScope.run({ provided: args?.params ?? {} }, () => generate(args));
+  return { ...module, params };
+}
+
+export { createVaryParamsAccumulator, getMetadataVaryParamsAccumulator, accumulateRootVaryParam, varyTrackingInfo, createVaryingParams, normalizeOptionalCatchAllParams, createVaryingSearchParams, withVaryParamsTracking, responseVaryParamsFromWire, varyNamesFor, generateStaticParamsScope, aliasGenerateStaticParams };