@clearlydev/nx-archweave 0.3.2 → 0.4.0

package/dist/eslint/index.js

@@ -1,315 +1,22 @@
+import {
+  fsdBoundariesRule
+} from "../generators/_chunks/chunk-MQNQJOWA.js";
+import {
+  readRecordedFsd,
+  resolveFsdPolicy
+} from "../generators/_chunks/chunk-5MI3O4VZ.js";
+
 // src/eslint/index.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname3, join as join3, posix as posix2, resolve as resolve3, sep as sep3 } from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname2, join, posix, resolve as resolve2, sep as sep2 } from "node:path";
 import { fileURLToPath } from "node:url";
 
-// src/eslint/fsd-boundaries.ts
-import { posix, relative, resolve, sep } from "node:path";
-
-// src/eslint/fsd-policy.ts
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-var PRESETS = {
-  basic: {
-    sliceGroups: { auto: true, include: [], exclude: [] },
-    sharedPublicApi: "segment",
-    testFiles: false,
-    segments: [],
-    platformSuffixes: [],
-    routerDirs: []
-  },
-  practical: {
-    sliceGroups: { auto: true, include: [], exclude: [] },
-    sharedPublicApi: "file",
-    testFiles: ["**/*.{spec,test}.*", "**/__tests__/**"],
-    segments: [],
-    platformSuffixes: [],
-    routerDirs: []
-  }
-};
-var isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
-function resolveFsdPolicy(recorded, overrides = {}) {
-  const fsd = typeof recorded === "object" && recorded !== null ? recorded : {};
-  const preset = fsd["preset"] === "practical" ? "practical" : "basic";
-  const policy = { ...PRESETS[preset] };
-  const groups = fsd["sliceGroups"];
-  if (groups === false) policy.sliceGroups = false;
-  else if (groups === "auto") policy.sliceGroups = { auto: true, include: [], exclude: [] };
-  else if (typeof groups === "object" && groups !== null) {
-    const value = groups;
-    policy.sliceGroups = {
-      auto: value["auto"] !== false,
-      include: isStringArray(value["include"]) ? value["include"] : [],
-      exclude: isStringArray(value["exclude"]) ? value["exclude"] : []
-    };
-  }
-  const shared = fsd["sharedPublicApi"];
-  if (shared === "segment" || shared === "component" || shared === "file") policy.sharedPublicApi = shared;
-  const tests = fsd["testFiles"];
-  if (tests === false || isStringArray(tests)) policy.testFiles = tests;
-  if (isStringArray(fsd["segments"])) policy.segments = fsd["segments"];
-  if (isStringArray(fsd["platformSuffixes"])) policy.platformSuffixes = fsd["platformSuffixes"];
-  if (isStringArray(fsd["routerDirs"])) policy.routerDirs = fsd["routerDirs"];
-  for (const [key, value] of Object.entries(overrides)) {
-    if (value !== void 0) policy[key] = value;
-  }
-  return policy;
-}
-function readRecordedFsd(from) {
-  for (let dir = from; ; dir = dirname(dir)) {
-    const file = join(dir, "toolkit.config.json");
-    if (existsSync(file)) {
-      try {
-        return JSON.parse(readFileSync(file, "utf-8"))["fsd"];
-      } catch {
-        return void 0;
-      }
-    }
-    if (dirname(dir) === dir) return void 0;
-  }
-}
-var escapeLiteral = (text) => text.replace(/[.+^$()|[\]\\{}]/g, "\\$&");
-function wildcardsToRegExp(glob) {
-  let source = "";
-  for (let i = 0; i < glob.length; i++) {
-    const ch = glob[i];
-    if (ch === "*" && glob[i + 1] === "*") {
-      const slash = glob[i + 2] === "/";
-      source += slash ? "(?:.*/)?" : ".*";
-      i += slash ? 2 : 1;
-    } else if (ch === "*") source += "[^/]*";
-    else if (ch === "?") source += "[^/]";
-    else source += escapeLiteral(ch);
-  }
-  return source;
-}
-function globToRegExp(glob) {
-  let source = "";
-  let rest = glob;
-  for (; ; ) {
-    const open = rest.indexOf("{");
-    const close = open === -1 ? -1 : rest.indexOf("}", open);
-    if (open === -1 || close === -1) {
-      source += wildcardsToRegExp(rest);
-      break;
-    }
-    source += wildcardsToRegExp(rest.slice(0, open));
-    source += `(?:${rest.slice(open + 1, close).split(",").map(wildcardsToRegExp).join("|")})`;
-    rest = rest.slice(close + 1);
-  }
-  return new RegExp(`^${source}$`);
-}
-
-// src/eslint/slice-groups.ts
-import { readdirSync, statSync } from "node:fs";
-import { join as join2 } from "node:path";
-var SEGMENTS = [
-  "ui",
-  "model",
-  "api",
-  "lib",
-  "config",
-  "components",
-  "hooks",
-  "types",
-  "utils",
-  "helpers",
-  "constants",
-  "consts",
-  "store",
-  "stores",
-  "styles",
-  "assets",
-  "services",
-  "context"
-];
-var IGNORED = /^(\.|readme(\.|$))/i;
-var listings = /* @__PURE__ */ new Map();
-function list(dir) {
-  let mtimeMs;
-  try {
-    mtimeMs = statSync(dir).mtimeMs;
-  } catch {
-    listings.delete(dir);
-    return null;
-  }
-  const cached = listings.get(dir);
-  if (cached !== void 0 && cached.mtimeMs === mtimeMs) return cached.entries;
-  try {
-    const entries = readdirSync(dir, { withFileTypes: true }).map((entry) => ({ name: entry.name, directory: entry.isDirectory() }));
-    listings.set(dir, { mtimeMs, entries });
-    return entries;
-  } catch {
-    return null;
-  }
-}
-function createGroupDetector(rootAbsolute, policy, isIndexFile, listDirectory = list) {
-  const groups = policy.sliceGroups;
-  if (groups === false) return () => false;
-  const segments = /* @__PURE__ */ new Set([...SEGMENTS, ...policy.segments]);
-  return (layerDir, name) => {
-    const key = `${layerDir}/${name}`;
-    if (groups.include.includes(key)) return true;
-    if (groups.exclude.includes(key) || !groups.auto) return false;
-    const entries = listDirectory(join2(rootAbsolute, layerDir, name))?.filter((entry) => !IGNORED.test(entry.name)) ?? null;
-    if (entries === null || entries.length === 0) return false;
-    if (entries.some((entry) => !entry.directory || segments.has(entry.name))) return false;
-    return entries.some((entry) => listDirectory(join2(rootAbsolute, layerDir, name, entry.name))?.some((child) => !child.directory && isIndexFile(child.name)) ?? false);
-  };
-}
-
-// src/eslint/fsd-boundaries.ts
-var LAYER_ORDER = ["app", "pages", "widgets", "features", "entities", "shared"];
-var LAYER_BY_DIR = {
-  app: "app",
-  _app: "app",
-  pages: "pages",
-  _pages: "pages",
-  widgets: "widgets",
-  features: "features",
-  entities: "entities",
-  shared: "shared"
-};
-var SLICED_LAYERS = /* @__PURE__ */ new Set(["pages", "widgets", "features", "entities"]);
-function indexFilePattern(platformSuffixes) {
-  const platforms = platformSuffixes.length === 0 ? "" : `(\\.(${platformSuffixes.map((suffix) => suffix.replace(/[^a-z0-9-]/gi, "")).join("|")}))?`;
-  return new RegExp(`^index${platforms}(\\.[cm]?[jt]sx?)?$`);
-}
-var DEFAULT_POLICY = resolveFsdPolicy(void 0);
-var NO_GROUPS = () => false;
-function locate(rootRelativePath, policy = DEFAULT_POLICY, isGroup = NO_GROUPS) {
-  const segments = rootRelativePath.split("/").filter((s) => s.length > 0 && s !== ".");
-  if (segments.length === 0) return null;
-  const layer = policy.routerDirs.includes(segments[0]) ? "app" : LAYER_BY_DIR[segments[0]];
-  if (layer === void 0) return null;
-  let unit;
-  let rest;
-  if (layer === "app") {
-    unit = null;
-    rest = segments.slice(1);
-  } else if (layer === "shared") {
-    const component = policy.sharedPublicApi === "component" && segments.length > 2;
-    unit = segments[1] === void 0 ? null : component ? `${segments[1]}/${segments[2]}` : segments[1];
-    rest = policy.sharedPublicApi === "file" ? [] : segments.slice(component ? 3 : 2);
-  } else if (segments[1] !== void 0 && isGroup(segments[0], segments[1])) {
-    if (segments[2] === void 0) return { layer, unit: segments[1], rest: [], group: true };
-    unit = `${segments[1]}/${segments[2]}`;
-    rest = segments.slice(3);
-  } else {
-    unit = segments[1] ?? null;
-    rest = segments.slice(2);
-  }
-  if (rest.length > 0 && indexFilePattern(policy.platformSuffixes).test(rest[rest.length - 1])) rest.pop();
-  return { layer, unit, rest };
-}
-function judge(from, to) {
-  if (LAYER_ORDER.indexOf(to.layer) < LAYER_ORDER.indexOf(from.layer)) return { kind: "upward", from, to };
-  if (to.unit === null) return null;
-  if (to.group) return { kind: "group", from, to };
-  const sameUnit = from.layer === to.layer && from.unit === to.unit;
-  if (sameUnit) return null;
-  const importerSlice = from.unit?.split("/").pop();
-  const viaCrossImportApi = to.rest[0] === "@x" && to.rest[1] === importerSlice && from.layer === to.layer;
-  if (viaCrossImportApi) return null;
-  if (from.layer === to.layer && SLICED_LAYERS.has(to.layer)) return { kind: "cross-slice", from, to };
-  if (to.rest.length > 0) return { kind: "sidestep", from, to };
-  return null;
-}
-function describeLocation(location) {
-  return location.unit === null ? location.layer : `${location.layer}/${location.unit}`;
-}
-function resolveSpecifier(specifier, importerRootRelative, options) {
-  let rootRelative = null;
-  if (specifier.startsWith("./") || specifier.startsWith("../") || specifier === "." || specifier === "..") {
-    rootRelative = posix.normalize(posix.join(posix.dirname(importerRootRelative), specifier));
-  } else {
-    for (const [prefix, target] of Object.entries(options.aliases)) {
-      if (!specifier.startsWith(prefix)) continue;
-      const absolute = resolve(resolve(options.cwd, target), specifier.slice(prefix.length));
-      rootRelative = toPosix(relative(options.rootAbsolute, absolute)) || ".";
-      break;
-    }
-  }
-  if (rootRelative === null) return null;
-  if (rootRelative === ".." || rootRelative.startsWith("../")) return null;
-  return rootRelative;
-}
-function toPosix(path) {
-  return sep === "/" ? path : path.split(sep).join("/");
-}
-var fsdBoundariesRule = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Enforce canonical Feature-Sliced Design import rules inside a frontend app",
-      url: "https://github.com/clearlydev/nx-archweave#fsd-lite"
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          root: { type: "string" },
-          aliases: { type: "object", additionalProperties: { type: "string" } },
-          policy: { type: "object" }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      upward: 'FSD: "{{from}}" may not import from "{{to}}" (a higher layer).',
-      crossSlice: 'FSD: "{{from}}" may not import a sibling slice "{{to}}" \u2014 move the shared part down a layer, or expose it through "{{to}}/@x/{{fromUnit}}".',
-      sidestep: 'FSD: import "{{to}}" through its public API (index.ts), not its internal file "{{path}}".',
-      group: 'FSD: "{{to}}" is a group of slices, not a slice \u2014 import one of its slices through its index.ts.'
-    }
-  },
-  create(context) {
-    const options = context.options[0] ?? {};
-    const root = options.root ?? "src";
-    const aliases = options.aliases ?? { "@/": root };
-    const cwd = context.cwd;
-    const rootAbsolute = resolve(cwd, root);
-    const importerRootRelative = toPosix(relative(rootAbsolute, context.filename));
-    if (importerRootRelative === "" || importerRootRelative.startsWith("..")) return {};
-    const policy = resolveFsdPolicy(void 0, options.policy ?? {});
-    const isIndexFile = (name) => indexFilePattern(policy.platformSuffixes).test(name);
-    const isGroup = createGroupDetector(rootAbsolute, policy, isIndexFile);
-    const from = locate(importerRootRelative, policy, isGroup);
-    if (from === null) return {};
-    const isTestFile = policy.testFiles !== false && policy.testFiles.some((glob) => globToRegExp(glob).test(importerRootRelative));
-    const check = (node, specifier) => {
-      if (typeof specifier !== "string") return;
-      const target = resolveSpecifier(specifier, importerRootRelative, { rootAbsolute, cwd, aliases });
-      if (target === null) return;
-      const to = locate(target, policy, isGroup);
-      if (to === null) return;
-      const violation = judge(from, to);
-      if (violation === null || isTestFile && violation.kind !== "upward") return;
-      const data = { from: describeLocation(from), to: describeLocation(to), fromUnit: from.unit?.split("/").pop() ?? "", path: target };
-      context.report({
-        node,
-        messageId: violation.kind === "cross-slice" ? "crossSlice" : violation.kind,
-        data
-      });
-    };
-    const fromSource = (node) => check(node, node.source?.value);
-    return {
-      ImportDeclaration: fromSource,
-      ExportNamedDeclaration: fromSource,
-      ExportAllDeclaration: fromSource,
-      ImportExpression: (node) => {
-        const argument = node.source;
-        if (argument && argument.type === "Literal") check(node, argument.value);
-      }
-    };
-  }
-};
-
 // src/eslint/tsconfig-aliases.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { dirname as dirname2, isAbsolute, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 function aliasesFromTsconfig({ cwd, tsconfig = "tsconfig.json", maxDepth = 8 }) {
   const aliases = {};
-  let current = resolve2(cwd, tsconfig);
+  let current = resolve(cwd, tsconfig);
   const seen = /* @__PURE__ */ new Set();
   for (let depth = 0; current !== null && depth < maxDepth && !seen.has(current); depth++) {
     seen.add(current);
@@ -318,37 +25,37 @@ function aliasesFromTsconfig({ cwd, tsconfig = "tsconfig.json", maxDepth = 8 })
     const compilerOptions = asRecord(config["compilerOptions"]);
     const paths = asRecord(compilerOptions?.["paths"]);
     if (paths) {
-      const baseUrl = typeof compilerOptions?.["baseUrl"] === "string" ? resolve2(dirname2(current), compilerOptions["baseUrl"]) : dirname2(current);
+      const baseUrl = typeof compilerOptions?.["baseUrl"] === "string" ? resolve(dirname(current), compilerOptions["baseUrl"]) : dirname(current);
       for (const [pattern, targets] of Object.entries(paths)) {
         if (!pattern.endsWith("*")) continue;
         const prefix = pattern.slice(0, -1);
         if (prefix in aliases) continue;
         const target = Array.isArray(targets) ? targets.find((t) => typeof t === "string") : void 0;
         if (target === void 0 || !target.endsWith("/*")) continue;
-        const dir = toPosix2(relative2(cwd, resolve2(baseUrl, target.slice(0, -"/*".length))));
+        const dir = toPosix(relative(cwd, resolve(baseUrl, target.slice(0, -"/*".length))));
         aliases[prefix] = dir === "" ? "." : dir;
       }
     }
     const parent = config["extends"];
     const parentPath = typeof parent === "string" ? parent : Array.isArray(parent) ? parent.find((p) => typeof p === "string") : void 0;
-    current = parentPath !== void 0 && (parentPath.startsWith(".") || isAbsolute(parentPath)) ? resolveExtends(dirname2(current), parentPath) : null;
+    current = parentPath !== void 0 && (parentPath.startsWith(".") || isAbsolute(parentPath)) ? resolveExtends(dirname(current), parentPath) : null;
   }
   return aliases;
 }
 function resolveExtends(fromDir, target) {
-  const candidates = [resolve2(fromDir, target), resolve2(fromDir, `${target}.json`)];
-  return candidates.find((candidate) => existsSync2(candidate)) ?? null;
+  const candidates = [resolve(fromDir, target), resolve(fromDir, `${target}.json`)];
+  return candidates.find((candidate) => existsSync(candidate)) ?? null;
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
-function toPosix2(path) {
-  return sep2 === "/" ? path : path.split(sep2).join("/");
+function toPosix(path) {
+  return sep === "/" ? path : path.split(sep).join("/");
 }
 function readJsonc(path) {
   let text;
   try {
-    text = readFileSync2(path, "utf-8");
+    text = readFileSync(path, "utf-8");
   } catch {
     return null;
   }
@@ -398,14 +105,14 @@ function readJsonc(path) {
 
 // src/eslint/index.ts
 function ownVersion() {
-  let dir = dirname3(fileURLToPath(import.meta.url));
+  let dir = dirname2(fileURLToPath(import.meta.url));
   for (; ; ) {
-    const manifest = join3(dir, "package.json");
-    if (existsSync3(manifest)) {
-      const pkg = JSON.parse(readFileSync3(manifest, "utf-8"));
+    const manifest = join(dir, "package.json");
+    if (existsSync2(manifest)) {
+      const pkg = JSON.parse(readFileSync2(manifest, "utf-8"));
       if (pkg.name === "@clearlydev/nx-archweave" && pkg.version) return pkg.version;
     }
-    const parent = dirname3(dir);
+    const parent = dirname2(dir);
     if (parent === dir) throw new Error("@clearlydev/nx-archweave: its own package.json was not found");
     dir = parent;
   }
@@ -420,7 +127,7 @@ function fsdBoundaries(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const fromTsconfig = options.aliases === void 0 && options.tsconfig !== false ? aliasesFromTsconfig({ cwd, tsconfig: options.tsconfig }) : {};
   const aliases = options.aliases ?? { "@/": root, ...fromTsconfig };
-  const anchor = (dir) => options.cwd === void 0 ? dir : resolve3(options.cwd, dir);
+  const anchor = (dir) => options.cwd === void 0 ? dir : resolve2(options.cwd, dir);
   const { sliceGroups, sharedPublicApi, testFiles, segments, platformSuffixes, routerDirs } = options;
   const policy = resolveFsdPolicy(readRecordedFsd(cwd), { sliceGroups, sharedPublicApi, testFiles, segments, platformSuffixes, routerDirs });
   const ruleOptions = {
@@ -428,7 +135,7 @@ function fsdBoundaries(options = {}) {
     aliases: Object.fromEntries(Object.entries(aliases).map(([prefix, dir]) => [prefix, anchor(dir)])),
     policy
   };
-  const rootGlob = posix2.normalize(root.split(sep3).join("/"));
+  const rootGlob = posix.normalize(root.split(sep2).join("/"));
   const atAppRoot = rootGlob === "." || rootGlob === "./";
   return [
     {

package/dist/generators/_chunks/chunk-2WSX5YNB.js

@@ -0,0 +1,274 @@
+import {
+  resolveProjectType
+} from "./chunk-TXAQ2GJC.js";
+import {
+  readBoundaryTags
+} from "./chunk-6ZTIUBB2.js";
+import {
+  readToolkitConfig
+} from "./chunk-EXYZLL7A.js";
+
+// ../template-engine/dist/frameworks/profiles.js
+var ALL_LAYERS = ["app", "pages", "features", "entities", "shared"];
+var NEXT = {
+  id: "next",
+  recognised: true,
+  // Next.js's own app/ (App Router) directory is the composition root; FSD's Next.js guide
+  // names the FSD app and pages layers _app and _pages, since Next.js reads src/app and
+  // src/pages as its routers.
+  layers: ["pages", "features", "entities", "shared"],
+  layerDirs: { app: "_app", pages: "_pages" },
+  buildOutputDirs: [".next", "out"],
+  platformSuffixes: [],
+  routerDirs: ["pages"]
+};
+var REACT_VITE = {
+  id: "react-vite",
+  recognised: true,
+  layers: ALL_LAYERS,
+  layerDirs: {},
+  buildOutputDirs: ["dist"],
+  platformSuffixes: [],
+  routerDirs: []
+};
+var EXPO_ROUTER = {
+  id: "expo",
+  recognised: true,
+  layers: ALL_LAYERS,
+  layerDirs: { app: "_app" },
+  buildOutputDirs: [".expo", "dist"],
+  platformSuffixes: ["ios", "android", "native", "web"],
+  routerDirs: []
+};
+var EXPO = { ...EXPO_ROUTER, layerDirs: {} };
+var GENERIC = {
+  id: "generic",
+  recognised: false,
+  layers: ALL_LAYERS,
+  layerDirs: {},
+  buildOutputDirs: ["dist", "build"],
+  platformSuffixes: [],
+  routerDirs: []
+};
+var PROFILES = { next: NEXT, "react-vite": REACT_VITE, expo: EXPO_ROUTER, generic: GENERIC };
+function profileById(id) {
+  return PROFILES[id];
+}
+function allFrameworkProfiles() {
+  return Object.values(PROFILES);
+}
+var NEXT_CONFIGS = ["next.config.js", "next.config.mjs", "next.config.ts", "next.config.cjs"];
+var VITE_CONFIGS = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"];
+var EXPO_CONFIGS = ["app.config.ts", "app.config.js", "app.config.mjs"];
+function hasExpoKey(input, file) {
+  const text = input.read(file);
+  if (typeof text !== "string")
+    return false;
+  try {
+    return typeof JSON.parse(text)["expo"] === "object";
+  } catch {
+    return false;
+  }
+}
+function dependsOn(input, manifest, name) {
+  const text = input.read(manifest);
+  if (typeof text !== "string")
+    return false;
+  try {
+    const parsed = JSON.parse(text);
+    return ["dependencies", "devDependencies", "peerDependencies"].some((field) => parsed[field]?.[name] !== void 0);
+  } catch {
+    return false;
+  }
+}
+function detectFramework(input) {
+  const prefix = input.projectRoot === "" || input.projectRoot === "." ? "" : `${input.projectRoot}/`;
+  const executors = input.executors ?? [];
+  if (NEXT_CONFIGS.some((file) => input.exists(`${prefix}${file}`)) || executors.some((executor) => executor.startsWith("@nx/next:"))) {
+    return NEXT;
+  }
+  const dependsAnywhere = (name) => dependsOn(input, `${prefix}package.json`, name) || dependsOn(input, "package.json", name);
+  const usesExpo = executors.some((executor) => executor.startsWith("@nx/expo:")) || hasExpoKey(input, `${prefix}app.json`) || EXPO_CONFIGS.some((file) => input.exists(`${prefix}${file}`)) || dependsOn(input, `${prefix}package.json`, "expo");
+  if (usesExpo)
+    return dependsAnywhere("expo-router") ? EXPO_ROUTER : EXPO;
+  const usesReact = dependsAnywhere("react");
+  const usesVite = VITE_CONFIGS.some((file) => input.exists(`${prefix}${file}`)) || executors.some((executor) => executor.startsWith("@nx/vite:"));
+  if (usesVite && usesReact)
+    return REACT_VITE;
+  return GENERIC;
+}
+
+// src/generators/shared/frontend-app.ts
+import { getProjects } from "@nx/devkit";
+
+// ../template-engine/dist/fsd/slice-rules.js
+function toCamelCase(kebabName) {
+  return kebabName.split("-").filter((part) => part.length > 0).map((part, index) => index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function resolveSlicePublicApiName(name, publicApiName) {
+  return publicApiName ?? toCamelCase(name);
+}
+var IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "interface",
+  "let",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield"
+]);
+function isUsableSliceApiName(candidate) {
+  return IDENTIFIER_PATTERN.test(candidate) && !RESERVED_WORDS.has(candidate);
+}
+var ESSENCE_SEGMENT_NAMES = [
+  "components",
+  "hooks",
+  "helpers",
+  "utils",
+  "types",
+  "constants",
+  "consts",
+  "interfaces",
+  "enums",
+  "modals",
+  "stores",
+  "services"
+];
+function isEssenceSegmentName(name) {
+  return ESSENCE_SEGMENT_NAMES.includes(name);
+}
+var SEGMENT_NAME_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+
+// src/generators/shared/frontend-app.ts
+var baseNameOf = (root) => root.split("/").pop() ?? root;
+function isEndToEnd(root) {
+  const dir = baseNameOf(root);
+  return dir === "e2e" || dir.endsWith("-e2e");
+}
+function isBackend(root, config, backendTag) {
+  return baseNameOf(root) === "api" || (config.tags ?? []).includes(backendTag);
+}
+function prefixOf(root) {
+  return root === "" || root === "." ? "" : `${root}/`;
+}
+function sourceRootOf(tree, config) {
+  const prefix = prefixOf(config.root);
+  const declared = config.sourceRoot?.replace(/\/$/, "");
+  const atRoot = declared !== void 0 && (declared === config.root || prefix === "" && (declared === "." || declared === ""));
+  if (declared && !atRoot) return declared;
+  if (atRoot && !tree.exists(`${prefix}src`)) return prefix === "" ? "." : config.root;
+  return `${prefix}src`;
+}
+function frameworkOf(tree, config) {
+  return detectFramework({
+    exists: (path) => tree.exists(path),
+    read: (path) => tree.read(path, "utf-8"),
+    projectRoot: config.root,
+    executors: Object.values(config.targets ?? {}).flatMap((target) => target.executor ? [target.executor] : [])
+  });
+}
+function resolveFrontendApp(tree, explicitProject) {
+  let projects;
+  try {
+    projects = getProjects(tree);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const pathMatch = /Cannot parse ([^:]+):/.exec(message);
+    return { kind: "invalid-project-json", detail: pathMatch ? pathMatch[1] : message };
+  }
+  const found = (project2, config2) => {
+    const profile = frameworkOf(tree, config2);
+    return { kind: "found", project: project2, root: config2.root, sourceRoot: sourceRootOf(tree, config2), framework: profile.id, profile };
+  };
+  if (explicitProject !== void 0) {
+    const config2 = projects.get(explicitProject);
+    if (config2) return found(explicitProject, config2);
+    const rootApp = inferredRootApp(tree, projects);
+    return rootApp?.kind === "found" && rootApp.project === explicitProject ? rootApp : { kind: "not-found", project: explicitProject };
+  }
+  const backendTag = readBoundaryTags(readToolkitConfig(tree)).backend;
+  const eligible = [...projects.entries()].filter(([, config2]) => !isEndToEnd(config2.root) && !isBackend(config2.root, config2, backendTag));
+  const declared = eligible.filter(([, config2]) => config2.projectType === "application");
+  const inferred = eligible.filter(([, config2]) => {
+    if (config2.projectType !== void 0) return false;
+    if (config2.root === "" || config2.root === ".") return frameworkOf(tree, config2).recognised;
+    return resolveProjectType(tree, config2.root, void 0) === "application";
+  });
+  const candidates = (declared.length > 0 ? declared : inferred).sort(([a], [b]) => a.localeCompare(b));
+  if (candidates.length === 0) {
+    const rootApp = inferredRootApp(tree, projects);
+    if (rootApp !== null) return rootApp;
+    const otherProjects = [...projects.keys()].filter((name) => !isEndToEnd(projects.get(name)?.root ?? "")).sort();
+    return { kind: "none", otherProjects };
+  }
+  if (candidates.length > 1) return { kind: "ambiguous", candidates: candidates.map(([name]) => name) };
+  const [project, config] = candidates[0];
+  return found(project, config);
+}
+function inferredRootApp(tree, projects) {
+  if ([...projects.values()].some((config2) => config2.root === "" || config2.root === ".")) return null;
+  const raw = tree.read("package.json", "utf-8");
+  if (raw === null) return null;
+  let name;
+  try {
+    name = JSON.parse(raw).name;
+  } catch {
+    return null;
+  }
+  if (typeof name !== "string" || name === "") return null;
+  const config = { name, root: "." };
+  const framework = frameworkOf(tree, config);
+  if (!framework.recognised) return null;
+  return { kind: "found", project: name, root: ".", sourceRoot: sourceRootOf(tree, config), framework: framework.id, profile: framework, inferredRoot: true };
+}
+
+export {
+  profileById,
+  allFrameworkProfiles,
+  resolveSlicePublicApiName,
+  isUsableSliceApiName,
+  isEssenceSegmentName,
+  SEGMENT_NAME_PATTERN,
+  sourceRootOf,
+  resolveFrontendApp
+};