@clearlydev/nx-archweave 0.3.1 → 0.3.3

package/dist/generators/_chunks/chunk-6ZTIUBB2.js

@@ -0,0 +1,139 @@
+// ../template-engine/dist/backend/eslint-boundaries.js
+var DEFAULT_BOUNDARY_TAGS = { frontend: "scope:frontend", backend: "scope:backend", shared: "scope:shared" };
+function readBoundaryTags(config) {
+  const boundaries = config?.["boundaries"];
+  const tags = typeof boundaries === "object" && boundaries !== null ? boundaries["tags"] : void 0;
+  const pick = (role) => {
+    const value = typeof tags === "object" && tags !== null ? tags[role] : void 0;
+    return typeof value === "string" && value.trim() !== "" ? value : DEFAULT_BOUNDARY_TAGS[role];
+  };
+  return { frontend: pick("frontend"), backend: pick("backend"), shared: pick("shared") };
+}
+function scopeConstraints(tags = DEFAULT_BOUNDARY_TAGS) {
+  return [
+    { sourceTag: tags.frontend, notDependOnLibsWithTags: [tags.backend] },
+    { sourceTag: tags.backend, notDependOnLibsWithTags: [tags.frontend] },
+    { sourceTag: tags.shared, notDependOnLibsWithTags: [tags.frontend, tags.backend] }
+  ];
+}
+var SCOPE_CONSTRAINTS = scopeConstraints();
+var ESLINT_CONFIG_CANDIDATES = ["eslint.config.mjs", "eslint.config.js", "eslint.config.cjs"];
+var appliedMarker = (tags) => `sourceTag: '${tags.frontend}'`;
+var ALLOW_ALL_BLOCK = /depConstraints:\s*\[\s*\{\s*sourceTag:\s*'\*',\s*onlyDependOnLibsWithTags:\s*\[\s*'\*'\s*\],?\s*\},?\s*\]/g;
+function maskComments(text) {
+  const out = text.split("");
+  let mode = "code";
+  let quote = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    const d = text[i + 1];
+    if (mode === "code") {
+      if (c === "'" || c === '"' || c === "`") {
+        mode = "string";
+        quote = c;
+      } else if (c === "/" && d === "/") {
+        mode = "line";
+        out[i] = " ";
+      } else if (c === "/" && d === "*") {
+        mode = "block";
+        out[i] = " ";
+      }
+    } else if (mode === "string") {
+      if (c === "\\") {
+        i++;
+      } else if (c === quote) {
+        mode = "code";
+      }
+    } else if (mode === "line") {
+      if (c === "\n") {
+        mode = "code";
+      } else {
+        out[i] = " ";
+      }
+    } else {
+      if (c === "*" && d === "/") {
+        out[i] = " ";
+        out[i + 1] = " ";
+        i++;
+        mode = "code";
+      } else if (c !== "\n") {
+        out[i] = " ";
+      }
+    }
+  }
+  return out.join("");
+}
+function findAllowAllMatches(masked) {
+  const matches = [];
+  ALLOW_ALL_BLOCK.lastIndex = 0;
+  for (let m = ALLOW_ALL_BLOCK.exec(masked); m !== null; m = ALLOW_ALL_BLOCK.exec(masked)) {
+    matches.push({ index: m.index, length: m[0].length });
+  }
+  return matches;
+}
+function classifyBoundaryConstraints(configText, tags = DEFAULT_BOUNDARY_TAGS) {
+  const masked = maskComments(configText);
+  if (masked.includes(appliedMarker(tags)))
+    return "enforced";
+  if (findAllowAllMatches(masked).length > 0)
+    return "allow-all";
+  return "unknown";
+}
+function renderConstraintsBlock(indent, eol, tags) {
+  const renderList = (list) => list.map((t) => `'${t}'`).join(", ");
+  const inner = scopeConstraints(tags).map((c) => {
+    const field = c.notDependOnLibsWithTags ? `notDependOnLibsWithTags: [${renderList(c.notDependOnLibsWithTags)}]` : `onlyDependOnLibsWithTags: [${renderList(c.onlyDependOnLibsWithTags ?? [])}]`;
+    return [`${indent}  {`, `${indent}    sourceTag: '${c.sourceTag}',`, `${indent}    ${field},`, `${indent}  },`].join(eol);
+  }).join(eol);
+  return [
+    `// nx-archweave boundaries \u2014 the frontend and the backend may never import each other`,
+    `${indent}depConstraints: [`,
+    inner,
+    [
+      `${indent}  // baseline: everything else stays allowed (constraints apply conjunctively)`,
+      `${indent}  {`,
+      `${indent}    sourceTag: '*',`,
+      `${indent}    onlyDependOnLibsWithTags: ['*'],`,
+      `${indent}  },`
+    ].join(eol),
+    `${indent}]`
+  ].join(eol);
+}
+function applyBoundaryConstraints(configText, tags = DEFAULT_BOUNDARY_TAGS) {
+  const classification = classifyBoundaryConstraints(configText, tags);
+  if (classification === "enforced")
+    return { status: "already-applied" };
+  if (classification === "unknown")
+    return { status: "unrecognized" };
+  const masked = maskComments(configText);
+  const matches = findAllowAllMatches(masked);
+  if (matches.length !== 1) {
+    return { status: "unrecognized" };
+  }
+  const [match] = matches;
+  const eol = configText.includes("\r\n") ? "\r\n" : "\n";
+  const lineStart = configText.lastIndexOf("\n", match.index) + 1;
+  const indent = /^[ \t]*/.exec(configText.slice(lineStart, match.index))?.[0] ?? "";
+  const replacement = renderConstraintsBlock(indent, eol, tags);
+  const text = configText.slice(0, match.index) + replacement + configText.slice(match.index + match.length);
+  return { status: "applied", text };
+}
+function buildBoundarySnippet(tags = DEFAULT_BOUNDARY_TAGS) {
+  return [
+    "// nx-archweave project boundaries \u2014 merge these entries into the depConstraints",
+    "// array of the '@nx/enforce-module-boundaries' rule in your root ESLint config.",
+    "// They ride on top of your existing entries: constraints apply conjunctively,",
+    "// so the allow-all baseline can stay.",
+    renderConstraintsBlock("", "\n", tags)
+  ].join("\n");
+}
+
+export {
+  DEFAULT_BOUNDARY_TAGS,
+  readBoundaryTags,
+  ESLINT_CONFIG_CANDIDATES,
+  maskComments,
+  classifyBoundaryConstraints,
+  applyBoundaryConstraints,
+  buildBoundarySnippet
+};

package/dist/generators/_chunks/chunk-AIJCJ7JK.js

@@ -0,0 +1,203 @@
+import {
+  SEGMENT_NAME_PATTERN,
+  isEssenceSegmentName,
+  isUsableSliceApiName,
+  profileById,
+  resolveFrontendApp,
+  resolveSlicePublicApiName
+} from "./chunk-2WSX5YNB.js";
+import {
+  generatorFilesDir,
+  renderTemplateFiles
+} from "./chunk-YNMLB4DL.js";
+import {
+  RECORDED_FRONTENDS,
+  readToolkitConfig,
+  recordedFrontends,
+  resolveLocaleOption
+} from "./chunk-EXYZLL7A.js";
+
+// src/generators/slice/core.ts
+import { join } from "node:path";
+function composeSlice(input) {
+  const files = generatorFilesDir("slice", import.meta.url);
+  const directory = `${input.sourceRoot}/${input.layerDirName}/${input.group === void 0 ? "" : `${input.group}/`}${input.name}`;
+  const shared = input.layer === "shared";
+  const values = {
+    name: input.name,
+    publicApiName: input.publicApiName,
+    layer: input.layer,
+    locale: input.locale,
+    modulePath: shared ? `./${input.name}` : `./model/${input.name}`
+  };
+  const module = renderTemplateFiles(join(files, "module"), shared ? directory : `${directory}/model`, values).filter((file) => input.withSpec !== false || !file.filePath.endsWith(".spec.ts")).sort((a, b) => Number(a.filePath.endsWith(".spec.ts")) - Number(b.filePath.endsWith(".spec.ts")));
+  const segments = shared ? [] : Array.from(new Set(input.segments)).filter((segment) => segment !== "model").flatMap((segment) => renderTemplateFiles(join(files, "segment"), `${directory}/${segment}`, { ...values, segment }));
+  return {
+    directory,
+    publicApiName: input.publicApiName,
+    files: [...renderTemplateFiles(join(files, "index"), directory, values), ...module, ...segments]
+  };
+}
+var KEBAB_CASE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+function layerDirNameFor(layer, frontend) {
+  return profileById(frontend).layerDirs[layer] ?? layer;
+}
+function layerDirFor(layer, sourceRoot, frontend = "react-vite") {
+  return `${sourceRoot}/${layerDirNameFor(layer, frontend)}`;
+}
+function resolveFrontendForApp(option, config, detected) {
+  if (option !== void 0) return option;
+  const recorded = config?.["frontend"];
+  if (typeof recorded === "string" && RECORDED_FRONTENDS.includes(recorded) && recorded !== "none") {
+    return recorded;
+  }
+  return detected;
+}
+function listFilesUnder(tree, dir, prefix = "") {
+  return tree.children(dir).flatMap((child) => {
+    const path = `${dir}/${child}`;
+    return tree.isFile(path) ? [`${prefix}${child}`] : listFilesUnder(tree, path, `${prefix}${child}/`);
+  });
+}
+function computeSliceAction(tree, plan) {
+  if (!tree.exists(plan.directory)) return "created";
+  const expectedNames = plan.files.map((f) => f.filePath.slice(plan.directory.length + 1)).sort();
+  const actualNames = listFilesUnder(tree, plan.directory).sort();
+  if (actualNames.length !== expectedNames.length || !actualNames.every((n, i) => n === expectedNames[i])) {
+    return "skipped";
+  }
+  const allMatch = plan.files.every((f) => tree.read(f.filePath, "utf-8") === f.content);
+  return allMatch ? "unchanged" : "skipped";
+}
+function refusal(reason, dryRun, layer, name, app, extra = {}) {
+  const layerDir = layerDirFor(layer, app.sourceRoot);
+  return {
+    dryRun,
+    layer,
+    name,
+    project: app.project,
+    layerDir,
+    directory: `${layerDir}/${name}`,
+    publicApiName: null,
+    refused: true,
+    refusalReason: reason,
+    action: null,
+    files: [],
+    ...extra
+  };
+}
+function runFsdSlice(tree, layer, options) {
+  const dryRun = options.dryRun ?? false;
+  const unresolved = { project: null, sourceRoot: "<app>/src" };
+  if (!KEBAB_CASE.test(options.name)) {
+    return refusal("invalid-name", dryRun, layer, options.name, unresolved);
+  }
+  if (!isUsableSliceApiName(resolveSlicePublicApiName(options.name, options.publicApiName))) {
+    return refusal("invalid-public-api-name", dryRun, layer, options.name, unresolved);
+  }
+  if (layer === "shared" && isEssenceSegmentName(options.name)) {
+    return refusal("segment-by-essence", dryRun, layer, options.name, unresolved);
+  }
+  const segments = Array.from(new Set(options.segments ?? []));
+  if (segments.length > 0 && layer === "shared") {
+    return refusal("segments-on-shared", dryRun, layer, options.name, unresolved);
+  }
+  const badSegment = segments.find((segment) => !SEGMENT_NAME_PATTERN.test(segment));
+  if (badSegment !== void 0) return refusal("invalid-segment", dryRun, layer, options.name, unresolved, { detail: badSegment });
+  const essenceSegment = segments.find((segment) => isEssenceSegmentName(segment));
+  if (essenceSegment !== void 0) return refusal("segment-by-essence", dryRun, layer, options.name, unresolved, { detail: essenceSegment });
+  if (options.group !== void 0 && layer === "shared") return refusal("group-on-shared", dryRun, layer, options.name, unresolved);
+  if (options.group !== void 0 && (!KEBAB_CASE.test(options.group) || SEGMENT_FOLDERS.includes(options.group) || isEssenceSegmentName(options.group))) {
+    return refusal("invalid-group", dryRun, layer, options.name, unresolved, { detail: options.group });
+  }
+  const app = resolveFrontendApp(tree, options.project);
+  if (app.kind === "not-found") return refusal("project-not-found", dryRun, layer, options.name, { project: app.project, sourceRoot: unresolved.sourceRoot });
+  if (app.kind === "ambiguous") {
+    return refusal("ambiguous-frontend", dryRun, layer, options.name, unresolved, { candidates: app.candidates, recordedFrontends: recordedFrontends(readToolkitConfig(tree)) });
+  }
+  if (app.kind === "invalid-project-json") return refusal("invalid-project-json", dryRun, layer, options.name, unresolved, { detail: app.detail });
+  if (app.kind === "none") return refusal("no-frontend-app", dryRun, layer, options.name, unresolved, { candidates: app.otherProjects });
+  const config = readToolkitConfig(tree);
+  const frontend = resolveFrontendForApp(options.frontend, config, app.framework);
+  const layerDir = layerDirFor(layer, app.sourceRoot, frontend);
+  const locale = resolveLocaleOption(options.locale, config);
+  const requested = options.unitTestRunner !== void 0 && options.unitTestRunner !== "auto" ? options.unitTestRunner : recordedUnitTestRunner(config);
+  const runner = requested ?? detectUnitTestRunner(tree, app.root);
+  const plan = composeSlice({
+    layer,
+    name: options.name,
+    publicApiName: resolveSlicePublicApiName(options.name, options.publicApiName),
+    locale,
+    sourceRoot: app.sourceRoot,
+    layerDirName: layerDirNameFor(layer, frontend),
+    segments,
+    group: options.group,
+    withSpec: runner !== "none"
+  });
+  const action = computeSliceAction(tree, plan);
+  if (action === "created" && !dryRun) {
+    for (const file of plan.files) tree.write(file.filePath, file.content);
+  }
+  return {
+    dryRun,
+    layer,
+    name: options.name,
+    project: app.project,
+    layerDir,
+    directory: plan.directory,
+    publicApiName: plan.publicApiName,
+    refused: false,
+    refusalReason: null,
+    action,
+    files: plan.files,
+    ...runner === "none" ? { specSkipped: requested === "none" ? "none-requested" : "no-test-runner" } : {}
+  };
+}
+var SEGMENT_FOLDERS = ["ui", "model", "api", "lib", "config"];
+function recordedUnitTestRunner(config) {
+  const fsd = config?.["fsd"];
+  const value = typeof fsd === "object" && fsd !== null ? fsd["unitTestRunner"] : void 0;
+  return value === "jest" || value === "vitest" || value === "none" ? value : void 0;
+}
+function hasDependency(tree, manifest, name) {
+  const raw = tree.read(manifest, "utf-8");
+  if (raw === null) return false;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed["dependencies"]?.[name] !== void 0 || parsed["devDependencies"]?.[name] !== void 0;
+  } catch {
+    return false;
+  }
+}
+function detectUnitTestRunner(tree, projectRoot) {
+  const prefix = projectRoot === "" || projectRoot === "." ? "" : `${projectRoot}/`;
+  const project = tree.read(`${prefix}project.json`, "utf-8");
+  if (project !== null) {
+    try {
+      const targets = JSON.parse(project).targets ?? {};
+      for (const target of Object.values(targets)) {
+        if (target?.executor?.startsWith("@nx/jest:")) return "jest";
+        if (target?.executor?.startsWith("@nx/vite:test") || target?.executor?.startsWith("@nx/vitest:")) return "vitest";
+      }
+    } catch {
+    }
+  }
+  for (const dir of prefix === "" ? [""] : [prefix, ""]) {
+    if (["ts", "mts", "cts", "js", "mjs", "cjs"].some((ext) => tree.exists(`${dir}jest.config.${ext}`))) return "jest";
+    if (["ts", "mts", "js", "mjs"].some((ext) => tree.exists(`${dir}vitest.config.${ext}`) || tree.exists(`${dir}vitest.workspace.${ext}`))) return "vitest";
+    for (const ext of ["ts", "mts", "js", "mjs"]) {
+      const vite = tree.read(`${dir}vite.config.${ext}`, "utf-8");
+      if (vite !== null && /\btest\s*:/.test(vite)) return "vitest";
+    }
+  }
+  for (const manifest of prefix === "" ? ["package.json"] : [`${prefix}package.json`, "package.json"]) {
+    if (hasDependency(tree, manifest, "vitest")) return "vitest";
+    if (hasDependency(tree, manifest, "jest")) return "jest";
+  }
+  return "none";
+}
+
+export {
+  runFsdSlice,
+  detectUnitTestRunner
+};