@elia97/officina 0.1.0 → 0.3.0

package/dist/gen/sectioned-collection.d.mts

@@ -0,0 +1,26 @@
+declare const forSections: (answers: any) => boolean;
+export declare function sectionedCollectionPrompts(plop: any): ({
+    type: string;
+    name: string;
+    message: string;
+    when: typeof forSections;
+    validate: (value: any) => string | true;
+    default?: never;
+} | {
+    validate?: never;
+    type: string;
+    name: string;
+    message: string;
+    default: boolean;
+    when: typeof forSections;
+})[];
+export declare function sectionedCollectionActions(plop: any, answers: any, root: any): ((() => string) | {
+    type: string;
+    path: string | undefined;
+    templateFile: string;
+    data: {
+        collection: any;
+        pageKey: any;
+    };
+})[];
+export {};

package/dist/gen/sectioned-collection.mjs

@@ -0,0 +1,81 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { assertInjectable, injectCollection } from './inject-config.mjs';
+import { assertStringsInjectable, injectStrings } from './inject-strings.mjs';
+import { pageStrings, pathSegments } from './page.mjs';
+import { postGenAction } from './post-gen.mjs';
+import { casings, findSectionedPages, sectionFiles, sectionTargets, validateSectionName } from './section-targets.mjs';
+const SECTIONS = 'templates/sections';
+const SECTION = 'templates/section';
+const ROLLBACK_HINT = 'gen:collection also MODIFIED src/content.config.ts and every dictionary in src/i18n/strings/. Review them ' +
+    'with `git diff`, then discard ONLY the injected hunks with `git checkout -p` on those paths, and delete the ' +
+    'generated barrel, data layer, page and section files. A re-run without rollback fails pre-flight with ' +
+    '"already exists".';
+const forSections = (answers) => answers.sections === true;
+export function sectionedCollectionPrompts(plop) {
+    return [
+        {
+            type: 'input',
+            name: 'page',
+            message: 'Page path of the sectioned page (e.g. about-us):',
+            when: forSections,
+            validate: (value) => pathSegments(plop, value).length > 0 || 'Page path must contain at least one letter or digit',
+        },
+        {
+            type: 'input',
+            name: 'section',
+            message: 'First section name (e.g. intro):',
+            when: forSections,
+            validate: validateSectionName(plop),
+        },
+        {
+            type: 'confirm',
+            name: 'image',
+            message: 'Does the first section carry an image?',
+            default: false,
+            when: forSections,
+        },
+    ];
+}
+function assertCreatable({ root, targets, page, section, strings }) {
+    for (const path of [page, targets.barrel, targets.dataLayer, ...sectionFiles(targets, section.kebab)]) {
+        if (existsSync(join(root, path))) {
+            throw new Error(`gen:collection pre-flight failed: ${path} already exists — remove it or pick another name`);
+        }
+    }
+    const carriers = findSectionedPages(root, targets.sectionsMarker);
+    if (carriers.length > 0) {
+        throw new Error(`gen:collection pre-flight failed: ${carriers.join(', ')} already carries ${targets.sectionsMarker}`);
+    }
+    assertStringsInjectable({ root, keys: strings.map(({ key }) => key) });
+}
+export function sectionedCollectionActions(plop, answers, root) {
+    const collection = casings(plop, answers.name);
+    const section = casings(plop, answers.section);
+    const targets = sectionTargets(collection);
+    const segments = pathSegments(plop, answers.page);
+    const pageKey = plop.getHelper('camelCase')(segments.join('/'));
+    const page = `src/pages/${segments.join('/')}.astro`;
+    const strings = pageStrings({ pageKey, pageTitle: plop.getHelper('sentenceCase')(segments.at(-1)), dynamic: false });
+    const data = { collection: answers.name, pageKey };
+    const [schema, content, component] = sectionFiles(targets, section.kebab);
+    return [
+        () => {
+            assertInjectable({ root, camel: collection.camel, kebab: collection.kebab });
+            assertCreatable({ root, targets, page, section, strings });
+            return 'content.config.ts, page and dictionary contract checks passed';
+        },
+        { type: 'add', path: targets.barrel, templateFile: `${SECTIONS}/index.ts.hbs`, data },
+        { type: 'add', path: targets.dataLayer, templateFile: `${SECTIONS}/data-layer.ts.hbs`, data },
+        { type: 'add', path: page, templateFile: `${SECTIONS}/page.astro.hbs`, data },
+        { type: 'add', path: schema, templateFile: `${SECTION}/schema.ts.hbs`, data },
+        { type: 'add', path: content, templateFile: `${SECTION}/content.yml.hbs`, data },
+        { type: 'add', path: component, templateFile: `${SECTION}/component.astro.hbs`, data },
+        () => {
+            injectCollection({ root, camel: collection.camel, kebab: collection.kebab, sections: true });
+            injectStrings({ root, entries: strings });
+            return `injected sectioned collection ${collection.kebab} and ${strings.map(({ key }) => key).join(', ')}`;
+        },
+        postGenAction(root, ROLLBACK_HINT),
+    ];
+}

package/dist/gen/templates/collection/data.yml.hbs

@@ -0,0 +1,2 @@
+title: Esempio
+description: Voce di esempio della collection {{dashCase name}}. Sostituiscila col contenuto reale.

package/dist/gen/templates/collection/doc.md.hbs

@@ -0,0 +1,8 @@
+---
+title: Esempio
+description: Voce di esempio della collection {{dashCase name}}.
+pubDate: 2026-01-01
+draft: true
+---
+
+Corpo di esempio della collection **{{dashCase name}}**. Sostituiscilo col contenuto reale.

package/dist/gen/templates/collection/schema.ts.hbs

@@ -0,0 +1,11 @@
+import { z } from 'astro/zod'
+
+export const {{camelCase name}}Schema = z.strictObject({
+  title: z.string().min(1),
+  description: z.string().optional(),
+  {{#if document}}
+  pubDate: z.coerce.date(),
+  draft: z.boolean().default(false),
+  {{/if}}
+})
+export type {{pascalCase name}}Entry = z.infer<typeof {{camelCase name}}Schema>

package/dist/gen/templates/component/component.astro.hbs

@@ -0,0 +1,21 @@
+---
+import type { HTMLAttributes } from 'astro/types'
+import { cva, type VariantProps } from 'class-variance-authority'
+
+import { cn } from '@/lib/utils'
+
+export const {{camelCase name}}Variants = cva('', {
+  variants: {
+    variant: {
+      default: '',
+    },
+  },
+  defaultVariants: { variant: 'default' },
+})
+
+interface Props extends HTMLAttributes<'div'>, VariantProps<typeof {{camelCase name}}Variants> {}
+
+const { variant, class: className, ...rest } = Astro.props
+---
+
+<div class={cn({{camelCase name}}Variants({ variant }), className)} {...rest}><slot /></div>

package/dist/gen/templates/page/dynamic.astro.hbs

@@ -0,0 +1,24 @@
+---
+import Container from '@/components/ui/container.astro'
+import Heading from '@/components/ui/heading.astro'
+import Section from '@/components/ui/section.astro'
+import MainLayout from '@/layouts/main.astro'
+
+import { useTranslations } from '@/i18n/translate'
+
+export function getStaticPaths() {
+  // TODO: ricava i percorsi da una collection, come nel blueprint content-section del plugin metodo.
+  return [{ params: { slug: 'example' } }]
+}
+
+const t = useTranslations(Astro.currentLocale)
+const { slug } = Astro.params
+---
+
+<MainLayout title={slug ?? t('page.{{pageKey}}.title')}>
+  <Section>
+    <Container>
+      <Heading as="h1" size="h1">{slug}</Heading>
+    </Container>
+  </Section>
+</MainLayout>

package/dist/gen/templates/page/static.astro.hbs

@@ -0,0 +1,20 @@
+---
+import Container from '@/components/ui/container.astro'
+import Heading from '@/components/ui/heading.astro'
+import Section from '@/components/ui/section.astro'
+import MainLayout from '@/layouts/main.astro'
+
+import { useTranslations } from '@/i18n/translate'
+
+const t = useTranslations(Astro.currentLocale)
+const title = t('page.{{pageKey}}.title')
+const description = t('page.{{pageKey}}.description')
+---
+
+<MainLayout {title} {description}>
+  <Section>
+    <Container>
+      <Heading as="h1" size="h1">{title}</Heading>
+    </Container>
+  </Section>
+</MainLayout>

package/dist/gen/templates/section/component.astro.hbs

@@ -0,0 +1,45 @@
+---
+{{#if image}}
+import { Image } from 'astro:assets'
+
+{{/if}}
+import Button from '@/components/ui/button.astro'
+import Container from '@/components/ui/container.astro'
+import Heading from '@/components/ui/heading.astro'
+import Section from '@/components/ui/section.astro'
+import type { {{pascalCase collection}}Sections } from '@/lib/{{dashCase collection}}'
+
+import { ctaHref } from '@/i18n/href'
+
+type Props = {{pascalCase collection}}Sections['{{camelCase section}}']
+
+const { title, body, {{#if image}}image, {{/if}}buttons } = Astro.props
+const href = (url: string) => ctaHref(Astro.currentLocale, url)
+---
+
+<Section class="border-b border-border bg-background">
+  <Container>
+    <Heading as="h2">{title}</Heading>
+    {body && <p class="mt-4 max-w-2xl text-pretty text-muted-foreground">{body}</p>}
+    {{#if image}}
+    <Image
+      src={image.src}
+      alt={image.alt}
+      widths={[640, 960, 1280, 1920]}
+      sizes="(min-width: 96rem) 96rem, 100vw"
+      class="mt-8 h-auto w-full rounded-lg"
+    />
+    {{/if}}
+    {
+      buttons.length > 0 && (
+        <div class="mt-8 flex flex-wrap gap-4">
+          {buttons.map((button, index) => (
+            <Button as="a" href={href(button.url)} variant={index === 0 ? 'default' : 'outline'}>
+              {button.label}
+            </Button>
+          ))}
+        </div>
+      )
+    }
+  </Container>
+</Section>

package/dist/gen/templates/section/content.yml.hbs

@@ -0,0 +1,10 @@
+section: {{camelCase section}}
+title: Titolo della sezione
+body: >-
+  Contenuto placeholder della sezione. Sostituiscilo col copy reale del progetto.
+{{#if image}}
+image:
+  src: ../../assets/placeholder.jpg
+  alt: Descrizione dell'immagine
+{{/if}}
+buttons: []

package/dist/gen/templates/section/schema.ts.hbs

@@ -0,0 +1,20 @@
+{{#if image}}
+import type { SchemaContext } from 'astro:content'
+{{/if}}
+import { z } from 'astro/zod'
+
+import { ctaSchema{{#if image}}, imageSchema{{/if}} } from '../common'
+
+export function {{camelCase section}}SectionSchema({{#if image}}{ image }: SchemaContext{{/if}}) {
+  return z.strictObject({
+    section: z.literal('{{camelCase section}}'),
+    title: z.string().min(1),
+    body: z.string().optional(),
+    {{#if image}}
+    image: imageSchema(image),
+    {{/if}}
+    buttons: z.array(ctaSchema).default([]),
+  })
+}
+
+export type {{pascalCase section}}Section = z.infer<ReturnType<typeof {{camelCase section}}SectionSchema>>

package/dist/gen/templates/sections/data-layer.ts.hbs

@@ -0,0 +1,13 @@
+import { loadLocalizedSections, type SectionedPage } from '@/lib/content/localized-sections'
+
+export type {{pascalCase collection}}Sections = SectionedPage<'{{dashCase collection}}'>
+
+export async function get{{pascalCase collection}}Sections(locale?: string): Promise<{{pascalCase collection}}Sections> {
+  const { pick } = await loadLocalizedSections('{{dashCase collection}}', locale)
+
+  // INJECTION POINT per `pnpm gen:section` (ts-morph): le sezioni nuove aggiungono qui il
+  // loro pick() — il generatore verifica questo letterale di ritorno.
+  return {
+    {{camelCase section}}: pick('{{camelCase section}}'),
+  }
+}

package/dist/gen/templates/sections/index.ts.hbs

@@ -0,0 +1,12 @@
+{{#if image}}
+import type { SchemaContext } from 'astro:content'
+{{/if}}
+import { z } from 'astro/zod'
+
+import { {{camelCase section}}SectionSchema } from './{{dashCase section}}'
+
+// INJECTION POINT per `pnpm gen:section` (ts-morph): il generatore verifica questa funzione
+// e la sua chiamata a z.discriminatedUnion.
+export function {{camelCase collection}}CollectionSchema({{#if image}}context: SchemaContext{{/if}}) {
+  return z.discriminatedUnion('section', [{{camelCase section}}SectionSchema({{#if image}}context{{/if}})])
+}

package/dist/gen/templates/sections/page.astro.hbs

@@ -0,0 +1,30 @@
+---
+import {{pascalCase section}} from '@/components/{{dashCase collection}}/{{dashCase section}}.astro'
+import Container from '@/components/ui/container.astro'
+import Heading from '@/components/ui/heading.astro'
+import Section from '@/components/ui/section.astro'
+
+import MainLayout from '@/layouts/main.astro'
+
+import { get{{pascalCase collection}}Sections } from '@/lib/{{dashCase collection}}'
+
+import { useTranslations } from '@/i18n/translate'
+
+// @gen:{{dashCase collection}}-imports (i generatori inseriscono i nuovi import SOPRA questa riga)
+
+const t = useTranslations(Astro.currentLocale)
+const title = t('page.{{pageKey}}.title')
+const description = t('page.{{pageKey}}.description')
+const content = await get{{pascalCase collection}}Sections(Astro.currentLocale)
+---
+
+<MainLayout {title} {description}>
+  <Section>
+    <Container>
+      <Heading as="h1" size="h1">{title}</Heading>
+    </Container>
+  </Section>
+  {{!-- Handlebars legge "}}}" come chiusura di un'espressione non escapata: il tilde chiude il mustache prima della graffa di Astro. --}}
+  <{{pascalCase section}} {...content.{{camelCase section~}}} />
+  {/* @gen:{{dashCase collection}}-sections */}
+</MainLayout>

package/dist/gen/ts-morph-utils.d.mts

@@ -0,0 +1 @@
+export declare function isNameTaken(sourceFile: any, name: any): any;

package/dist/gen/ts-morph-utils.mjs

@@ -0,0 +1,8 @@
+export function isNameTaken(sourceFile, name) {
+    if (sourceFile.getVariableDeclaration(name) || sourceFile.getFunction(name))
+        return true;
+    return sourceFile
+        .getImportDeclarations()
+        .some((d) => d.getNamedImports().some((n) => (n.getAliasNode()?.getText() ?? n.getName()) === name) ||
+        d.getDefaultImport()?.getText() === name);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export type { Budget } from './lib/bundle-budget.ts';
+export { CSS_BUDGET_GZIP } from './lib/bundle-budget.ts';
+export type { OfficinaConfig } from './lib/config.ts';
+export { defineConfig } from './lib/config.ts';
+export type { IconSpec } from './lib/icon-specs.ts';
+export { ICON_SPECS } from './lib/icon-specs.ts';
+export type { VerifiedRoute } from './lib/routes.ts';
+export { NON_HTML_ROUTES } from './lib/routes.ts';
+export type { CheckResult, SmokeCheck, SmokeContext } from './lib/smoke-production.ts';
+export { checkBotIdChallenge, checkCanonicalHost, checkPages, checkSecurityHeaders, checkTrailingSlash, DEFAULT_CHECKS, SECURITY_HEADERS, } from './lib/smoke-production.ts';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { CSS_BUDGET_GZIP } from './lib/bundle-budget.js';
+export { defineConfig } from './lib/config.js';
+export { ICON_SPECS } from './lib/icon-specs.js';
+export { NON_HTML_ROUTES } from './lib/routes.js';
+export { checkBotIdChallenge, checkCanonicalHost, checkPages, checkSecurityHeaders, checkTrailingSlash, DEFAULT_CHECKS, SECURITY_HEADERS, } from './lib/smoke-production.js';

package/dist/lib/analytics-coverage.d.ts

@@ -0,0 +1,12 @@
+import type { Trigger } from './gtm-container.ts';
+export type LinkEvent = {
+    prefix: string;
+    event: string;
+};
+export type Coverage = {
+    event: string;
+    prefix: string;
+    covered: boolean;
+};
+export declare function extractLinkEvents(source: string): LinkEvent[];
+export declare function coverageOf(events: readonly LinkEvent[], triggers: readonly Trigger[]): Coverage[];

package/dist/lib/analytics-coverage.js

@@ -0,0 +1,15 @@
+const LINK_EVENT = /startsWith\('([^']+)'\)\)\s*return\s*'([^']+)'/g;
+// Letto dal sorgente di src/lib/analytics/link-tracking.ts invece di essere riscritto qui: le
+// due liste divergono il giorno in cui qualcuno aggiunge uno schema, e non fallirebbe niente.
+export function extractLinkEvents(source) {
+    return [...source.matchAll(LINK_EVENT)].map(([, prefix, event]) => ({
+        /* v8 ignore start -- i due gruppi di LINK_EVENT sono obbligatori: il ripiego serve solo ai tipi */
+        prefix: prefix ?? '',
+        event: event ?? '',
+        /* v8 ignore stop */
+    }));
+}
+export function coverageOf(events, triggers) {
+    const fired = new Set(triggers.map(({ eventName }) => eventName));
+    return events.map(({ event, prefix }) => ({ event, prefix, covered: fired.has(event) }));
+}

package/dist/lib/bundle-budget.d.ts

@@ -0,0 +1,24 @@
+export type Chunk = {
+    gzip: number;
+    static: Set<string>;
+    dynamic: Set<string>;
+};
+export type Budget = {
+    label: string;
+    matches: (route: string) => boolean;
+    maxGzip: number;
+};
+/** Le classi del progetto vengono prima, nell'ordine in cui `officina.config.ts` le dichiara. */
+export declare function budgetFor(route: string, budgets?: readonly Budget[]): Budget;
+/** Rollup racchiude gli specificatori statici con `"` e i dinamici in un template literal. */
+export declare function parseEdges(source: string): Pick<Chunk, 'static' | 'dynamic'>;
+export declare function htmlEntries(html: string): string[];
+export declare function staticClosure(entries: Iterable<string>, chunks: Map<string, Chunk>): Set<string>;
+export declare function deferredClosure(reached: Set<string>, chunks: Map<string, Chunk>): Set<string>;
+export declare const CSS_BUDGET_GZIP: number;
+export type Stylesheet = {
+    file: string;
+    gzip: number;
+};
+export declare function heaviestStylesheet(sheets: readonly Stylesheet[]): Stylesheet | null;
+export declare function cssBudgetFailure(sheets: readonly Stylesheet[], maxGzip?: number): string | null;

package/dist/lib/bundle-budget.js

@@ -0,0 +1,50 @@
+// 20 KB è ~1,5× la rotta più pesante misurata nello starter (/contatti, 13,4 KB gz).
+const DEFAULT_BUDGET = { label: 'default', matches: () => true, maxGzip: 20 * 1024 };
+/** Le classi del progetto vengono prima, nell'ordine in cui `officina.config.ts` le dichiara. */
+export function budgetFor(route, budgets = []) {
+    /* v8 ignore next -- DEFAULT_BUDGET accetta ogni rotta, quindi find() non torna mai undefined */
+    return [...budgets, DEFAULT_BUDGET].find((budget) => budget.matches(route)) ?? DEFAULT_BUDGET;
+}
+const captured = (source, pattern, group) => new Set([...source.matchAll(pattern)].map((match) => match[group]).filter((name) => name !== undefined));
+/** Rollup racchiude gli specificatori statici con `"` e i dinamici in un template literal. */
+export function parseEdges(source) {
+    return {
+        static: captured(source, /(?:from|import)\s*(["'`])\.\/([^"'`]+\.js)\1/g, 2),
+        dynamic: captured(source, /import\(\s*(["'`])\.\/([^"'`]+\.js)\1\s*\)/g, 2),
+    };
+}
+export function htmlEntries(html) {
+    return [...captured(html, /(?:src|href)="\/_astro\/([^"]+\.js)"/g, 1)];
+}
+export function staticClosure(entries, chunks) {
+    const seen = new Set();
+    const queue = [...entries];
+    while (queue.length > 0) {
+        const name = queue.pop();
+        if (name === undefined || seen.has(name))
+            continue;
+        const chunk = chunks.get(name);
+        if (chunk === undefined)
+            continue;
+        seen.add(name);
+        queue.push(...chunk.static);
+    }
+    return seen;
+}
+export function deferredClosure(reached, chunks) {
+    const entries = [...reached].flatMap((name) => [...(chunks.get(name)?.dynamic ?? [])]);
+    return new Set([...staticClosure(entries, chunks)].filter((name) => !reached.has(name)));
+}
+export const CSS_BUDGET_GZIP = 12 * 1024;
+export function heaviestStylesheet(sheets) {
+    return sheets.reduce((worst, sheet) => (worst && worst.gzip >= sheet.gzip ? worst : sheet), null);
+}
+// Astro emette un foglio di stile per gruppo di pagine e una rotta ne collega esattamente uno,
+// quindi la loro somma è fatta di byte che nessun visitatore scarica mai insieme.
+export function cssBudgetFailure(sheets, maxGzip = CSS_BUDGET_GZIP) {
+    const heaviest = heaviestStylesheet(sheets);
+    if (heaviest === null || heaviest.gzip <= maxGzip)
+        return null;
+    const over = heaviest.gzip - maxGzip;
+    return `CSS ${(heaviest.gzip / 1024).toFixed(1)} KB gz > ${(maxGzip / 1024).toFixed(1)} KB (+${(over / 1024).toFixed(1)} KB) in ${heaviest.file}`;
+}

package/dist/lib/check-comments.d.ts

@@ -0,0 +1,10 @@
+import type { Hit } from './cli.ts';
+import { type Line } from './comment-syntax.ts';
+export interface FileReport {
+    findings: Hit[];
+    comments: number;
+    total: number;
+}
+export declare const SCANNED: RegExp;
+export declare function report(file: string, lines: Line[]): FileReport;
+export declare function isNoisy({ comments, total }: FileReport): boolean;

package/dist/lib/check-language.d.ts

@@ -0,0 +1,11 @@
+import type { Hit } from './cli.ts';
+export declare function isScanned(path: string): boolean;
+export interface Tally {
+    italian: number;
+    english: number;
+}
+export declare function tally(prose: string): Tally;
+export type Verdict = 'english' | 'italian' | 'undecided';
+export declare function classify({ italian, english }: Tally, minHits?: number): Verdict;
+/** In un sorgente la prosa sta solo nei commenti: il codice è inglese per costruzione. */
+export declare function findingsFor(path: string, source: string): Hit[];

package/dist/lib/check-placeholders.d.ts

@@ -0,0 +1,6 @@
+import { type Finding, type Hit } from './cli.ts';
+type EnvHit = Omit<Finding, 'path' | 'severity'>;
+export declare function placeholderSources(): string[];
+export declare function sourceFindings(source: string): Hit[];
+export declare function envFindings(content: string): EnvHit[];
+export {};

package/dist/lib/check-roadmap.d.ts

@@ -0,0 +1,30 @@
+import type { Hit } from './cli.ts';
+export interface Row {
+    line: number;
+    number: number;
+    name: string;
+    phase: number;
+    days: number;
+}
+export interface Subtotal {
+    line: number;
+    label: string;
+    phase: number | null;
+    days: number;
+}
+export interface Section {
+    line: number;
+    number: number;
+    name: string;
+    phase: number;
+    days: number;
+}
+/** «1,5» è una giornata e mezza. Una cella vuota non è zero giornate: `Number('')` sarebbe 0. */
+export declare function parseDays(raw: string): number;
+/** Le righe numerate della tabella Status: una per milestone. */
+export declare function statusRows(source: string): Row[];
+/** Le righe di somma: un subtotale per fase, più il totale. */
+export declare function subtotals(source: string): Subtotal[];
+/** Le sezioni `## Milestone N`, con la fase e le giornate della loro testata. */
+export declare function sections(source: string): Section[];
+export declare function findingsFor(source: string): Hit[];

package/dist/lib/check-routes.d.ts

@@ -0,0 +1,6 @@
+import type { Hit } from './cli.ts';
+export declare const isScanned: (path: string) => boolean;
+export declare function normalizeTitle(raw: string): string;
+export declare function headings(source: string): string[];
+export declare function resolveTarget(from: string, cited: string): string;
+export declare function findingsFor(path: string, source: string): Hit[];

package/dist/lib/cli.d.ts

@@ -0,0 +1,26 @@
+export interface Hit {
+    line: number;
+    message: string;
+}
+export type Finding = {
+    path: string;
+    line?: number;
+    message: string;
+    severity: 'error' | 'warning';
+};
+export declare function cliOptions(args?: string[]): {
+    base?: string;
+    head?: string;
+    strict: boolean;
+    format: string;
+    diff: boolean;
+};
+export type CliOptions = ReturnType<typeof cliOptions>;
+export declare const isGenerated: (path: string) => boolean;
+export declare function scopedPaths(options: CliOptions, isScanned: (path: string) => boolean): string[];
+export declare function printFindings(findings: Finding[], format: string): void;
+export declare function exitCode(findings: Finding[], strict: boolean): number;
+export declare const readLines: (text: string) => {
+    n: number;
+    text: string;
+}[];

package/dist/lib/comment-syntax.d.ts

@@ -0,0 +1,11 @@
+export interface Line {
+    n: number;
+    text: string;
+}
+export interface CommentBlock {
+    lines: Line[];
+    trailing: boolean;
+}
+export type CommentStyle = 'hash' | 'css' | 'slash' | 'astro';
+export declare function styleOf(file: string): CommentStyle;
+export declare function commentBlocks(lines: Line[], style: CommentStyle): CommentBlock[];

package/dist/lib/config.d.ts

@@ -0,0 +1,24 @@
+import type { Budget } from './bundle-budget.ts';
+import type { VerifiedRoute } from './routes.ts';
+import type { SmokeCheck } from './smoke-production.ts';
+export interface OfficinaConfig {
+    /** L'apice di produzione, senza barra finale: lo usa `check smoke` quando non riceve un URL. */
+    siteUrl?: string;
+    icons?: {
+        background: string;
+    };
+    bundle?: {
+        budgets?: readonly Budget[];
+        cssMaxGzip?: number;
+    };
+    smoke?: {
+        securityHeaders?: Record<string, string | null>;
+        nonHtmlRoutes?: readonly VerifiedRoute[];
+        checks?: readonly SmokeCheck[];
+    };
+    analytics?: {
+        linkTracking?: string;
+    };
+}
+export declare const defineConfig: (config: OfficinaConfig) => OfficinaConfig;
+export declare function loadConfig(root: string): Promise<OfficinaConfig>;

package/dist/lib/config.js

@@ -0,0 +1,21 @@
+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 { pathToFileURL } from 'node:url';
+const CONFIG_FILES = ['officina.config.ts', 'officina.config.mjs', 'officina.config.js'];
+export const defineConfig = (config) => config;
+// Fuori da node_modules Node toglie i tipi da solo: il file del progetto può essere TypeScript.
+export async function loadConfig(root) {
+    const file = CONFIG_FILES.map((name) => join(root, name)).find((path) => existsSync(path));
+    if (file === undefined)
+        return {};
+    const module = await import(__rewriteRelativeImportExtension(pathToFileURL(file).href));
+    return module.default ?? {};
+}