@ng-doc/builder 22.0.0-beta.1 → 22.0.0

package/generator/worker/entry.js

@@ -0,0 +1,614 @@
+// libs/builder/generator/worker/entry.ts
+import { createRequire } from "node:module";
+
+// libs/builder/generator/worker/protocol.ts
+function encode(value) {
+  const result = JSON.stringify(
+    value,
+    function(key, item) {
+      const original = this[key];
+      if (typeof item === "function" || typeof item === "symbol" || typeof item === "bigint" || typeof item === "number" && !Number.isFinite(item) || original !== null && typeof original === "object" && !Array.isArray(original) && (Object.getPrototypeOf(original) !== Object.prototype && Object.getPrototypeOf(original) !== null || typeof original.toJSON === "function"))
+        throw new Error("Worker transport requires JSON values");
+      return item;
+    }
+  );
+  if (result === void 0) throw new Error("Worker transport requires a JSON value");
+  return result;
+}
+function decode(value) {
+  if (typeof value !== "string") throw new Error("Worker message must be JSON text");
+  const parsed = JSON.parse(value);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Worker message must be an object");
+  }
+  return parsed;
+}
+function resultFrom(value) {
+  if (value === null || typeof value !== "object") throw new Error("Invalid compilation result");
+  const result = value;
+  if (!Array.isArray(result.dependencies) || !Array.isArray(result.diagnostics) || !Array.isArray(result.whyRebuilt) || result.candidate !== void 0 && (result.candidate === null || typeof result.candidate !== "object" || !Array.isArray(result.candidate.artifacts))) {
+    throw new Error("Invalid compilation result");
+  }
+  return result;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var FIELD_LEVEL_LIMIT = 16;
+function sameJson(left, right) {
+  return left === right || JSON.stringify(left) === JSON.stringify(right);
+}
+function fields(value, base, skip) {
+  const record = value;
+  const previous = base;
+  const keys = Object.keys(record).filter((key) => record[key] !== void 0);
+  const set = {};
+  for (const key of keys) {
+    if (key === skip) continue;
+    if (!previous || !Object.hasOwn(previous, key) || !sameJson(record[key], previous[key]))
+      set[key] = record[key];
+  }
+  return { keys, set };
+}
+function snapshotDelta(base, candidate) {
+  const previous = new Map((base?.artifacts ?? []).map((artifact) => [artifact.id, artifact]));
+  const unchanged = (artifact) => previous.get(artifact.id)?.revision === artifact.revision;
+  const fieldLevel = candidate.artifacts.filter((artifact) => !unchanged(artifact)).length <= FIELD_LEVEL_LIMIT;
+  return {
+    base: base?.revision ?? null,
+    ...fields(candidate, void 0, "artifacts"),
+    artifacts: candidate.artifacts.map(
+      (artifact) => unchanged(artifact) ? { id: artifact.id, revision: artifact.revision } : {
+        id: artifact.id,
+        revision: artifact.revision,
+        ...fields(artifact, fieldLevel ? previous.get(artifact.id) : void 0)
+      }
+    )
+  };
+}
+function object(value, what) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`Invalid snapshot delta: ${what}`);
+  return value;
+}
+function strings(value, what) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string"))
+    throw new Error(`Invalid snapshot delta: ${what}`);
+  return value;
+}
+function assemble(keys, set, base, what, artifacts) {
+  const result = {};
+  for (const key of keys) {
+    if (key === "__proto__" || Object.hasOwn(result, key))
+      throw new Error(`Invalid snapshot delta: ${what} key ${key}`);
+    if (artifacts && key === "artifacts") result[key] = artifacts;
+    else if (Object.hasOwn(set, key)) result[key] = set[key];
+    else if (base && Object.hasOwn(base, key)) result[key] = base[key];
+    else throw new Error(`Invalid snapshot delta: ${what} has no base value for ${key}`);
+  }
+  return result;
+}
+function applySnapshotDelta(base, value) {
+  const delta = object(value, "delta");
+  if (delta["base"] !== (base?.revision ?? null))
+    throw new Error(
+      `Invalid snapshot delta: base ${String(delta["base"])} is not ${String(base?.revision ?? null)}`
+    );
+  const previous = /* @__PURE__ */ new Map();
+  for (const artifact of base?.artifacts ?? []) {
+    if (previous.has(artifact.id))
+      throw new Error(`Invalid snapshot delta: duplicate base artifact ${artifact.id}`);
+    previous.set(artifact.id, artifact);
+  }
+  if (!Array.isArray(delta["artifacts"])) throw new Error("Invalid snapshot delta: artifacts");
+  const seen = /* @__PURE__ */ new Set();
+  const artifacts = delta["artifacts"].map((item) => {
+    const entry = object(item, "artifact entry");
+    const id = entry["id"];
+    const revision = entry["revision"];
+    if (typeof id !== "string" || typeof revision !== "string" || seen.has(id))
+      throw new Error(`Invalid snapshot delta: artifact ${String(id)}`);
+    seen.add(id);
+    const old = previous.get(id);
+    if (!("keys" in entry)) {
+      if (!old || old.revision !== revision)
+        throw new Error(`Invalid snapshot delta: no base artifact ${id} at ${revision}`);
+      return old;
+    }
+    const artifact = assemble(
+      strings(entry["keys"], `artifact ${id} keys`),
+      object(entry["set"], `artifact ${id} values`),
+      old,
+      `artifact ${id}`
+    );
+    if (artifact["id"] !== id || artifact["revision"] !== revision)
+      throw new Error(`Invalid snapshot delta: artifact ${id} identity`);
+    return artifact;
+  });
+  const keys = strings(delta["keys"], "snapshot keys");
+  if (!keys.includes("artifacts")) throw new Error("Invalid snapshot delta: snapshot artifacts");
+  const snapshot = assemble(
+    keys,
+    object(delta["set"], "snapshot values"),
+    base,
+    "snapshot",
+    artifacts
+  );
+  if (typeof snapshot["revision"] !== "string" || typeof snapshot["projectId"] !== "string")
+    throw new Error("Invalid snapshot delta: snapshot identity");
+  return snapshot;
+}
+function deepFreeze(value) {
+  const pending = [value];
+  while (pending.length) {
+    const item = pending.pop();
+    if (item === null || typeof item !== "object" || Object.isFrozen(item)) continue;
+    Object.freeze(item);
+    for (const child of Object.values(item)) pending.push(child);
+  }
+  return value;
+}
+function createRuntimeRetention() {
+  let committed;
+  let working;
+  let invalidated;
+  const counters = { offered: 0, promoted: 0, dropped: 0 };
+  const commit = (entry) => {
+    committed = entry;
+    invalidated = void 0;
+  };
+  const settle = (revision) => {
+    if (working !== void 0 && working.base === revision) {
+      commit(working);
+      counters.promoted++;
+    } else if (working !== void 0) {
+      counters.dropped++;
+      if (!committed) invalidated ??= "dropped unacknowledged";
+    }
+    working = void 0;
+  };
+  return {
+    serve(promotion) {
+      return Object.freeze({
+        take() {
+          const entry = committed;
+          committed = void 0;
+          return entry;
+        },
+        offer(entry) {
+          if (promotion === "compile-end") {
+            commit(entry);
+            return;
+          }
+          working = entry;
+          counters.offered++;
+        },
+        restore(entry) {
+          if (committed) return false;
+          commit(entry);
+          return true;
+        },
+        invalidate(reason) {
+          if (!committed) invalidated = reason;
+        },
+        held: () => ({
+          ...committed ? { committed: committed.base } : {},
+          ...working ? { working: working.base } : {},
+          ...!committed && invalidated !== void 0 ? { invalidated } : {}
+        })
+      });
+    },
+    promote: settle,
+    resync: settle,
+    inspect: () => ({
+      committed: committed?.base ?? null,
+      working: working?.base ?? null,
+      invalidated: committed ? null : invalidated ?? null,
+      counters: { ...counters }
+    })
+  };
+}
+var PROGRESS_INTERVAL_MS = 100;
+function createProgressChannel(send2, now = () => performance.now()) {
+  let closed = false;
+  let sentAt = Number.NEGATIVE_INFINITY;
+  let pending;
+  let timer;
+  const deliver = (update) => {
+    try {
+      send2(update);
+    } catch {
+    }
+  };
+  const flush = () => {
+    timer = void 0;
+    const update = pending;
+    pending = void 0;
+    if (!update || closed) return;
+    sentAt = now();
+    deliver(update);
+  };
+  const drop = () => {
+    pending = void 0;
+    if (timer !== void 0) clearTimeout(timer);
+    timer = void 0;
+  };
+  return {
+    sink(update) {
+      if (closed) return;
+      if (update.state !== "advance") {
+        drop();
+        deliver(update);
+        return;
+      }
+      const wait = sentAt + PROGRESS_INTERVAL_MS - now();
+      if (wait <= 0) {
+        drop();
+        sentAt = now();
+        deliver(update);
+        return;
+      }
+      pending = update;
+      timer ??= setTimeout(flush, wait).unref();
+    },
+    close() {
+      closed = true;
+      drop();
+    }
+  };
+}
+
+// libs/builder/generator/worker/entry.ts
+var dryRunReport;
+var renderThreads;
+function exit() {
+  void (renderThreads?.dispose() ?? Promise.resolve()).catch(() => void 0).finally(() => process.exit(0));
+}
+var send = (message) => {
+  process.send(message);
+};
+function progressFor(job, id, context) {
+  if (job["progress"] !== true || job["prime"] === true) return void 0;
+  const channel = createProgressChannel((update) => send(encode({ type: "progress", id, update })));
+  Object.defineProperty(context, "progress", { value: channel.sink, enumerable: false });
+  return channel;
+}
+async function load(options) {
+  if (typeof options["moduleUrl"] !== "string") throw new Error("Missing compilation module URL");
+  const module = await import(options["moduleUrl"]);
+  if (typeof module.createCompilationService !== "function") {
+    throw new Error("Compilation module must export createCompilationService(options)");
+  }
+  if (typeof module.targetedDryRun === "function") dryRunReport = module.targetedDryRun;
+  if (typeof module.keepRenderThreads === "function" && typeof module.disposeRenderThreads === "function")
+    renderThreads = { keep: module.keepRenderThreads, dispose: module.disposeRenderThreads };
+  return module.createCompilationService;
+}
+async function create(factory, options) {
+  const service = await factory(options);
+  if (!service || typeof service.compile !== "function" || typeof service.dispose !== "function") {
+    throw new Error("Factory must return a CompilationService");
+  }
+  return service;
+}
+async function start(workerData) {
+  const options = decode(workerData);
+  const factory = await load(options);
+  const service = await create(factory, options["factoryOptions"]);
+  process.once("message", async (message) => {
+    let id;
+    try {
+      const job = decode(message);
+      id = job["id"];
+      if (job["type"] !== "compile" || !Number.isSafeInteger(id))
+        throw new Error("Invalid compile message");
+      let result;
+      const context = { lifetime: "generation" };
+      const progress = progressFor(job, id, context);
+      try {
+        result = resultFrom(
+          await service.compile(
+            job["request"],
+            new AbortController().signal,
+            context
+          )
+        );
+      } finally {
+        progress?.close();
+        await service.dispose();
+        await renderThreads?.dispose().catch(() => void 0);
+      }
+      send(encode({ type: "result", id, result }));
+    } catch (error) {
+      send(encode({ type: "failure", id, message: errorMessage(error) }));
+    }
+  });
+  send(encode({ type: "ready" }));
+}
+function primedReply(result) {
+  const error = result.diagnostics.find((item) => item.severity === "error");
+  return result.candidate && !error ? { revision: result.candidate.revision } : {
+    code: error?.code ?? "WORKER_PRIME_NO_CANDIDATE",
+    message: error?.message ?? "The warm-up compile returned no candidate"
+  };
+}
+var moduleCache = createRequire(import.meta.url).cache;
+var PACKAGE_MODULE = /[\\/]node_modules[\\/]/;
+function replaceEnv(env) {
+  for (const key of Object.keys(process.env)) if (!(key in env)) delete process.env[key];
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === "string" && process.env[key] !== value) process.env[key] = value;
+  }
+}
+function changeDirectory(directory) {
+  try {
+    if (typeof directory === "string" && process.cwd() !== directory) process.chdir(directory);
+  } catch {
+  }
+}
+function isolate(host) {
+  if (host !== null && typeof host === "object" && !Array.isArray(host)) {
+    const { env: env2, cwd: cwd2 } = host;
+    if (env2 !== null && typeof env2 === "object" && !Array.isArray(env2)) {
+      replaceEnv(env2);
+    }
+    changeDirectory(cwd2);
+  }
+  const env = { ...process.env };
+  const cwd = process.cwd();
+  const umask = process.umask();
+  const listeners = new Map(
+    process.eventNames().map((name) => [name, new Set(process.rawListeners(name))])
+  );
+  const modules = new Set(Object.keys(moduleCache));
+  return () => {
+    for (const name of process.eventNames()) {
+      const before = listeners.get(name);
+      for (const listener of process.rawListeners(name)) {
+        if (!before?.has(listener)) {
+          process.removeListener(name, listener);
+        }
+      }
+    }
+    let stale = false;
+    for (const key of Object.keys(moduleCache)) {
+      if (modules.has(key) || PACKAGE_MODULE.test(key)) continue;
+      if (Object.prototype.toString.call(moduleCache[key]?.exports) === "[object Module]") {
+        stale = true;
+      }
+      delete moduleCache[key];
+    }
+    replaceEnv(env);
+    changeDirectory(cwd);
+    process.umask(umask);
+    process.exitCode = void 0;
+    return { stale };
+  };
+}
+function snapshotFor(value, base) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && value.revision === base && typeof value.projectId === "string" && Array.isArray(value.artifacts);
+}
+function withMembers(text, members) {
+  const extra = Object.entries(members).map(([key, value]) => `,${JSON.stringify(key)}:${value}`).join("");
+  return extra ? `${text.slice(0, -1)}${extra}}` : text;
+}
+async function serve(workerData) {
+  const options = decode(workerData);
+  const factory = await load(options);
+  renderThreads?.keep(true);
+  await (await create(factory, options["factoryOptions"])).dispose();
+  let base = null;
+  let committed;
+  let working;
+  let running;
+  let disposing = false;
+  const retention = createRuntimeRetention();
+  let pending;
+  const state = () => ({
+    base,
+    committed: committed?.revision ?? null,
+    working: working?.revision ?? null
+  });
+  const settle = () => {
+    const next = pending;
+    pending = void 0;
+    if (!next) return;
+    try {
+      working = applySnapshotDelta(next.base, JSON.parse(next.text));
+      if (next.verify) deepFreeze(working);
+    } catch {
+      working = void 0;
+    }
+    if (next.large) committed = void 0;
+  };
+  const compile = async (job) => {
+    const id = job["id"];
+    const controller = new AbortController();
+    running = { id, controller };
+    const release = isolate(job["host"]);
+    const request = job["request"];
+    const previous = request?.previous;
+    const delta = job["delta"] === true && job["prime"] !== true && job["full"] !== true;
+    let reply;
+    const members = {};
+    const deltaOf = (base2, candidate) => {
+      try {
+        const delta2 = snapshotDelta(base2, candidate);
+        const encoded = encode(delta2);
+        applySnapshotDelta(base2, delta2);
+        pending = {
+          base: base2,
+          text: encoded,
+          large: delta2.artifacts.filter((entry) => "keys" in entry).length > FIELD_LEVEL_LIMIT,
+          verify: job["verify"] === true
+        };
+        return encoded;
+      } catch {
+        return void 0;
+      }
+    };
+    const dryRuns = dryRunReport?.().counters.generations ?? 0;
+    try {
+      const service = await create(factory, options["factoryOptions"]);
+      let result;
+      let progress;
+      try {
+        const context = { lifetime: "watch" };
+        Object.defineProperty(context, "retention", {
+          value: retention.serve(delta ? "acknowledged" : "compile-end"),
+          enumerable: false
+        });
+        progress = progressFor(job, id, context);
+        result = resultFrom(await service.compile(request, controller.signal, context));
+      } finally {
+        progress?.close();
+        await service.dispose();
+      }
+      if (job["prime"] === true) {
+        reply = {
+          type: "result",
+          id,
+          result: { dependencies: [], diagnostics: [], whyRebuilt: [] },
+          primed: primedReply(result)
+        };
+      } else {
+        const { candidate, ...rest } = result;
+        const text = delta && candidate ? deltaOf(previous, candidate) : void 0;
+        if (text === void 0) {
+          reply = { type: "result", id, result };
+        } else {
+          if (job["verify"] === true) members["full"] = encode(candidate);
+          members["delta"] = text;
+          reply = { type: "result", id, result: rest, working: candidate.revision };
+        }
+        const dryRun = dryRunReport?.();
+        if (dryRun && dryRun.counters.generations > dryRuns) reply["dryRun"] = dryRun.last;
+      }
+    } catch (error) {
+      pending = void 0;
+      reply = { type: "failure", id, message: errorMessage(error) };
+    }
+    const { stale } = release();
+    running = void 0;
+    let message;
+    const { working: next, ...reported } = reply;
+    reply = reported;
+    const promised = () => pending ? {
+      base,
+      committed: pending.large ? null : committed?.revision ?? null,
+      working: next
+    } : state();
+    try {
+      message = withMembers(
+        encode({
+          ...reply,
+          state: promised(),
+          rss: process.memoryUsage().rss,
+          ...stale ? { recycle: true } : {}
+        }),
+        members
+      );
+    } catch (error) {
+      pending = void 0;
+      message = encode({ type: "failure", id, message: errorMessage(error), state: state() });
+    }
+    process.send(message, () => {
+      if (disposing) return exit();
+      settle();
+      if (running) return;
+      globalThis.gc?.();
+      send(encode({ type: "idle", rss: process.memoryUsage().rss }));
+    });
+  };
+  process.on("message", (message) => {
+    let job;
+    try {
+      job = decode(message);
+    } catch (error) {
+      send(encode({ type: "failure", message: errorMessage(error) }));
+      return;
+    }
+    const id = job["id"];
+    if (job["type"] === "abort") {
+      if (running && running.id === id) running.controller.abort();
+    } else if (job["type"] === "dispose") {
+      disposing = true;
+      if (!running) return exit();
+      running.controller.abort();
+    } else if (job["type"] === "resync" && !running && (job["base"] === null || typeof job["base"] === "string") && (job["snapshot"] === void 0 || snapshotFor(job["snapshot"], job["base"]))) {
+      pending = void 0;
+      retention.resync(job["base"]);
+      base = job["base"];
+      committed = job["snapshot"];
+      if (committed && job["verify"] === true) deepFreeze(committed);
+      working = void 0;
+      send(encode({ type: "resynced", base, state: state() }));
+    } else if (job["type"] === "compile" && Number.isSafeInteger(id) && !running) {
+      settle();
+      if (typeof job["promote"] === "string" && working?.revision === job["promote"]) {
+        committed = working;
+        base = job["promote"];
+      }
+      retention.promote(job["promote"]);
+      working = void 0;
+      if (job["delta"] !== true) committed = void 0;
+      if (job["base"] !== base) {
+        send(
+          encode({
+            type: "failure",
+            id,
+            code: "WORKER_BASE_MISMATCH",
+            message: `Compile base ${String(job["base"])} does not match the acknowledged base ${String(base)}`,
+            state: state()
+          })
+        );
+        return;
+      }
+      if (job["delta"] === true && job["retained"] === true) {
+        const request = job["request"];
+        if (!committed || committed.revision !== base || request === null || typeof request !== "object" || Array.isArray(request)) {
+          send(
+            encode({
+              type: "failure",
+              id,
+              code: "WORKER_RESYNC_REQUIRED",
+              message: `No retained snapshot for base ${String(base)}`,
+              state: state()
+            })
+          );
+          return;
+        }
+        request.previous = committed;
+      }
+      if (job["prime"] === true && base !== null && retention.inspect().committed === base) {
+        send(
+          encode({
+            type: "result",
+            id,
+            result: { dependencies: [], diagnostics: [], whyRebuilt: [] },
+            primed: { revision: base },
+            state: state(),
+            rss: process.memoryUsage().rss
+          })
+        );
+        return;
+      }
+      void compile(job);
+    } else {
+      send(encode({ type: "failure", id, message: `Invalid ${String(job["type"])} message` }));
+    }
+  });
+  send(encode({ type: "ready", base, delta: true }));
+}
+process.once("message", (workerData) => {
+  process.channel.ref();
+  process.once("disconnect", () => process.exit(0));
+  let persistent = false;
+  try {
+    persistent = decode(workerData)["persistent"] === true;
+  } catch {
+  }
+  void (persistent ? serve(workerData) : start(workerData)).catch((error) => {
+    process.send(encode({ type: "failure", message: errorMessage(error) }));
+  });
+});