@ws-test-realm/admin-kit 0.6.2-ng20 → 0.6.4-ng20

package/bin/ws-generate-module.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 // ws-generate-module — scaffold a federated admin module project under
-// projects/<name>/ in the current workspace. Updates angular.json and
-// tsconfig.json paths.
+// projects/<name>/ in the current workspace. Delegates the Angular-blessed
+// scaffolding to `ng generate library`, then overlays the federation files
+// + BOM-only peerDep shape + workspace registration + npm install. After
+// this runs, the dev can immediately `npm run wire`.
 //
 // Usage:
 //   ws-generate-module <name>
@@ -18,16 +20,11 @@ function main() {
   }
 
   const workspaceDir = process.cwd();
-  const templateModuleDir = path.join(__dirname, "..", "template-module");
 
   try {
-    const { projectDir } = generateModule({
-      workspaceDir,
-      name,
-      templateModuleDir,
-    });
+    const { projectDir } = generateModule({ workspaceDir, name });
     console.log(`Generated ${path.relative(workspaceDir, projectDir)}/`);
-    console.log(`Updated angular.json + tsconfig.json with the new project.`);
+    console.log(`Module ready — run \`npm run wire\` to build and deploy.`);
   } catch (e) {
     console.error(e.message);
     process.exit(1);

package/lib/bom-shape.js

@@ -0,0 +1,144 @@
+// Federation-shaped JSON artifacts that ws-generate-module stamps over
+// the output of `ng generate library`. Hardcoded here (rather than in
+// template-module/) because the @ws-test-realm/shared peer pin is derived
+// from admin-kit's own dependency, and the JSON shapes are small enough
+// that token substitution against a template file would just be ceremony.
+//
+// File-shaped overlay artifacts (federation.config.js, main.ts, etc.) live
+// in admin-kit/template-module/ and are copied with token substitution by
+// the generator — those are large enough that a real file is clearer than
+// an embedded string.
+
+const adminKitPkg = require("../package.json");
+
+// The single peer that workspace libs declare. Pulls from admin-kit's own
+// `dependencies` so bumping admin-kit's shared ref propagates automatically
+// to every freshly-generated module.
+const SHARED_VERSION_PIN =
+  (adminKitPkg.dependencies || {})["@ws-test-realm/shared"];
+
+// Module's package.json shape. Lib declares ONLY the BOM as a peer. All
+// @angular/*, @ngx-translate/core, rxjs, zone.js etc. flow transitively
+// from `@ws-test-realm/shared`. ng-packagr's `allowedNonPeerDependencies`
+// (in ng-package.json) permits the bare imports without per-package peer
+// entries. See the convention pinned at /Users/ph/projects/ws-admin/admin/PINNED.md.
+function bomOnlyPackageJson(name) {
+  return {
+    name,
+    version: "0.0.1",
+    module: `../../dist/${name}/fesm2022/${name}.mjs`,
+    sideEffects: true,
+    peerDependencies: {
+      "@ws-test-realm/shared": SHARED_VERSION_PIN,
+    },
+    dependencies: {
+      tslib: "^2.5.0",
+    },
+    wsmodules: {
+      target: "ext",
+    },
+  };
+}
+
+// Module's ng-package.json. The `allowedNonPeerDependencies` regex array
+// is the load-bearing companion to the BOM-only peer pattern: it tells
+// ng-packagr that imports from these packages are OK even though they
+// aren't in peerDependencies (because the BOM owns them).
+function federationNgPackageJson(name) {
+  return {
+    $schema: "../../node_modules/ng-packagr/ng-package.schema.json",
+    dest: `../../dist/${name}`,
+    assets: ["./assets"],
+    lib: {
+      entryFile: "src/public-api.ts",
+    },
+    allowedNonPeerDependencies: [
+      "@angular/.*",
+      "@ngx-translate/core",
+      "rxjs",
+      "ws-framework",
+      "shop-common",
+      "@ws-test-realm/ws-core",
+    ],
+  };
+}
+
+// Uppercase + underscore form for path/route constant names. user-management
+// → USER_MANAGEMENT.
+function constantBase(name) {
+  return name.toUpperCase().replace(/-/g, "_");
+}
+
+// Pascal-case form for the generated class name. user-management →
+// UserManagement.
+function classBase(name) {
+  return name
+    .split(/[-_]/g)
+    .map((p) => (p ? p.charAt(0).toUpperCase() + p.slice(1) : p))
+    .join("");
+}
+
+// Camel-case form for the federation remote name. user-management →
+// userManagement (then suffixed with "Module" downstream).
+function camelBase(name) {
+  return name
+    .split(/[-_]/g)
+    .map((p, i) => {
+      if (!p) return p;
+      return i === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1);
+    })
+    .join("");
+}
+
+// The NgModule file we stamp over what `ng g library` emits. Brings in
+// SubModuleRouting + adminSettings + the path/route constant convention.
+// Devs typically re-point `parent: adminSettings` to whatever main module
+// makes sense (crm/admin-settings/...) after generation.
+//
+// Adopts the ng20+ naming convention emitted by the schematic:
+//   - file:        src/lib/<name>-module.ts        (dash suffix, no dot)
+//   - module cls:  <Pascal>Module
+//   - component:   ./<name>                        (flat in lib/, no .component infix)
+//   - cmp cls:     <Pascal>                        (no Component suffix)
+function moduleSource(name) {
+  const className = classBase(name);
+  const constName = constantBase(name);
+  return `import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SubModuleRouting, adminSettings } from '@ws-test-realm/ws-core';
+
+import { ${className} } from './${name}';
+
+export const ${constName}_PATH = '${name}';
+export const ${constName}_ROUTE = '/' + ${constName}_PATH;
+
+@SubModuleRouting({
+\tparent: adminSettings,
+\tpath: ${constName}_PATH,
+\tlabel: '_${name}.${name}',
+\tsort: 99,
+\ticonPath: 'assets/svg/module.svg',
+})
+@NgModule({
+\tdeclarations: [${className}],
+\timports: [CommonModule],
+\texports: [${className}],
+})
+export class ${className}Module {}
+`;
+}
+
+function publicApiSource(name) {
+  return `export * from './lib/${name}-module';\n`;
+}
+
+module.exports = {
+  SHARED_VERSION_PIN,
+  bomOnlyPackageJson,
+  federationNgPackageJson,
+  moduleSource,
+  publicApiSource,
+  classBase,
+  camelBase,
+  constantBase,
+};

package/lib/drop-module.js

@@ -10,6 +10,7 @@ function dropModule({ workspaceDir, name }) {
   const projectDir = path.join(workspaceDir, "projects", name);
   const distDir = path.join(workspaceDir, "dist", name);
   const distRemoteDir = path.join(workspaceDir, "dist", "admin-remotes", name);
+  const distRemoteAltDir = path.join(workspaceDir, "dist", `${name}-remote`);
 
   const projectExisted = fs.existsSync(projectDir);
 
@@ -31,6 +32,35 @@ function dropModule({ workspaceDir, name }) {
     );
   }
 
+  // Inverse of registerInWorkspaces — drop the projects/<name> entry from
+  // package.json#workspaces if present. Subsequent `npm install` removes
+  // the node_modules/<name> symlink.
+  const pkgPath = path.join(workspaceDir, "package.json");
+  let workspacesChanged = false;
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    const entry = `projects/${name}`;
+    if (Array.isArray(pkg.workspaces)) {
+      const idx = pkg.workspaces.indexOf(entry);
+      if (idx >= 0) {
+        pkg.workspaces.splice(idx, 1);
+        workspacesChanged = true;
+      }
+    } else if (
+      pkg.workspaces &&
+      Array.isArray(pkg.workspaces.packages)
+    ) {
+      const idx = pkg.workspaces.packages.indexOf(entry);
+      if (idx >= 0) {
+        pkg.workspaces.packages.splice(idx, 1);
+        workspacesChanged = true;
+      }
+    }
+    if (workspacesChanged) {
+      fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, "\t") + "\n");
+    }
+  }
+
   const fed = rebuildFederationTsconfig(workspaceDir);
   const federationTsconfigUpdated = !(name in fed.paths);
 
@@ -44,6 +74,10 @@ function dropModule({ workspaceDir, name }) {
     fs.rmSync(distRemoteDir, { recursive: true, force: true });
     distRemoteCleaned = true;
   }
+  if (fs.existsSync(distRemoteAltDir)) {
+    fs.rmSync(distRemoteAltDir, { recursive: true, force: true });
+    distRemoteCleaned = true;
+  }
 
   // Hook point: when type publishing to the host lands, clean the host-side
   // typings for this module here. See TODO.md.
@@ -52,6 +86,7 @@ function dropModule({ workspaceDir, name }) {
   if (
     !projectExisted &&
     !angularChanged &&
+    !workspacesChanged &&
     !distCleaned &&
     !distRemoteCleaned
   ) {
@@ -61,6 +96,7 @@ function dropModule({ workspaceDir, name }) {
   return {
     projectExisted,
     angularChanged,
+    workspacesChanged,
     federationTsconfigUpdated,
     distCleaned,
     distRemoteCleaned,

package/lib/generate-module.js

@@ -1,81 +1,152 @@
 const fs = require("fs");
 const path = require("path");
-const { rebuildFederationTsconfig } = require("./wire-host");
+const { ngGenerateLibrary, npmInstall } = require("./ng-shell");
+const {
+  bomOnlyPackageJson,
+  federationNgPackageJson,
+  moduleSource,
+  publicApiSource,
+  camelBase,
+} = require("./bom-shape");
 
-function pascalCase(s) {
-  return s
-    .split(/[-_]/g)
-    .map((p) => (p ? p.charAt(0).toUpperCase() + p.slice(1) : p))
-    .join("");
-}
+const TEMPLATE_MODULE_DIR = path.join(__dirname, "..", "template-module");
 
-function camelCase(s) {
-  return s
-    .split(/[-_]/g)
-    .map((p, i) => {
-      if (!p) return p;
-      return i === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1);
-    })
-    .join("");
-}
+// Pipeline orchestrator. Generates a federated admin module project by:
+//
+//   1. shelling out to `ng generate library` for the Angular-blessed source
+//      scaffold (component, module file, ng-package.json, tsconfig.lib*,
+//      package.json, public-api.ts, plus angular.json entry and root
+//      tsconfig path);
+//   2. overwriting the schematic's package.json + ng-package.json with our
+//      BOM-only / allowedNonPeerDependencies shapes (see bom-shape.js);
+//   3. overwriting the schematic's module file with our @SubModuleRouting
+//      stamp + the <NAME>_PATH/_ROUTE constants convention;
+//   4. copying federation-overlay files from admin-kit/template-module/
+//      with token substitution (federation.config.js, src/main.ts,
+//      src/exposed-module.ts, src/index.html, src/polyfills.ts,
+//      tsconfig.app.json, assets/i18n/*);
+//   5. replacing the angular.json block (schematic wrote a library-type
+//      block with 2 targets; we need application-type with 3 targets:
+//      build-lib + build + esbuild);
+//   6. cleaning up the duplicate `paths` entry the schematic put into the
+//      root tsconfig.json (tsconfig.federation.json is our single source
+//      of truth for federation paths);
+//   7. registering the new project in root package.json#workspaces;
+//   8. running `npm install` — npm workspaces machinery materializes the
+//      `node_modules/<name>` symlink, and the workspace's postinstall hook
+//      (ws-sync-paths) rebuilds tsconfig.federation.json with the new path
+//      entry.
+//
+// End state: the dev can immediately run `npm run wire` and the new module
+// builds and deploys alongside the rest.
+function generateModule({ workspaceDir, name }) {
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    throw new Error(
+      `Invalid module name: ${name}. Use lowercase, hyphen-separated (e.g. db-login).`
+    );
+  }
+  if (!fs.existsSync(path.join(workspaceDir, "angular.json"))) {
+    throw new Error(`No angular.json in ${workspaceDir} (not a workspace).`);
+  }
+  const projectDir = path.join(workspaceDir, "projects", name);
+  if (fs.existsSync(projectDir)) {
+    throw new Error(`projects/${name}/ already exists.`);
+  }
 
-function buildTokens(name) {
-  return {
-    name,
-    className: pascalCase(name),
-    camelName: camelCase(name),
-    selector: `ws-${name}`,
-  };
+  // 1. Angular schematic: scaffolds projects/<name>/ + updates angular.json
+  //    + adds tsconfig.json paths entry. Adds tsconfig.lib(.prod).json,
+  //    tsconfig.spec.json, ng-package.json, package.json, README.md,
+  //    src/public-api.ts, src/lib/<name>-module.ts, src/lib/<name>.ts
+  //    (ng20+ naming: dash suffix, no .component infix, classes are plain
+  //    <Pascal> / <Pascal>Module).
+  ngGenerateLibrary({ workspaceDir, name });
+
+  // 2. Overwrite the schematic's package.json with the BOM-only shape.
+  writeJson(path.join(projectDir, "package.json"), bomOnlyPackageJson(name));
+
+  // 3. Overwrite the schematic's ng-package.json with our shape (different
+  //    `dest`, plus `allowedNonPeerDependencies`).
+  writeJson(
+    path.join(projectDir, "ng-package.json"),
+    federationNgPackageJson(name)
+  );
+
+  // 4. Overwrite the schematic's module file with our @SubModuleRouting
+  //    stamp + the <NAME>_PATH/_ROUTE constants convention. ng20 emits
+  //    `<name>-module.ts` (dash suffix, no dot).
+  fs.writeFileSync(
+    path.join(projectDir, "src", "lib", `${name}-module.ts`),
+    moduleSource(name)
+  );
+
+  // 5. Replace public-api.ts: the schematic re-exports both module and
+  //    component; for federation we only need the module export. (Decorated
+  //    components requiring DCE protection get added by the dev later, per
+  //    the @ExpansionEntry public-api rule.)
+  fs.writeFileSync(
+    path.join(projectDir, "src", "public-api.ts"),
+    publicApiSource(name)
+  );
+
+  // 6. Copy federation overlay files from template-module/ with token
+  //    substitution. The schematic doesn't produce any of these.
+  copyOverlayWithSubstitution(projectDir, name);
+
+  // 7. Replace the angular.json block. ng schematic wrote a library-type
+  //    block with build (ng-packagr) + test (karma) targets. We need
+  //    application-type with build-lib + build + esbuild.
+  replaceAngularJsonBlock(workspaceDir, name);
+
+  // 8. Clean the duplicate tsconfig.json paths entry the schematic added.
+  cleanTsconfigPathsEntry(workspaceDir, name);
+
+  // 9. Add to package.json#workspaces (npm-workspaces machinery uses this
+  //    to materialize the node_modules/<name> symlink).
+  registerInWorkspaces(workspaceDir, name);
+
+  // 10. npm install — symlinks materialize; postinstall (ws-sync-paths)
+  //     rebuilds tsconfig.federation.json with the new path entry.
+  npmInstall({ workspaceDir });
+
+  return { projectDir };
 }
 
-function substitute(s, tokens) {
-  return s
-    .replace(/__className__/g, tokens.className)
-    .replace(/__camelName__/g, tokens.camelName)
-    .replace(/__selector__/g, tokens.selector)
-    .replace(/__name__/g, tokens.name);
+function writeJson(filePath, obj) {
+  fs.writeFileSync(filePath, JSON.stringify(obj, null, "\t") + "\n");
 }
 
-function copyAndSubstitute(src, dest, tokens) {
-  fs.mkdirSync(dest, { recursive: true });
-  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    const newName = substitute(entry.name, tokens);
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, newName);
-    if (entry.isDirectory()) {
-      copyAndSubstitute(srcPath, destPath, tokens);
+// Recursively copy admin-kit/template-module/ into projects/<name>/,
+// substituting __name__ → <name> and __camelName__ → camelCase(<name>)
+// in both file contents AND filenames. Existing destination files are
+// overwritten — the previous schematic+overwrites have already populated
+// the directory and these copies don't conflict.
+function copyOverlayWithSubstitution(destDir, name) {
+  const camelName = camelBase(name);
+  const substitute = (s) =>
+    s.replace(/__camelName__/g, camelName).replace(/__name__/g, name);
+
+  function copyRecursive(src, dst) {
+    if (!fs.existsSync(src)) return;
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      fs.mkdirSync(dst, { recursive: true });
+      for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        copyRecursive(
+          path.join(src, entry.name),
+          path.join(dst, substitute(entry.name))
+        );
+      }
     } else {
-      const content = fs.readFileSync(srcPath, "utf8");
-      fs.writeFileSync(destPath, substitute(content, tokens));
+      fs.writeFileSync(dst, substitute(fs.readFileSync(src, "utf8")));
     }
   }
+  copyRecursive(TEMPLATE_MODULE_DIR, destDir);
 }
 
-// Register the project as a dual-build admin module in angular.json. Three
-// architect targets per project:
-//
-//   build-lib  → @angular-devkit/build-angular:ng-packagr. Produces the typed
-//                library at dist/<name>/ (with .d.ts + package.json + fesm2015).
-//                Consumed at COMPILE time by sibling projects in this workspace
-//                (and by the host) via tsconfig.federation.json `paths`.
-//
-//   build      → @angular-architects/native-federation:build. Wraps the
-//                `esbuild` target and emits remoteEntry.json + chunks at
-//                dist/<name>-remote/. Deployed to the fiddle; consumed at
-//                RUNTIME via the host's initFederation + import map.
-//
-//   esbuild    → @angular-devkit/build-angular:application. The bundle
-//                target the native-federation builder wraps (NF 17.1+ requires
-//                the application builder). Output dir dist/<name>-remote/ keeps
-//                it separate from the lib output; outputPath.browser is
-//                flattened to "" so federation chunks land at the dist root
-//                rather than dist/<name>-remote/browser/, keeping the deploy
-//                layout consistent with the pre-ng17 line.
-//
-// Every module is dual-build by default — any project could grow a type-level
-// consumer (pluggable slots, base components), and the dual invariant
-// guarantees the typed surface is always there.
-function registerInAngularJson(workspaceDir, name) {
+// Replace projects.<name> in angular.json with the application-type +
+// 3-target dual-build shape. We overwrite (not merge) because the schematic
+// emits a library-type block that we'd need to fully restructure anyway.
+function replaceAngularJsonBlock(workspaceDir, name) {
   const angularJsonPath = path.join(workspaceDir, "angular.json");
   const angular = JSON.parse(fs.readFileSync(angularJsonPath, "utf8"));
   angular.projects = angular.projects || {};
@@ -84,7 +155,7 @@ function registerInAngularJson(workspaceDir, name) {
     schematics: {},
     root: `projects/${name}`,
     sourceRoot: `projects/${name}/src`,
-    prefix: "ws",
+    prefix: "lib",
     architect: {
       "build-lib": {
         builder: "@angular-devkit/build-angular:ng-packagr",
@@ -93,7 +164,9 @@ function registerInAngularJson(workspaceDir, name) {
           production: {
             tsConfig: `projects/${name}/tsconfig.lib.prod.json`,
           },
-          development: { tsConfig: `projects/${name}/tsconfig.lib.json` },
+          development: {
+            tsConfig: `projects/${name}/tsconfig.lib.json`,
+          },
         },
         defaultConfiguration: "production",
       },
@@ -114,20 +187,7 @@ function registerInAngularJson(workspaceDir, name) {
           browser: `projects/${name}/src/main.ts`,
           polyfills: [],
           tsConfig: `projects/${name}/tsconfig.app.json`,
-          // Cross-workspace federation siblings reach this workspace via
-          // admin-kit-managed symlinks at node_modules/<name>; esbuild needs
-          // preserveSymlinks=true to resolve peer imports out of those .d.ts/
-          // .mjs files against THIS workspace's node_modules (where the
-          // peers are installed) rather than walking up from the symlink
-          // target in the fiddle.
           preserveSymlinks: true,
-          // Copy the project's `assets/` into the federation output so the
-          // fiddle's `/api/v1/admin-federation/asset/<id>/...` endpoint can
-          // serve them. The endpoint resolves to
-          // `META-INF/federation/<id>/remote/<subpath>` (jar target) or
-          // `<ext-dir>/remote/<subpath>` (ext target); packIntoJar /
-          // deployExt mirror whatever's in `dist/<id>-remote/` into that
-          // `remote/` directory, so anything here becomes addressable.
           assets: [
             {
               glob: "**/*",
@@ -152,26 +212,51 @@ function registerInAngularJson(workspaceDir, name) {
   );
 }
 
-function generateModule({ workspaceDir, name, templateModuleDir }) {
-  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
-    throw new Error(
-      `Invalid module name: ${name}. Use lowercase, hyphen-separated (e.g. db-login).`
-    );
+// ng g library appends `<name>: ["./dist/<name>"]` to the root tsconfig's
+// compilerOptions.paths. tsconfig.federation.json is our SSOT for federation
+// paths so this duplicate would just be confusing. Strip it.
+function cleanTsconfigPathsEntry(workspaceDir, name) {
+  const tsconfigPath = path.join(workspaceDir, "tsconfig.json");
+  if (!fs.existsSync(tsconfigPath)) return;
+  const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, "utf8"));
+  if (
+    !tsconfig.compilerOptions ||
+    !tsconfig.compilerOptions.paths ||
+    !(name in tsconfig.compilerOptions.paths)
+  ) {
+    return;
   }
-  if (!fs.existsSync(path.join(workspaceDir, "angular.json"))) {
-    throw new Error(`No angular.json in ${workspaceDir} (not a workspace).`);
+  delete tsconfig.compilerOptions.paths[name];
+  if (Object.keys(tsconfig.compilerOptions.paths).length === 0) {
+    delete tsconfig.compilerOptions.paths;
   }
-  const projectDir = path.join(workspaceDir, "projects", name);
-  if (fs.existsSync(projectDir)) {
-    throw new Error(`projects/${name}/ already exists.`);
-  }
-
-  const tokens = buildTokens(name);
-  copyAndSubstitute(templateModuleDir, projectDir, tokens);
-  registerInAngularJson(workspaceDir, name);
-  rebuildFederationTsconfig(workspaceDir);
+  fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, "\t") + "\n");
+}
 
-  return { projectDir, tokens };
+// Add "projects/<name>" to package.json#workspaces if missing. This is the
+// gap-closer: without this entry, npm-workspaces machinery won't symlink
+// node_modules/<name> → projects/<name>, and native-federation's
+// findDepPackageJson lookup fails at build time.
+function registerInWorkspaces(workspaceDir, name) {
+  const pkgPath = path.join(workspaceDir, "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  const entry = `projects/${name}`;
+  pkg.workspaces = pkg.workspaces || [];
+  if (!Array.isArray(pkg.workspaces)) {
+    // npm also supports { packages: [...] } shape. Handle both.
+    if (pkg.workspaces.packages) {
+      if (!pkg.workspaces.packages.includes(entry)) {
+        pkg.workspaces.packages.push(entry);
+      }
+    } else {
+      throw new Error(
+        "Unsupported package.json#workspaces shape; expected array or { packages: [...] }"
+      );
+    }
+  } else if (!pkg.workspaces.includes(entry)) {
+    pkg.workspaces.push(entry);
+  }
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, "\t") + "\n");
 }
 
-module.exports = { generateModule, buildTokens };
+module.exports = { generateModule };

package/lib/ng-shell.js

@@ -0,0 +1,31 @@
+const { execSync } = require("child_process");
+
+// Run `ng generate library <name>` in the workspace via npx, so we don't
+// require @angular/cli to be globally installed. Every admin workspace
+// already has it as a transitive dep through @angular/build. Defaults:
+//   --prefix=lib              (matches existing crm/shop-settings/...)
+//   --standalone=false        (NgModule mode; required by our PINNED rule)
+//   --skip-install            (admin-kit drives the install at end of pipeline)
+//
+// Inherits stdio so the dev sees ng's output and any prompts. ng's exit code
+// is checked: on failure, throws so the generator pipeline aborts cleanly.
+function ngGenerateLibrary({ workspaceDir, name, prefix = "lib" }) {
+  const cmd = [
+    "npx",
+    "--no-install",
+    "ng",
+    "generate",
+    "library",
+    name,
+    `--prefix=${prefix}`,
+    "--standalone=false",
+    "--skip-install",
+  ].join(" ");
+  execSync(cmd, { cwd: workspaceDir, stdio: "inherit" });
+}
+
+function npmInstall({ workspaceDir }) {
+  execSync("npm install", { cwd: workspaceDir, stdio: "inherit" });
+}
+
+module.exports = { ngGenerateLibrary, npmInstall };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ws-test-realm/admin-kit",
-  "version": "0.6.2-ng20",
+  "version": "0.6.4-ng20",
   "description": "Workflow CLI + scaffolding for Wiresphere admin-modules workspaces (Angular 20 + native-federation line). Ships `ws-init-workspace`, `ws-modules` (build+deploy driver), `ws-generate-module`/`ws-drop-module`, `ws-wire-host`, `ws-wire-pom`, `ws-sync-paths`, and `ws-purge`. Depends on @ws-test-realm/devkit (toolchain BOM) + @ws-test-realm/shared (runtime BOM + native-federation share map).",
   "license": "Artistic-2.0",
   "publishConfig": {

package/template-module/ng-package.json

@@ -1,8 +0,0 @@
-{
-	"$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
-	"dest": "../../dist/__name__",
-	"assets": ["./assets"],
-	"lib": {
-		"entryFile": "src/public-api.ts"
-	}
-}

package/template-module/package.json

@@ -1,19 +0,0 @@
-{
-	"name": "__name__",
-	"version": "0.0.1",
-	"module": "../../dist/__name__/fesm2022/__name__.mjs",
-	"sideEffects": true,
-	"peerDependencies": {
-		"@angular/common": "^20.0.0",
-		"@angular/core": "^20.0.0",
-		"@angular/forms": "^20.0.0",
-		"@angular/router": "^20.0.0",
-		"rxjs": "~7.8.0"
-	},
-	"dependencies": {
-		"tslib": "^2.5.0"
-	},
-	"wsmodules": {
-		"target": "jar"
-	}
-}

package/template-module/src/lib/__name__.module.ts

@@ -1,11 +0,0 @@
-import { NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
-
-import { __className__Component } from './components/__name__/__name__.component';
-
-@NgModule({
-	declarations: [__className__Component],
-	imports: [CommonModule],
-	exports: [__className__Component],
-})
-export class __className__Module {}

package/template-module/src/lib/components/__name__/__name__.component.html

@@ -1 +0,0 @@
-<p>__name__ works!</p>

package/template-module/src/lib/components/__name__/__name__.component.ts

@@ -1,8 +0,0 @@
-import { Component } from '@angular/core';
-
-@Component({
-	selector: '__selector__',
-	templateUrl: './__name__.component.html',
-	styleUrls: ['./__name__.component.scss'],
-})
-export class __className__Component {}

package/template-module/src/public-api.ts

@@ -1,6 +0,0 @@
-/*
- * Public API Surface of __name__
- */
-
-export * from './lib/__name__.module';
-export * from './lib/components/__name__/__name__.component';

package/template-module/tsconfig.lib.json

@@ -1,14 +0,0 @@
-{
-	"extends": "../../tsconfig.json",
-	"compilerOptions": {
-		"outDir": "../../out-tsc/lib",
-		"target": "es2022",
-		"useDefineForClassFields": false,
-		"declaration": true,
-		"declarationMap": true,
-		"inlineSources": true,
-		"types": [],
-		"lib": ["dom", "es2022"]
-	},
-	"exclude": ["src/test.ts", "**/*.spec.ts"]
-}

package/template-module/tsconfig.lib.prod.json

@@ -1,9 +0,0 @@
-{
-	"extends": "./tsconfig.lib.json",
-	"compilerOptions": {
-		"declarationMap": false
-	},
-	"angularCompilerOptions": {
-		"compilationMode": "partial"
-	}
-}