@wular/coder 0.3.18 → 0.4.0

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

@@ -0,0 +1,218 @@
+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 {
+  getNextConfig
+} from "./chunk-2ICEVELW.js";
+import {
+  includeTypes,
+  writeFileAtomic
+} from "./chunk-2HFY3DQT.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/tsconfig-defaults.ts
+import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+function hasTypescriptSources(root, depth = 0) {
+  if (depth > 6) return false;
+  let entries;
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    if (entry.isFile() && /\.(ts|tsx|mts|cts)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+      return true;
+    }
+    if (entry.isDirectory() && hasTypescriptSources(path.join(root, entry.name), depth + 1)) {
+      return true;
+    }
+  }
+  return false;
+}
+function appTypescriptVersion(root) {
+  for (const base of [root, "/Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat"]) {
+    try {
+      const require2 = createRequire(path.join(base, "noop.js"));
+      const pkg = require2("typescript/package.json");
+      if (typeof pkg.version === "string") return pkg.version;
+    } catch {
+    }
+  }
+  return "5.9.0";
+}
+function versionGte(version, major, minor) {
+  const [maj = 0, min = 0] = version.split(".").map((part) => Number.parseInt(part, 10));
+  return maj > major || maj === major && min >= minor;
+}
+function getDesiredCompilerOptions(typescriptVersion, userTsConfig) {
+  const configuredModule = typeof userTsConfig.compilerOptions?.module === "string" ? userTsConfig.compilerOptions.module.toLowerCase() : void 0;
+  const preferBundlerResolution = versionGte(typescriptVersion, 5, 0) && configuredModule !== "commonjs" && configuredModule !== "amd";
+  const modulePreserve = versionGte(typescriptVersion, 5, 4) && configuredModule === "preserve";
+  return {
+    target: {
+      suggested: "ES2017",
+      reason: "For top-level `await`. Note: Next.js only polyfills for the esmodules target."
+    },
+    lib: { suggested: ["dom", "dom.iterable", "esnext"] },
+    allowJs: { suggested: true },
+    skipLibCheck: { suggested: true },
+    strict: { suggested: false },
+    noEmit: { suggested: true },
+    incremental: { suggested: true },
+    module: {
+      parsedValue: "esnext",
+      parsedValues: [
+        ...versionGte(typescriptVersion, 5, 4) ? ["preserve"] : [],
+        "es2020",
+        "esnext",
+        "commonjs",
+        "amd",
+        "nodenext",
+        "node16"
+      ],
+      value: "esnext",
+      reason: "for dynamic import() support"
+    },
+    // `module: "preserve"` implies moduleResolution: bundler, esModuleInterop
+    // and resolveJsonModule — the app does not need (and must not be told to
+    // add) any of them.
+    ...modulePreserve ? {} : {
+      esModuleInterop: { value: true, reason: "requirement for SWC / babel" },
+      moduleResolution: {
+        parsedValue: preferBundlerResolution ? "bundler" : "node",
+        parsedValues: preferBundlerResolution ? ["node16", "nodenext", "bundler"] : ["node", "node12", "node16", "nodenext"],
+        value: preferBundlerResolution ? "bundler" : "node",
+        reason: preferBundlerResolution ? "to match modern bundler resolution" : "to match webpack resolution"
+      },
+      resolveJsonModule: { value: true, reason: "to match webpack resolution" }
+    },
+    ...userTsConfig.compilerOptions?.verbatimModuleSyntax === true ? {} : { isolatedModules: { value: true, reason: "requirement for SWC / Babel" } },
+    jsx: {
+      // A missing value follows Next's automatic-runtime default, while an app
+      // that explicitly owns JSX emission keeps preserve. PNext's private
+      // typecheck project can analyze either without rewriting user intent.
+      parsedValue: "react-jsx",
+      parsedValues: ["preserve", "react-jsx"],
+      value: "react-jsx",
+      reason: "next.js uses the React automatic runtime"
+    }
+  };
+}
+function typeDefinitionGlobPatterns(distDir) {
+  return [`${distDir}/types/**/*.ts`, `${distDir}/dev/types/**/*.ts`].sort(
+    (a, b) => a.length - b.length
+  );
+}
+async function writeTsconfigDefaults(config) {
+  const tsConfigPath = path.join(config.root, "tsconfig.json");
+  const tempDirectory = path.dirname(config.root);
+  let isFirstTimeSetup = false;
+  if (!existsSync(tsConfigPath)) {
+    if (!hasTypescriptSources(config.root)) return;
+    isFirstTimeSetup = true;
+    await writeFileAtomic(tsConfigPath, "{}\n", tempDirectory);
+  }
+  let userTsConfig;
+  try {
+    userTsConfig = JSON.parse(await readFile(tsConfigPath, "utf8"));
+  } catch {
+    return;
+  }
+  if (userTsConfig === null || typeof userTsConfig !== "object") return;
+  if ("extends" in userTsConfig || "references" in userTsConfig) return;
+  if (userTsConfig.compilerOptions == null) userTsConfig.compilerOptions = {};
+  const compilerOptions = userTsConfig.compilerOptions;
+  const desired = getDesiredCompilerOptions(appTypescriptVersion(config.root), userTsConfig);
+  const suggestedActions = [];
+  const requiredActions = [];
+  for (const [optionKey, check] of Object.entries(desired)) {
+    if ("suggested" in check) {
+      if (!(optionKey in compilerOptions)) {
+        compilerOptions[optionKey] = check.suggested;
+        suggestedActions.push(
+          `${optionKey} was set to ${JSON.stringify(check.suggested)}` + (check.reason ? ` (${check.reason})` : "")
+        );
+      }
+      continue;
+    }
+    let existingValue = compilerOptions[optionKey];
+    if (typeof existingValue === "string") existingValue = existingValue.toLowerCase();
+    const satisfied = check.parsedValues ? check.parsedValues.includes(existingValue) : (check.parsedValue ?? check.value) === existingValue;
+    if (!satisfied) {
+      compilerOptions[optionKey] = check.value;
+      requiredActions.push(`${optionKey} was set to ${String(check.value)} (${check.reason})`);
+    }
+  }
+  const hasAppDir = existsSync(path.join(config.root, "app")) || existsSync(path.join(config.root, "src", "app"));
+  const hasPagesDir = existsSync(path.join(config.root, "pages")) || existsSync(path.join(config.root, "src", "pages"));
+  const strictRouteTypes = process.env.__NEXT_EXPERIMENTAL_STRICT_ROUTE_TYPES === "true";
+  const distDir = typeof getNextConfig().distDir === "string" ? getNextConfig().distDir : ".next";
+  const nextTypes = typeDefinitionGlobPatterns(distDir);
+  if (!("include" in userTsConfig)) {
+    const defaultInclude = hasAppDir && !strictRouteTypes ? ["next-env.d.ts", ...nextTypes, "**/*.mts", "**/*.ts", "**/*.tsx"] : ["next-env.d.ts", "**/*.mts", "**/*.ts", "**/*.tsx"];
+    includeTypes(userTsConfig, [], defaultInclude);
+    suggestedActions.push(
+      `include was set to [${defaultInclude.map((type) => `'${type}'`).join(", ")}]`
+    );
+  } else if (hasAppDir && !strictRouteTypes && Array.isArray(userTsConfig.include)) {
+    for (const type of includeTypes(userTsConfig, nextTypes, [])) {
+      suggestedActions.push(`include was updated to add '${type}'`);
+    }
+  }
+  if (hasAppDir) {
+    const plugins = [
+      ...Array.isArray(userTsConfig.plugins) ? userTsConfig.plugins : [],
+      ...Array.isArray(compilerOptions.plugins) ? compilerOptions.plugins : []
+    ];
+    if (!plugins.some((plugin) => plugin?.name === "next")) {
+      if (!Array.isArray(compilerOptions.plugins)) compilerOptions.plugins = [];
+      compilerOptions.plugins.push({ name: "next" });
+      suggestedActions.push(`plugins was updated to add { name: 'next' }`);
+    }
+    if (hasPagesDir && !compilerOptions.strict && !("strictNullChecks" in compilerOptions)) {
+      compilerOptions.strictNullChecks = true;
+      suggestedActions.push("strictNullChecks was set to true");
+    }
+  }
+  if (!("exclude" in userTsConfig)) {
+    userTsConfig.exclude = ["node_modules"];
+    suggestedActions.push(`exclude was set to ['node_modules']`);
+  }
+  if (suggestedActions.length === 0 && requiredActions.length === 0) return;
+  await writeFileAtomic(tsConfigPath, `${JSON.stringify(userTsConfig, null, 2)}
+`, tempDirectory);
+  if (isFirstTimeSetup) {
+    console.log(
+      "\nWe detected TypeScript in your project and created a tsconfig.json file for you."
+    );
+    return;
+  }
+  const lines = [
+    "",
+    `We detected TypeScript in your project and reconfigured your tsconfig.json file for you.${compilerOptions.strict ? "" : " Strict-mode is set to false by default."}`
+  ];
+  if (suggestedActions.length > 0) {
+    lines.push(
+      `The following suggested values were added to your tsconfig.json. These values can be changed to fit your project's needs:
+`,
+      ...suggestedActions.map((action) => `	- ${action}`),
+      ""
+    );
+  }
+  if (requiredActions.length > 0) {
+    lines.push(
+      `The following mandatory changes were made to your tsconfig.json:
+`,
+      ...requiredActions.map((action) => `	- ${action}`),
+      ""
+    );
+  }
+  console.log(lines.join("\n"));
+}
+
+export {
+  writeTsconfigDefaults
+};

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

@@ -0,0 +1,70 @@
+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/routing/request-environment.ts
+var current;
+function setRequestRuntime(runtime) {
+  current = runtime;
+}
+function getRequestRuntime() {
+  return current;
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/api/navigation.ts
+var notFoundDigest = "PNEXT_NOT_FOUND";
+var redirectDigest = "PNEXT_REDIRECT";
+var forbiddenDigest = "PNEXT_FORBIDDEN";
+var unauthorizedDigest = "PNEXT_UNAUTHORIZED";
+var nextNotFoundDigest = "NEXT_HTTP_ERROR_FALLBACK;404";
+var nextForbiddenDigest = "NEXT_HTTP_ERROR_FALLBACK;403";
+var nextUnauthorizedDigest = "NEXT_HTTP_ERROR_FALLBACK;401";
+var PNextNotFoundError = class extends Error {
+  constructor() {
+    super("not found");
+    this.digest = notFoundDigest;
+  }
+};
+var PNextForbiddenError = class extends Error {
+  constructor() {
+    super("forbidden");
+    this.digest = forbiddenDigest;
+  }
+};
+var PNextUnauthorizedError = class extends Error {
+  constructor() {
+    super("unauthorized");
+    this.digest = unauthorizedDigest;
+  }
+};
+var PNextRedirectError = class extends Error {
+  constructor(location, status = 307) {
+    super(`redirect to ${location}`);
+    this.location = location;
+    this.status = status;
+    this.digest = redirectDigest;
+  }
+};
+function isNotFoundError(error) {
+  return error instanceof PNextNotFoundError || errorDigest(error) === notFoundDigest || errorDigest(error) === nextNotFoundDigest;
+}
+function isRedirectError(error) {
+  return error instanceof PNextRedirectError || errorDigest(error) === redirectDigest;
+}
+function isForbiddenError(error) {
+  return error instanceof PNextForbiddenError || errorDigest(error) === forbiddenDigest || errorDigest(error) === nextForbiddenDigest;
+}
+function isUnauthorizedError(error) {
+  return error instanceof PNextUnauthorizedError || errorDigest(error) === unauthorizedDigest || errorDigest(error) === nextUnauthorizedDigest;
+}
+function errorDigest(error) {
+  return typeof error === "object" && error !== null && "digest" in error ? error.digest : void 0;
+}
+
+export {
+  setRequestRuntime,
+  getRequestRuntime,
+  isNotFoundError,
+  isRedirectError,
+  isForbiddenError,
+  isUnauthorizedError
+};

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

@@ -0,0 +1,229 @@
+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 {
+  getNextConfig
+} from "./chunk-2ICEVELW.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/bundler/config.ts
+var PREDEFINED_SERVER_EXTERNAL_PACKAGES = [
+  "sharp",
+  "sqlite3",
+  "better-sqlite3",
+  "canvas",
+  "@node-rs/argon2",
+  "@node-rs/bcrypt"
+];
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function serverExternalPackages() {
+  const config = getNextConfig();
+  return /* @__PURE__ */ 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 : void 0;
+}
+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 void 0;
+  const language = relay.language;
+  return {
+    src: relay.src,
+    artifactDirectory: typeof relay.artifactDirectory === "string" ? relay.artifactDirectory : void 0,
+    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 void 0;
+}
+function tsconfigPath() {
+  const ts = getNextConfig().typescript;
+  return typeof ts?.tsconfigPath === "string" ? ts.tsconfigPath : void 0;
+}
+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 void 0;
+  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 : void 0;
+}
+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 : void 0;
+  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 void 0;
+  const query = value.query;
+  if (typeof query === "string" || query instanceof RegExp) return { query };
+  return void 0;
+}
+function parseAssetRuleType(value) {
+  if (value === "asset" || value === "asset/resource") return "resource";
+  if (value === "bytes") return "bytes";
+  if (value === "asset/source") return "source";
+  return void 0;
+}
+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,
+  publicRuntimeConfig,
+  transpilePackages,
+  modularizeImports,
+  optimizePackageImports,
+  relayCompilerConfig,
+  esmExternals,
+  resolveExtensions,
+  tsconfigPath,
+  compilerDefines,
+  removeConsoleTargets,
+  cacheComponentsEnabled,
+  swcEnvUsageMode,
+  reactCompilerEnabled,
+  turbopackLoaderRules,
+  turbopackResolveAlias
+};