@elia97/officina 0.1.0 → 0.3.0

package/dist/gen/identifier.mjs

@@ -0,0 +1,52 @@
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const RESERVED = 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',
+]);
+export function isValidIdentifier(camel) {
+    return IDENTIFIER.test(camel) && !RESERVED.has(camel);
+}

package/dist/gen/inject-config.d.mts

@@ -0,0 +1,12 @@
+export declare function assertInjectable({ root, camel, kebab }: {
+    camel: any;
+    kebab: any;
+    root: any;
+}): void;
+export declare function injectCollection({ root, camel, kebab, document, sections }: {
+    camel: any;
+    document: any;
+    kebab: any;
+    root: any;
+    sections?: boolean | undefined;
+}): void;

package/dist/gen/inject-config.mjs

@@ -0,0 +1,73 @@
+import { Project, SyntaxKind } from 'ts-morph';
+import { isNameTaken } from './ts-morph-utils.mjs';
+const CONFIG_PATH = 'src/content.config.ts';
+function loadConfig(root) {
+    const project = new Project();
+    return project.addSourceFileAtPath(`${root}/${CONFIG_PATH}`);
+}
+function locateContract(cfg, { camel, kebab }) {
+    const statement = cfg.getVariableStatement((s) => s.getDeclarations().some((d) => d.getName() === 'collections'));
+    if (!statement) {
+        throw new Error(`gen:collection injection failed: no \`collections\` variable in ${CONFIG_PATH}. ` +
+            `The contract expects \`export const collections = { … }\` — if it was renamed, ` +
+            `restore it or update scripts/gen/inject-config.mjs (see docs/guides/content-collections.md).`);
+    }
+    if (!statement.hasExportKeyword()) {
+        throw new Error(`gen:collection injection failed: \`collections\` in ${CONFIG_PATH} is not exported. ` +
+            `Astro silently ignores a non-exported collections object — restore \`export const collections\`.`);
+    }
+    const object = cfg
+        .getVariableDeclarationOrThrow('collections')
+        .getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+    if (!object) {
+        throw new Error(`gen:collection injection failed: \`collections\` in ${CONFIG_PATH} is not initialized ` +
+            `with an object literal, so there is no place to register the new collection.`);
+    }
+    if (object.getProperty(camel) || object.getProperty(`'${kebab}'`)) {
+        throw new Error(`gen:collection injection failed: a collection named "${kebab}" is already registered ` +
+            `in ${CONFIG_PATH}. Pick another name, or remove the existing entry first.`);
+    }
+    if (isNameTaken(cfg, camel)) {
+        throw new Error(`gen:collection injection failed: the identifier \`${camel}\` is already taken in ` +
+            `${CONFIG_PATH} (import or variable) — the injected const would shadow it. Pick another name.`);
+    }
+    return { statement, object };
+}
+export function assertInjectable({ root, camel, kebab }) {
+    locateContract(loadConfig(root), { camel, kebab });
+}
+export function injectCollection({ root, camel, kebab, document, sections = false }) {
+    const cfg = loadConfig(root);
+    const { statement, object } = locateContract(cfg, { camel, kebab });
+    const schema = sections ? `${camel}CollectionSchema` : `${camel}Schema`;
+    if (!cfg.getImportDeclaration((d) => d.getModuleSpecifierValue() === `@/lib/schemas/${kebab}`)) {
+        cfg.addImportDeclaration({
+            moduleSpecifier: `@/lib/schemas/${kebab}`,
+            namedImports: [schema],
+        });
+    }
+    const pattern = document ? '**/*.md' : '**/*.{yaml,yml}';
+    const loaderId = document
+        ? `    // Default generateId on purpose: this id becomes the route slug, so it\n` +
+            `    // should slugify segments and honor a frontmatter \`slug\`.\n`
+        : `    // Raw relative path minus extension, like the homepage collection: the\n` +
+            `    // default generateId slugifies segments (en-US → en-us), honors a top-level\n` +
+            `    // \`slug\` key before zod strips it, and drops a trailing /index — all three\n` +
+            `    // break reading entries back by locale folder.\n` +
+            `    generateId: ({ entry }) => entry.replace(/\\.(yaml|yml)$/, ''),\n`;
+    cfg.insertStatements(statement.getChildIndex(), `const ${camel} = defineCollection({\n` +
+        `  loader: glob({\n` +
+        `    pattern: '${pattern}',\n` +
+        `    base: './src/content/${kebab}',\n` +
+        loaderId +
+        `  }),\n` +
+        `  schema: ${schema},\n` +
+        `})\n`);
+    if (kebab.includes('-')) {
+        object.addPropertyAssignment({ name: `'${kebab}'`, initializer: camel });
+    }
+    else {
+        object.addShorthandPropertyAssignment({ name: camel });
+    }
+    cfg.saveSync();
+}

package/dist/gen/inject-section.d.mts

@@ -0,0 +1,16 @@
+export declare function assertSectionInjectable({ root, collection, camel, kebab, pascal, image }: {
+    camel: any;
+    collection: any;
+    image?: boolean | undefined;
+    kebab: any;
+    pascal: any;
+    root: any;
+}): void;
+export declare function injectSection({ root, collection, camel, kebab, pascal, image }: {
+    camel: any;
+    collection: any;
+    image?: boolean | undefined;
+    kebab: any;
+    pascal: any;
+    root: any;
+}): void;

package/dist/gen/inject-section.mjs

@@ -0,0 +1,140 @@
+// L'inserimento va SOPRA ogni marcatore: sotto, l'organizeImports di Biome adotta il marcatore come
+// trivia iniziale del nuovo import e lo sposta nel blocco ordinato. (.astro non è leggibile da ts-morph.)
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { Node, Project, SyntaxKind } from 'ts-morph';
+import { findSectionedPages, sectionFiles, sectionTargets } from './section-targets.mjs';
+import { isNameTaken } from './ts-morph-utils.mjs';
+const GUIDE = 'docs/guides/content-collections.md';
+function fail(where, problem) {
+    throw new Error(`gen:section injection failed in ${where}: ${problem} (contract: ${GUIDE})`);
+}
+function addSource(project, root, path, missing) {
+    if (!existsSync(`${root}/${path}`))
+        fail(path, missing);
+    return project.addSourceFileAtPath(`${root}/${path}`);
+}
+function locateUnionArray(project, root, targets, collection) {
+    const created = 'a sectioned collection is created by `pnpm gen:collection`';
+    const barrel = addSource(project, root, targets.barrel, `the "${collection}" collection has no schema barrel — ${created}`);
+    const fn = barrel.getFunction(targets.schemaFunction);
+    if (!fn) {
+        fail(targets.barrel, `no \`${targets.schemaFunction}\` function — was it renamed?`);
+    }
+    const call = fn
+        .getDescendantsOfKind(SyntaxKind.CallExpression)
+        .find((c) => c.getExpression().getText() === 'z.discriminatedUnion');
+    if (!call) {
+        fail(targets.barrel, `no \`z.discriminatedUnion(…)\` call inside ${targets.schemaFunction}`);
+    }
+    const union = call.getArguments()[1]?.asKind(SyntaxKind.ArrayLiteralExpression);
+    if (!union) {
+        fail(targets.barrel, 'the second argument of z.discriminatedUnion is not an array literal');
+    }
+    return { barrel, fn, union };
+}
+const inUnion = (union, camel) => union.getElements().some((element) => element.getText().startsWith(`${camel}SectionSchema(`));
+function locateReturnObject(project, root, targets, collection) {
+    const created = 'a sectioned collection is created by `pnpm gen:collection`';
+    const layer = addSource(project, root, targets.dataLayer, `the "${collection}" collection has no data layer — ${created}`);
+    const fn = layer.getFunction(targets.dataFunction);
+    if (!fn) {
+        fail(targets.dataLayer, `no \`${targets.dataFunction}\` function — was it renamed?`);
+    }
+    const ret = fn
+        .getBody()
+        ?.getStatements()
+        .findLast((s) => s.isKind(SyntaxKind.ReturnStatement));
+    const obj = ret?.getExpression()?.asKind(SyntaxKind.ObjectLiteralExpression);
+    if (!obj) {
+        fail(targets.dataLayer, `${targets.dataFunction} has no top-level \`return { … }\` object literal to register the pick() in`);
+    }
+    return obj;
+}
+function readSectionedPage(root, targets) {
+    const pages = findSectionedPages(root, targets.sectionsMarker);
+    if (pages.length === 0) {
+        fail('src/pages/', `no page carries the \`${targets.sectionsMarker}\` marker — the component has no anchor`);
+    }
+    if (pages.length > 1) {
+        fail('src/pages/', `${pages.join(' and ')} all carry the \`${targets.sectionsMarker}\` marker — keep it on one page`);
+    }
+    const [page] = pages;
+    const src = readFileSync(`${root}/${page}`, 'utf8');
+    if (!src.includes(targets.importsMarker)) {
+        fail(page, `the \`${targets.importsMarker}\` marker is missing — the import has no anchor`);
+    }
+    return { page, src };
+}
+function assertContextForwardable(fn, targets) {
+    const [first] = fn.getParameters();
+    if (first && !Node.isIdentifier(first.getNameNode())) {
+        fail(targets.barrel, `${targets.schemaFunction} destructures its parameter — name it \`context: SchemaContext\`, so an image section can receive it`);
+    }
+}
+export function assertSectionInjectable({ root, collection, camel, kebab, pascal, image = false }) {
+    const targets = sectionTargets(collection);
+    const project = new Project();
+    const { barrel, fn, union } = locateUnionArray(project, root, targets, collection.kebab);
+    if (inUnion(union, camel)) {
+        fail(targets.barrel, `section "${camel}" is already in the union — pick another name`);
+    }
+    if (image)
+        assertContextForwardable(fn, targets);
+    if (isNameTaken(barrel, `${camel}SectionSchema`)) {
+        fail(targets.barrel, `the identifier \`${camel}SectionSchema\` is already taken — the injected import would collide. Pick another name`);
+    }
+    const obj = locateReturnObject(project, root, targets, collection.kebab);
+    if (obj.getProperty(camel)) {
+        fail(targets.dataLayer, `section "${camel}" is already picked in ${targets.dataFunction}`);
+    }
+    const { page, src } = readSectionedPage(root, targets);
+    const frontmatter = src.split('---')[1] ?? '';
+    if (new RegExp(`\\b${pascal}\\b`).test(frontmatter)) {
+        fail(page, `the identifier \`${pascal}\` is already used in the frontmatter — the component import would collide. Pick another name`);
+    }
+    for (const target of sectionFiles(targets, kebab)) {
+        if (existsSync(`${root}/${target}`)) {
+            fail(target, 'the file already exists — remove it first or pick another name');
+        }
+    }
+}
+function contextArgument(barrel, fn) {
+    const [first] = fn.getParameters();
+    if (first)
+        return first.getName();
+    fn.addParameter({ name: 'context', type: 'SchemaContext' });
+    if (!isNameTaken(barrel, 'SchemaContext')) {
+        barrel.addImportDeclaration({ moduleSpecifier: 'astro:content', namedImports: ['SchemaContext'], isTypeOnly: true });
+    }
+    return 'context';
+}
+export function injectSection({ root, collection, camel, kebab, pascal, image = false }) {
+    const targets = sectionTargets(collection);
+    const project = new Project();
+    const { barrel, fn, union } = locateUnionArray(project, root, targets, collection.kebab);
+    if (!barrel.getImportDeclaration((d) => d.getModuleSpecifierValue() === `./${kebab}`)) {
+        barrel.addImportDeclaration({
+            moduleSpecifier: `./${kebab}`,
+            namedImports: [`${camel}SectionSchema`],
+        });
+    }
+    if (!inUnion(union, camel)) {
+        union.addElement(`${camel}SectionSchema(${image ? contextArgument(barrel, fn) : ''})`);
+    }
+    const obj = locateReturnObject(project, root, targets, collection.kebab);
+    if (!obj.getProperty(camel)) {
+        obj.addPropertyAssignment({ name: camel, initializer: `pick('${camel}')` });
+    }
+    project.saveSync();
+    const { page, src: original } = readSectionedPage(root, targets);
+    let src = original;
+    const imp = `import ${pascal} from '@/components/${collection.kebab}/${kebab}.astro'`;
+    if (!src.includes(imp)) {
+        src = src.replace(targets.importsMarker, `${imp}\n${targets.importsMarker}`);
+    }
+    const use = `<${pascal} {...content.${camel}} />`;
+    if (!src.includes(use)) {
+        src = src.replace(targets.sectionsMarker, `${use}\n  ${targets.sectionsMarker}`);
+    }
+    writeFileSync(`${root}/${page}`, src);
+}

package/dist/gen/inject-strings.d.mts

@@ -0,0 +1,8 @@
+export declare function assertStringsInjectable({ root, keys }: {
+    keys: any;
+    root: any;
+}): void;
+export declare function injectStrings({ root, entries }: {
+    entries: any;
+    root: any;
+}): void;

package/dist/gen/inject-strings.mjs

@@ -0,0 +1,56 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { Project, SyntaxKind } from 'ts-morph';
+const DICTIONARIES = 'src/i18n/strings';
+const GUIDE = 'docs/guides/content-collections.md';
+function fail(where, problem) {
+    throw new Error(`gen:page injection failed in ${where}: ${problem} (contract: ${GUIDE})`);
+}
+function locateObject(file, path, locale) {
+    const declaration = file.getVariableDeclaration(locale);
+    if (!declaration) {
+        fail(path, `no \`${locale}\` constant — the dictionary must export \`const ${locale} = { … } as const\``);
+    }
+    if (!declaration.isExported()) {
+        fail(path, `\`${locale}\` is not exported, so src/i18n/ui.ts cannot register it`);
+    }
+    const object = declaration
+        .getInitializerIfKind(SyntaxKind.AsExpression)
+        ?.getExpression()
+        .asKind(SyntaxKind.ObjectLiteralExpression);
+    if (!object) {
+        fail(path, `\`${locale}\` is not an object literal with \`as const\`, so there is no place for the new keys`);
+    }
+    return object;
+}
+function loadDictionaries(root) {
+    const names = readdirSync(join(root, DICTIONARIES))
+        .filter((name) => name.endsWith('.ts'))
+        .sort();
+    if (names.length === 0)
+        fail(DICTIONARIES, 'no dictionary to register the page strings in');
+    const project = new Project();
+    const dictionaries = names.map((name) => {
+        const path = `${DICTIONARIES}/${name}`;
+        const file = project.addSourceFileAtPath(join(root, path));
+        return { path, object: locateObject(file, path, name.slice(0, -3)) };
+    });
+    return { project, dictionaries };
+}
+export function assertStringsInjectable({ root, keys }) {
+    for (const { path, object } of loadDictionaries(root).dictionaries) {
+        for (const key of keys) {
+            if (object.getProperty(`'${key}'`))
+                fail(path, `the key '${key}' is already there — pick another page path`);
+        }
+    }
+}
+export function injectStrings({ root, entries }) {
+    const { project, dictionaries } = loadDictionaries(root);
+    for (const { object } of dictionaries) {
+        for (const { key, value } of entries) {
+            object.addPropertyAssignment({ name: `'${key}'`, initializer: `'${value}'` });
+        }
+    }
+    project.saveSync();
+}

package/dist/gen/page.d.mts

@@ -0,0 +1,10 @@
+export declare function pathSegments(plop: any, value: any): any[];
+export declare function pageStrings({ pageKey, pageTitle, dynamic }: {
+    dynamic: any;
+    pageKey: any;
+    pageTitle: any;
+}): {
+    key: string;
+    value: any;
+}[];
+export default function pageGenerator(plop: any): void;

package/dist/gen/page.mjs

@@ -0,0 +1,68 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { assertStringsInjectable, injectStrings } from './inject-strings.mjs';
+import { postGenAction } from './post-gen.mjs';
+const ROLLBACK_HINT = 'gen:page also MODIFIED every dictionary in src/i18n/strings/. Review them with `git diff`, then discard ONLY ' +
+    'the injected page.* keys with `git checkout -p` on those paths, and delete the generated page. A re-run ' +
+    'without rollback fails pre-flight with "is already there".';
+export function pathSegments(plop, value) {
+    const dash = plop.getHelper('dashCase');
+    return String(value)
+        .split('/')
+        .map((segment) => dash(segment.trim()))
+        .filter(Boolean);
+}
+export function pageStrings({ pageKey, pageTitle, dynamic }) {
+    const title = { key: `page.${pageKey}.title`, value: pageTitle };
+    return dynamic ? [title] : [title, { key: `page.${pageKey}.description`, value: '<PAGE_DESCRIPTION>' }];
+}
+export default function pageGenerator(plop) {
+    const root = process.cwd();
+    const tpl = 'templates/page';
+    plop.setGenerator('page', {
+        description: 'New Astro page (static, or dynamic [slug] with getStaticPaths)',
+        prompts: [
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Page path (e.g. about-us, or nested like legal/privacy):',
+                // change-case toglie la punteggiatura, quindi '...' non è vuoto ma in dash-case diventa ''.
+                validate: (value) => pathSegments(plop, value).length > 0 || 'Page path must contain at least one letter or digit',
+            },
+            {
+                type: 'confirm',
+                name: 'dynamic',
+                message: 'Dynamic [slug] route with getStaticPaths?',
+                default: false,
+            },
+        ],
+        actions: (answers) => {
+            const segments = pathSegments(plop, answers.name);
+            const pagePath = segments.join('/');
+            answers.pagePath = pagePath;
+            answers.pageTitle = plop.getHelper('sentenceCase')(segments.at(-1));
+            answers.pageKey = plop.getHelper('camelCase')(pagePath);
+            const target = answers.dynamic ? `src/pages/${pagePath}/[slug].astro` : `src/pages/${pagePath}.astro`;
+            const strings = pageStrings(answers);
+            return [
+                () => {
+                    if (existsSync(join(root, target))) {
+                        throw new Error(`gen:page pre-flight failed: ${target} already exists — remove it or pick another path`);
+                    }
+                    assertStringsInjectable({ root, keys: strings.map(({ key }) => key) });
+                    return 'page path and dictionary contract checks passed';
+                },
+                {
+                    type: 'add',
+                    path: target,
+                    templateFile: answers.dynamic ? `${tpl}/dynamic.astro.hbs` : `${tpl}/static.astro.hbs`,
+                },
+                () => {
+                    injectStrings({ root, entries: strings });
+                    return `injected ${strings.map(({ key }) => key).join(', ')}`;
+                },
+                postGenAction(root, ROLLBACK_HINT),
+            ];
+        },
+    });
+}

package/dist/gen/plopfile.d.mts

@@ -0,0 +1,2 @@
+export declare const PROJECT_GENERATORS = "officina.generators.mjs";
+export default function (plop: any): Promise<void>;

package/dist/gen/plopfile.mjs

@@ -0,0 +1,30 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+import { pathToFileURL } from 'node:url';
+import collectionGenerator from './collection.mjs';
+import componentGenerator from './component.mjs';
+import pageGenerator from './page.mjs';
+import sectionGenerator from './section.mjs';
+// I generatori propri di un progetto stanno qui, nella sua radice, e si aggiungono a quelli del
+// pacchetto: stessa firma di un plopfile, `export default function (plop)`.
+export const PROJECT_GENERATORS = 'officina.generators.mjs';
+export default async function (plop) {
+    sectionGenerator(plop);
+    pageGenerator(plop);
+    componentGenerator(plop);
+    collectionGenerator(plop);
+    const extension = join(process.cwd(), PROJECT_GENERATORS);
+    if (!existsSync(extension))
+        return;
+    const { default: projectGenerators } = await import(__rewriteRelativeImportExtension(pathToFileURL(extension).href));
+    await projectGenerators(plop);
+}

package/dist/gen/post-gen.d.mts

@@ -0,0 +1 @@
+export declare function postGenAction(root: any, recoveryHint: any): () => string;

package/dist/gen/post-gen.mjs

@@ -0,0 +1,16 @@
+// `pnpm run check` è un `biome check --write .` su tutto il repo, quindi riformatta anche file sporchi
+// che non c'entrano: i suggerimenti di recupero non devono mai ricorrere a un `git checkout` di file intero.
+import { execSync } from 'node:child_process';
+export function postGenAction(root, recoveryHint) {
+    return () => {
+        try {
+            execSync('pnpm exec astro sync', { cwd: root, stdio: 'inherit' });
+            execSync('pnpm run check', { cwd: root, stdio: 'inherit' });
+        }
+        catch (error) {
+            throw new Error(`Post-generation checks failed. ${recoveryHint ??
+                'The generated files were left on disk — inspect, then fix or delete them before re-running (a re-run against leftovers fails with "File already exists").'}`, { cause: error });
+        }
+        return 'astro sync + biome check passed';
+    };
+}

package/dist/gen/run.d.ts

@@ -0,0 +1,2 @@
+export declare function plopCommand(args: string[], cwd: string): string[];
+export declare function main(args?: string[]): number;

package/dist/gen/run.js

@@ -0,0 +1,17 @@
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+// plop risolve i template dalla cartella del plopfile e scrive in `--dest`: il plopfile sta nel
+// pacchetto, la destinazione è il progetto da cui si lancia il comando.
+export function plopCommand(args, cwd) {
+    const require = createRequire(import.meta.url);
+    const plopBin = join(dirname(require.resolve('plop/package.json')), 'bin', 'plop.js');
+    const plopfile = fileURLToPath(new URL('./plopfile.mjs', import.meta.url));
+    return [plopBin, '--plopfile', plopfile, '--dest', cwd, ...args];
+}
+export function main(args = []) {
+    const result = spawnSync(process.execPath, plopCommand(args, process.cwd()), { stdio: 'inherit' });
+    return result.status ?? 1;
+}

package/dist/gen/section-targets.d.mts

@@ -0,0 +1,23 @@
+export declare function casings(plop: any, value: any): {
+    camel: any;
+    kebab: any;
+    pascal: any;
+};
+export declare function sectionTargets({ camel, kebab, pascal }: {
+    camel: any;
+    kebab: any;
+    pascal: any;
+}): {
+    barrel: string;
+    schemaFunction: string;
+    dataLayer: string;
+    dataFunction: string;
+    schemaDir: string;
+    contentDir: string;
+    componentDir: string;
+    importsMarker: string;
+    sectionsMarker: string;
+};
+export declare const sectionFiles: (targets: any, kebab: any) => string[];
+export declare function findSectionedPages(root: any, marker: any): string[];
+export declare function validateSectionName(plop: any): (value: any) => string | true;

package/dist/gen/section-targets.mjs

@@ -0,0 +1,46 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { isValidIdentifier } from './identifier.mjs';
+export function casings(plop, value) {
+    return {
+        camel: plop.getHelper('camelCase')(value),
+        kebab: plop.getHelper('dashCase')(value),
+        pascal: plop.getHelper('pascalCase')(value),
+    };
+}
+export function sectionTargets({ camel, kebab, pascal }) {
+    return {
+        barrel: `src/lib/schemas/${kebab}/index.ts`,
+        schemaFunction: `${camel}CollectionSchema`,
+        dataLayer: `src/lib/${kebab}.ts`,
+        dataFunction: `get${pascal}Sections`,
+        schemaDir: `src/lib/schemas/${kebab}`,
+        contentDir: `src/content/${kebab}`,
+        componentDir: `src/components/${kebab}`,
+        importsMarker: `// @gen:${kebab}-imports`,
+        sectionsMarker: `{/* @gen:${kebab}-sections */}`,
+    };
+}
+export const sectionFiles = (targets, kebab) => [
+    `${targets.schemaDir}/${kebab}.ts`,
+    `${targets.contentDir}/${kebab}.yml`,
+    `${targets.componentDir}/${kebab}.astro`,
+];
+export function findSectionedPages(root, marker) {
+    return readdirSync(join(root, 'src/pages'), { recursive: true, withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.astro'))
+        .map((entry) => relative(root, join(entry.parentPath, entry.name)))
+        .filter((page) => readFileSync(join(root, page), 'utf8').includes(marker))
+        .sort();
+}
+export function validateSectionName(plop) {
+    return (value) => {
+        const camel = plop.getHelper('camelCase')(String(value));
+        if (!camel)
+            return 'Section name is required';
+        if (!isValidIdentifier(camel)) {
+            return `"${value}" would generate an invalid identifier (${camel}SectionSchema) — use ASCII letters/digits, starting with a letter, not a JS reserved word`;
+        }
+        return true;
+    };
+}

package/dist/gen/section.d.mts

@@ -0,0 +1 @@
+export default function sectionGenerator(plop: any): void;

package/dist/gen/section.mjs

@@ -0,0 +1,68 @@
+import { isValidIdentifier } from './identifier.mjs';
+import { assertSectionInjectable, injectSection } from './inject-section.mjs';
+import { postGenAction } from './post-gen.mjs';
+import { casings, sectionFiles, sectionTargets, validateSectionName } from './section-targets.mjs';
+function rollbackHint(targets) {
+    return (`gen:section also MODIFIED three existing files: ${targets.barrel}, ${targets.dataLayer} and the page ` +
+        `that carries ${targets.sectionsMarker}. Review them with \`git diff\`, then discard ONLY the injected hunks ` +
+        'with `git checkout -p` on those paths. Then delete the generated schema/yml/component files. A re-run ' +
+        'without rollback fails pre-flight with "already in the union".');
+}
+export default function sectionGenerator(plop) {
+    const root = process.cwd();
+    const tpl = 'templates/section';
+    plop.setGenerator('section', {
+        description: 'New section of a sectioned page (Zod schema + YAML + component + injection)',
+        prompts: [
+            {
+                type: 'input',
+                name: 'collection',
+                message: 'Sectioned collection (e.g. homepage):',
+                default: 'homepage',
+                validate: (value) => {
+                    const camel = plop.getHelper('camelCase')(String(value));
+                    if (!camel)
+                        return 'Collection name is required';
+                    if (!isValidIdentifier(camel)) {
+                        return `"${value}" would generate an invalid identifier (${camel}CollectionSchema) — use ASCII letters/digits, starting with a letter, not a JS reserved word`;
+                    }
+                    return true;
+                },
+            },
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Section name (e.g. features):',
+                validate: validateSectionName(plop),
+            },
+            {
+                type: 'confirm',
+                name: 'image',
+                message: 'Does the section carry an image? (its content starts on src/assets/placeholder.jpg)',
+                default: false,
+            },
+        ],
+        actions: (answers) => {
+            const collection = casings(plop, answers.collection);
+            const section = casings(plop, answers.name);
+            const targets = sectionTargets(collection);
+            const request = { root, collection, ...section, image: answers.image === true };
+            const [schema, content, component] = sectionFiles(targets, section.kebab);
+            const data = { section: answers.name };
+            return [
+                () => {
+                    assertSectionInjectable(request);
+                    return 'hook-point contract checks passed';
+                },
+                { type: 'add', path: schema, templateFile: `${tpl}/schema.ts.hbs`, data },
+                { type: 'add', path: content, templateFile: `${tpl}/content.yml.hbs`, data },
+                { type: 'add', path: component, templateFile: `${tpl}/component.astro.hbs`, data },
+                () => {
+                    injectSection(request);
+                    return `injected union + pick + page: ${section.pascal}`;
+                },
+                postGenAction(root, rollbackHint(targets)),
+            ];
+        },
+    });
+}