@absolutejs/absolute 0.20.0-beta.71 → 0.20.0-beta.73

package/dist/dev/importCostPreload.js

@@ -0,0 +1,206 @@
+// @bun
+// src/dev/importCostPreload.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var {plugin } = globalThis.Bun;
+
+// src/dev/importCost/instrument.ts
+var BYTE_ORDER_MARK = 65279;
+var NOT_FOUND = -1;
+var PROLOGUE_TOKEN = /\s+|\/\/[^\n]*|\/\*[\s\S]*?\*\/|(['"])use [^'"\n]*\1[ \t]*;?/y;
+var prologueEnd = (source) => {
+  let index = source.charCodeAt(0) === BYTE_ORDER_MARK ? 1 : 0;
+  if (source.startsWith("#!", index)) {
+    const newline = source.indexOf(`
+`, index);
+    index = newline === NOT_FOUND ? source.length : newline + 1;
+  }
+  for (;; ) {
+    PROLOGUE_TOKEN.lastIndex = index;
+    if (PROLOGUE_TOKEN.exec(source) === null)
+      return index;
+    index = PROLOGUE_TOKEN.lastIndex;
+  }
+};
+var TYPESCRIPT_EXTENSION = /\.[cm]?ts$/;
+var JS_LOADER = "js";
+var JSX_LOADER = "jsx";
+var TS_LOADER = "ts";
+var TSX_LOADER = "tsx";
+var importCostLoader = (path) => {
+  if (path.endsWith(".tsx"))
+    return TSX_LOADER;
+  if (path.endsWith(".jsx"))
+    return JSX_LOADER;
+  if (TYPESCRIPT_EXTENSION.test(path))
+    return TS_LOADER;
+  return JS_LOADER;
+};
+var instrumentModuleSource = (source, moduleIndex) => {
+  const insertAt = prologueEnd(source);
+  const enter = `globalThis.__absoluteImportCostEnter?.(${moduleIndex});`;
+  const exit = `
+;globalThis.__absoluteImportCostExit?.(${moduleIndex});`;
+  return `${source.slice(0, insertAt)}${enter}${source.slice(insertAt)}${exit}`;
+};
+
+// src/dev/importCost/recorder.ts
+var IMPORT_COST_EVENT = {
+  enter: 2,
+  exit: 3,
+  loadEnd: 1,
+  loadStart: 0
+};
+var IMPORT_COST_EVENT_KINDS = 4;
+var ensureImportCostRecorder = () => {
+  const existing = globalThis.__absoluteImportCost;
+  if (existing !== undefined)
+    return existing;
+  const created = {
+    entryModule: null,
+    entryOriginalModule: null,
+    events: [],
+    moduleIds: [],
+    moduleIndexes: new Map,
+    recording: true,
+    rootModule: null
+  };
+  globalThis.__absoluteImportCost = created;
+  return created;
+};
+
+// src/dev/importCost/scope.ts
+import { readdirSync, readFileSync, realpathSync, statSync } from "fs";
+import { join } from "path";
+var NESTED_SCAN_DEPTH = 6;
+var REGEX_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+var SEPARATOR = "[\\\\/]";
+var OUTSIDE_MODULES = `(?!.*${SEPARATOR}node_modules${SEPARATOR}).*`;
+var SOURCE_EXTENSION = "\\.m?[jt]sx?$";
+var ANY_MJS = "\\.mjs$";
+var manifestType = (directory) => {
+  try {
+    const manifest = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+    return Reflect.get(Object(manifest), "type") === "module" ? "module" : "commonjs";
+  } catch {
+    return null;
+  }
+};
+var subdirectories = (directory) => {
+  try {
+    return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+};
+var findCommonJsIslands = (directory, found, depth) => {
+  if (depth > NESTED_SCAN_DEPTH)
+    return;
+  for (const name of subdirectories(directory)) {
+    visitIsland(join(directory, name), name, found, depth);
+  }
+};
+var visitIsland = (directory, name, found, depth) => {
+  if (name === "node_modules" || manifestType(directory) === "commonjs") {
+    found.push(directory);
+    return;
+  }
+  findCommonJsIslands(directory, found, depth + 1);
+};
+var recordPackage = (directory, regions) => {
+  if (manifestType(directory) !== "module")
+    return;
+  regions.esmPrefixes.push(directory);
+  findCommonJsIslands(directory, regions.cjsPrefixes, 0);
+};
+var scanEntry = (modulesRoot, name, regions) => {
+  if (name.startsWith("."))
+    return;
+  if (!name.startsWith("@")) {
+    recordPackage(join(modulesRoot, name), regions);
+    return;
+  }
+  for (const scoped of subdirectories(join(modulesRoot, name))) {
+    recordPackage(join(modulesRoot, name, scoped), regions);
+  }
+};
+var scanPackages = (modulesRoot, regions) => {
+  for (const name of subdirectories(modulesRoot)) {
+    scanEntry(modulesRoot, name, regions);
+  }
+};
+var esmRegions = (root) => {
+  const regions = { cjsPrefixes: [], esmPrefixes: [] };
+  const modulesRoot = join(root, "node_modules");
+  try {
+    statSync(modulesRoot);
+  } catch {
+    return regions;
+  }
+  scanPackages(realpathSync(modulesRoot), regions);
+  return regions;
+};
+var alternation = (prefixes) => prefixes.map((prefix) => prefix.replace(REGEX_SPECIAL, "\\$&")).join("|");
+var instrumentableFilter = (regions) => {
+  const inEsmRegion = regions.esmPrefixes.length === 0 ? "" : `|(?:${alternation(regions.esmPrefixes)}).*`;
+  const notCommonJs = regions.cjsPrefixes.length === 0 ? "" : `(?!(?:${alternation(regions.cjsPrefixes)}))`;
+  return new RegExp(`^${notCommonJs}(?:${OUTSIDE_MODULES}${inEsmRegion})${SOURCE_EXTENSION}|${ANY_MJS}`);
+};
+
+// src/dev/importCostPreload.ts
+var recorder = ensureImportCostRecorder();
+var { events, moduleIds, moduleIndexes } = recorder;
+var record = (moduleIndex, kind) => {
+  events.push(moduleIndex * IMPORT_COST_EVENT_KINDS + kind, performance.now());
+};
+globalThis.__absoluteImportCostEnter = (moduleIndex) => {
+  if (!recorder.recording)
+    return;
+  record(moduleIndex, IMPORT_COST_EVENT.enter);
+};
+globalThis.__absoluteImportCostExit = (moduleIndex) => {
+  if (!recorder.recording)
+    return;
+  record(moduleIndex, IMPORT_COST_EVENT.exit);
+};
+var reportModulePath = () => {
+  const compiled = join2(import.meta.dir, "importCostReport.js");
+  return existsSync(compiled) ? compiled : join2(import.meta.dir, "importCost", "report.ts");
+};
+globalThis.__absoluteImportCostReport = async () => {
+  recorder.recording = false;
+  try {
+    const loaded = await import(reportModulePath());
+    loaded.reportImportCost?.();
+  } catch (error) {
+    console.error(`[absolute] import-cost report failed to load: ${error instanceof Error ? error.message : String(error)}`);
+  }
+};
+var moduleIndexOf = (path) => {
+  const existing = moduleIndexes.get(path);
+  if (existing !== undefined)
+    return existing;
+  const created = moduleIds.length;
+  moduleIds.push(path);
+  moduleIndexes.set(path, created);
+  return created;
+};
+plugin({
+  name: "absolute-import-cost",
+  setup(build) {
+    build.onLoad({ filter: instrumentableFilter(esmRegions(process.cwd())) }, (args) => {
+      const loader = importCostLoader(args.path);
+      if (!recorder.recording) {
+        return {
+          contents: readFileSync2(args.path, "utf8"),
+          loader
+        };
+      }
+      const moduleIndex = moduleIndexOf(args.path);
+      record(moduleIndex, IMPORT_COST_EVENT.loadStart);
+      const contents = instrumentModuleSource(readFileSync2(args.path, "utf8"), moduleIndex);
+      record(moduleIndex, IMPORT_COST_EVENT.loadEnd);
+      return { contents, loader };
+    });
+  }
+});