@wular/coder 0.3.17 → 0.4.0

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

@@ -0,0 +1,206 @@
+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/fs.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { mkdir, readdir, rename, rm, stat, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var atomicWriteSequence = 0;
+async function writeFileAtomic(file, contents, tempDirectory) {
+  const suffix = `${process.pid.toString(36)}.${(++atomicWriteSequence).toString(36)}.tmp`;
+  let temp = tempDirectory ? path.join(
+    tempDirectory,
+    `.${path.basename(path.dirname(file))}-${path.basename(file)}.${suffix}`
+  ) : `${file}.${suffix}`;
+  try {
+    await writeFile(temp, contents);
+  } catch (error) {
+    if (!tempDirectory) throw error;
+    temp = `${file}.${suffix}`;
+    await writeFile(temp, contents);
+  }
+  try {
+    await rename(temp, file);
+  } catch (error) {
+    if (!existsSync(file)) throw error;
+  }
+}
+async function listFiles(root) {
+  if (!existsSync(root)) return [];
+  const entries = await readdir(root, { withFileTypes: true });
+  const branches = await Promise.all(
+    entries.map((entry) => {
+      const entryPath = path.join(root, entry.name);
+      if (entry.isDirectory()) return listFiles(entryPath);
+      return Promise.resolve(entry.isFile() ? [entryPath] : []);
+    })
+  );
+  return branches.flat();
+}
+var dirListings;
+function withDirCache(run) {
+  if (dirListings) return run();
+  dirListings = /* @__PURE__ */ new Map();
+  try {
+    return run();
+  } finally {
+    dirListings = void 0;
+  }
+}
+function readDirListing(dir) {
+  const cached = dirListings?.get(dir);
+  if (cached) return cached;
+  let listing;
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    listing = {
+      files: new Set(entries.filter((entry) => !entry.isDirectory()).map((entry) => entry.name)),
+      dirs: entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort()
+    };
+  } catch {
+    listing = { files: /* @__PURE__ */ new Set(), dirs: [] };
+  }
+  dirListings?.set(dir, listing);
+  return listing;
+}
+function listFilesSync(root) {
+  if (!existsSync(root)) return [];
+  const out = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const entryPath = path.join(root, entry.name);
+    if (entry.isDirectory()) out.push(...listFilesSync(entryPath));
+    else if (entry.isFile()) out.push(entryPath);
+  }
+  return out;
+}
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+async function writeText(file, value) {
+  await ensureDir(path.dirname(file));
+  await writeFile(file, value);
+}
+async function readText(file) {
+  return readFile(file, "utf8");
+}
+function toPosixPath(value) {
+  return value.split(path.sep).join("/");
+}
+function cssModuleScopePath(file) {
+  const normalized = toPosixPath(file);
+  const appIndex = normalized.lastIndexOf("/app/");
+  if (appIndex !== -1) return normalized.slice(appIndex + 1);
+  let dir = path.dirname(file);
+  let fallback;
+  while (true) {
+    const packageFile = path.join(dir, "package.json");
+    if (existsSync(packageFile) || existsSync(path.join(dir, "pnext.config.ts")) || existsSync(path.join(dir, "node_modules"))) {
+      const relative = toPosixPath(path.relative(dir, file));
+      try {
+        const { name } = JSON.parse(readFileSync(packageFile, "utf8"));
+        if (typeof name === "string") return `${name}/${relative}`;
+      } catch {
+      }
+      fallback ??= relative;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return fallback ?? path.basename(file);
+    dir = parent;
+  }
+}
+function pnextVersionRange() {
+  const pkgPath = fileURLToPath(new URL("../../package.json", "file:///Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/utils/fs.ts"));
+  const { version } = JSON.parse(readFileSync(pkgPath, "utf8"));
+  return `^${version}`;
+}
+function includeTypes(config, files, defaults) {
+  if (!("include" in config)) {
+    config.include = [...files, ...defaults];
+    return files;
+  }
+  const include = config.include;
+  if (!Array.isArray(include)) return [];
+  const added = files.filter((file) => !include.includes(file));
+  include.push(...added);
+  return added;
+}
+function resolveManifest(data, outPath, root) {
+  if (path.isAbsolute(data.root)) return data;
+  const absolute = (file) => path.join(root, file);
+  return {
+    ...mapSourcePaths(data, absolute),
+    root,
+    appDir: absolute(data.appDir),
+    outDir: outPath
+  };
+}
+var sourcePathFields = [
+  "file",
+  "sourceFiles",
+  "cssImports",
+  "templateFiles",
+  "forbiddenFiles",
+  "unauthorizedFiles",
+  "slotDirs",
+  "slotDir",
+  "syntheticSlotDir",
+  "childrenDefault",
+  "serverActionFile",
+  "globalErrorFile"
+];
+function mapSourcePaths(data, map) {
+  function owner(value) {
+    if (!value) return value;
+    const mapped2 = { ...value };
+    for (const key of sourcePathFields) {
+      const field = value[key];
+      if (field !== void 0) mapped2[key] = Array.isArray(field) ? field.map(map) : map(field);
+    }
+    return mapped2;
+  }
+  const mapped = owner(data);
+  mapped.routes = data.routes.map((route) => ({
+    ...owner(route),
+    clientReferences: route.clientReferences.map(owner),
+    ...route.interception && { interception: owner(route.interception) }
+  }));
+  if (data.staticMetadataFiles) mapped.staticMetadataFiles = data.staticMetadataFiles.map(owner);
+  if (data.staticRouteMetadata) {
+    mapped.staticRouteMetadata = Object.fromEntries(
+      Object.entries(data.staticRouteMetadata).map(([route, entry]) => [
+        route,
+        {
+          ...entry,
+          favicon: owner(entry.favicon),
+          manifest: owner(entry.manifest),
+          icons: entry.icons.map(owner),
+          appleIcons: entry.appleIcons.map(owner),
+          rootIcons: entry.rootIcons.map(owner)
+        }
+      ])
+    );
+  }
+  if (data.staticModuleMetadata) {
+    mapped.staticModuleMetadata = Object.fromEntries(
+      Object.entries(data.staticModuleMetadata).map(([file, metadata]) => [map(file), metadata])
+    );
+  }
+  return mapped;
+}
+
+export {
+  writeFileAtomic,
+  listFiles,
+  withDirCache,
+  readDirListing,
+  listFilesSync,
+  ensureDir,
+  writeText,
+  readText,
+  toPosixPath,
+  cssModuleScopePath,
+  pnextVersionRange,
+  includeTypes,
+  resolveManifest
+};