@clearlydev/nx-archweave 0.3.2 → 0.4.0

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
+};