@elia97/officina 0.2.0 → 0.4.0

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/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/post-gen.d.mts

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

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/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.d.mts

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

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/ts-morph-utils.d.mts

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

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/alignment.d.ts

@@ -0,0 +1,23 @@
+import type { OfficinaConfig } from './config.ts';
+import type { ContractGap } from './contract.ts';
+export interface ProjectFiles {
+    /** Tracciati e non tracciati, senza gli ignorati: un file locale fuori da git non è un residuo. */
+    paths: readonly string[];
+    read: (path: string) => string | undefined;
+}
+export interface Manifest {
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}
+export declare const EXPECTED_SCRIPTS: Readonly<Record<string, string>>;
+export declare const CI_STEPS: readonly string[];
+export declare function scriptGaps({ scripts }: Manifest): ContractGap[];
+export declare function dependencyGaps({ dependencies, devDependencies }: Manifest): ContractGap[];
+export declare function leftoverGaps({ paths, read }: ProjectFiles): ContractGap[];
+export declare const BIOME_PRESET = "@elia97/officina/biome";
+export declare const LEFTHOOK_PRESET = "node_modules/@elia97/officina/presets/lefthook.yml";
+export declare function presetGaps({ read }: ProjectFiles): ContractGap[];
+export declare function workflowGaps({ read }: ProjectFiles): ContractGap[];
+/** `loaded` è la configurazione letta, l'errore che il suo caricamento ha sollevato, o `undefined` se il file non c'è. */
+export declare function configGaps(loaded: OfficinaConfig | Error | undefined): ContractGap[];

package/dist/lib/alignment.js

@@ -0,0 +1,166 @@
+export const EXPECTED_SCRIPTS = {
+    'check:comments': 'officina check comments',
+    'check:language': 'officina check language',
+    'check:routes': 'officina check routes',
+    'check:roadmap': 'officina check roadmap',
+    'check:placeholders': 'officina check placeholders',
+    'perf:bundle': 'officina check bundle',
+    'smoke:prod': 'officina check smoke',
+    'analytics:verify': 'officina check analytics',
+    lhci: 'officina check lighthouse',
+    'lhci:local': 'officina check lighthouse --local',
+    doctor: 'officina doctor',
+    gen: 'officina gen',
+    'gen:section': 'officina gen section',
+    'gen:page': 'officina gen page',
+    'gen:component': 'officina gen component',
+    'gen:collection': 'officina gen collection',
+    'gen:icons': 'officina gen icons',
+};
+export const CI_STEPS = [
+    'check:language',
+    'check:routes',
+    'check:roadmap',
+    'check:comments',
+    'doctor',
+];
+const MANIFEST = 'package.json';
+export function scriptGaps({ scripts = {} }) {
+    const gaps = [];
+    for (const [name, expected] of Object.entries(EXPECTED_SCRIPTS)) {
+        const actual = scripts[name];
+        if (actual === undefined)
+            gaps.push({ path: MANIFEST, message: `script \`${name}\` assente: atteso \`${expected}\`` });
+        else if (!actual.startsWith(expected))
+            gaps.push({ path: MANIFEST, message: `script \`${name}\` è \`${actual}\`: atteso \`${expected}\`` });
+    }
+    const ci = scripts.ci ?? '';
+    for (const step of CI_STEPS) {
+        if (!ci.includes(`pnpm run ${step}`))
+            gaps.push({ path: MANIFEST, message: `script \`ci\` non lancia \`${step}\`` });
+    }
+    return gaps;
+}
+const RETIRED_DEPENDENCIES = ['plop', 'ts-morph'];
+export function dependencyGaps({ dependencies = {}, devDependencies = {} }) {
+    const declared = { ...dependencies, ...devDependencies };
+    const gaps = RETIRED_DEPENDENCIES.filter((name) => name in declared).map((name) => ({
+        path: MANIFEST,
+        message: `\`${name}\` non serve più al progetto: è una dipendenza di officina`,
+    }));
+    if (!('@elia97/officina' in devDependencies)) {
+        gaps.push({ path: MANIFEST, message: '`@elia97/officina` non è fra le devDependencies' });
+    }
+    return gaps;
+}
+const FROM_PLUGIN = 'arriva dal plugin `metodo`';
+const FROM_PACKAGE = 'arriva da officina';
+const OUT_OF_REPOSITORY = 'sta nella cartella del progetto, fuori dal repository';
+// Una cartella si nomina con la barra finale: corrisponde a qualunque file sotto di lei.
+const LEFTOVERS = [
+    { path: '.claude/agents/', reason: FROM_PLUGIN },
+    { path: '.claude/commands/', reason: FROM_PLUGIN },
+    { path: '.claude/scripts/', reason: FROM_PLUGIN },
+    { path: '.claude/hooks/', reason: FROM_PLUGIN },
+    { path: 'HOW_TO_USE.md', reason: FROM_PLUGIN },
+    { path: 'docs/milestone-templates/', reason: FROM_PLUGIN },
+    { path: 'docs/proposal-templates/', reason: 'i modelli commerciali stanno nel sistema, non nel repository' },
+    { path: 'plopfile.mjs', reason: FROM_PACKAGE },
+    { path: 'scripts/gen/', reason: FROM_PACKAGE },
+    { path: 'scripts/templates/', reason: FROM_PACKAGE },
+    { path: 'scripts/check-comments.mjs', reason: FROM_PACKAGE },
+    { path: 'scripts/check-language.mjs', reason: FROM_PACKAGE },
+    { path: 'scripts/bundle-budget.mjs', reason: FROM_PACKAGE },
+    { path: 'scripts/smoke-production.mjs', reason: FROM_PACKAGE },
+    { path: 'scripts/lighthouse.mjs', reason: FROM_PACKAGE },
+    { path: 'scripts/verify-analytics-coverage.mjs', reason: FROM_PACKAGE },
+    { path: 'scripts/gen-icons.mjs', reason: FROM_PACKAGE },
+    { path: 'scripts/gen-icons.ts', reason: FROM_PACKAGE },
+    { path: 'scripts/lhci-local.sh', reason: FROM_PACKAGE },
+    { path: 'scripts/lib/bundle-budget.ts', reason: FROM_PACKAGE },
+    { path: 'scripts/lib/smoke-production.ts', reason: FROM_PACKAGE },
+    { path: 'scripts/lib/routes.ts', reason: FROM_PACKAGE },
+    { path: 'scripts/lib/check-comments.ts', reason: FROM_PACKAGE },
+    { path: 'scripts/lib/check-language.ts', reason: FROM_PACKAGE },
+    { path: 'scripts/lib/gtm-container.ts', reason: FROM_PACKAGE },
+    { path: 'scripts/lib/analytics-coverage.ts', reason: FROM_PACKAGE },
+    { path: 'scripts/lib/icons.ts', reason: FROM_PACKAGE },
+    { path: '.github/workflows/vercel-cli.yml', reason: "il pin di Vercel sta nell'action di deploy di officina" },
+    { path: 'docs/PROJECT.md', reason: OUT_OF_REPOSITORY },
+    { path: 'docs/DECISIONS.md', reason: OUT_OF_REPOSITORY },
+    { path: 'docs/RISKS.md', reason: OUT_OF_REPOSITORY },
+    { path: 'docs/INPUTS.md', reason: OUT_OF_REPOSITORY },
+    { path: 'docs/TASK-CONTEXT.md', reason: OUT_OF_REPOSITORY },
+    { path: 'docs/ESTIMATE.md', reason: OUT_OF_REPOSITORY },
+];
+const holds = (paths, target) => target.endsWith('/') ? paths.some((path) => path.startsWith(target)) : paths.includes(target);
+export function leftoverGaps({ paths, read }) {
+    const gaps = LEFTOVERS.filter(({ path }) => holds(paths, path)).map(({ path, reason }) => ({
+        path,
+        message: `residuo: ${reason}`,
+    }));
+    if (read('.claude/settings.json')?.includes('"hooks"')) {
+        gaps.push({ path: '.claude/settings.json', message: `blocco \`hooks\` residuo: il guard ${FROM_PLUGIN}` });
+    }
+    if (read('.mcp.json')?.includes('astro-docs')) {
+        gaps.push({ path: '.mcp.json', message: `server \`astro-docs\` residuo: ${FROM_PLUGIN}` });
+    }
+    return gaps;
+}
+export const BIOME_PRESET = '@elia97/officina/biome';
+export const LEFTHOOK_PRESET = 'node_modules/@elia97/officina/presets/lefthook.yml';
+export function presetGaps({ read }) {
+    const gaps = [];
+    if (!read('biome.json')?.includes(BIOME_PRESET)) {
+        gaps.push({ path: 'biome.json', message: `non estende \`${BIOME_PRESET}\`` });
+    }
+    if (!read('lefthook.yml')?.includes(LEFTHOOK_PRESET)) {
+        gaps.push({ path: 'lefthook.yml', message: `non estende \`${LEFTHOOK_PRESET}\`` });
+    }
+    return gaps;
+}
+const ACTIONS = [
+    { workflow: '.github/workflows/ci.yml', action: 'ci' },
+    { workflow: '.github/workflows/ci.yml', action: 'review' },
+    { workflow: '.github/workflows/deploy.yml', action: 'deploy' },
+    { workflow: '.github/workflows/lighthouse.yml', action: 'lighthouse' },
+];
+// Un tag di versione o uno SHA intero: `@main` farebbe girare in produzione passi mai collaudati.
+const PINNED_REF = /^(v\d+\.\d+\.\d+|[0-9a-f]{40})$/;
+function actionGap(source, action) {
+    const name = `Elia97/officina/actions/${action}`;
+    if (source === undefined)
+        return `manca: i suoi passi arrivano da \`${name}\``;
+    const ref = new RegExp(`${name}@(\\S+)`).exec(source)?.[1];
+    if (ref === undefined)
+        return `non usa \`${name}\``;
+    return PINNED_REF.test(ref)
+        ? undefined
+        : `\`${name}@${ref}\`: il riferimento va fissato a un tag di versione o a uno SHA`;
+}
+export function workflowGaps({ read }) {
+    return ACTIONS.flatMap(({ workflow, action }) => {
+        const message = actionGap(read(workflow), action);
+        return message === undefined ? [] : [{ path: workflow, message }];
+    });
+}
+const CONFIG = 'officina.config.ts';
+function siteUrlGap(siteUrl) {
+    if (siteUrl === undefined)
+        return '`siteUrl` assente: `check smoke` non ha un host canonico';
+    if (!URL.canParse(siteUrl))
+        return `\`siteUrl\` non è un URL: \`${siteUrl}\``;
+    return siteUrl.endsWith('/') ? `\`siteUrl\` finisce con una barra: \`${siteUrl}\`` : undefined;
+}
+/** `loaded` è la configurazione letta, l'errore che il suo caricamento ha sollevato, o `undefined` se il file non c'è. */
+export function configGaps(loaded) {
+    if (loaded === undefined)
+        return [{ path: CONFIG, message: 'manca: i valori del progetto per officina stanno qui' }];
+    if (loaded instanceof Error)
+        return [{ path: CONFIG, message: `non si carica: ${loaded.message}` }];
+    const messages = [
+        siteUrlGap(loaded.siteUrl),
+        loaded.icons === undefined ? '`icons.background` assente: `gen icons` non ha un colore di fondo' : undefined,
+    ];
+    return messages.filter((message) => message !== undefined).map((message) => ({ path: CONFIG, message }));
+}

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,25 @@
+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 const findConfigFile: (root: string) => string | undefined;
+export declare function loadConfig(root: string): Promise<OfficinaConfig>;

package/dist/lib/config.js

@@ -0,0 +1,22 @@
+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 const findConfigFile = (root) => CONFIG_FILES.map((name) => join(root, name)).find((path) => existsSync(path));
+export async function loadConfig(root) {
+    const file = findConfigFile(root);
+    if (file === undefined)
+        return {};
+    const module = await import(__rewriteRelativeImportExtension(pathToFileURL(file).href));
+    return module.default ?? {};
+}

package/dist/lib/contract.d.ts

@@ -0,0 +1,22 @@
+type Requirement = {
+    kind: 'file';
+    path: string;
+    reason: string;
+} | {
+    kind: 'directory';
+    path: string;
+    extension: string;
+    reason: string;
+} | {
+    kind: 'anchor';
+    path: string;
+    text: string;
+    reason: string;
+};
+export declare const CONTRACT: Requirement[];
+export interface ContractGap {
+    path: string;
+    message: string;
+}
+export declare function contractGaps(root: string): ContractGap[];
+export {};

package/dist/lib/git.d.ts

@@ -0,0 +1,6 @@
+export declare const trackedAndUntracked: () => string[];
+export type DiffScope = {
+    base?: string | undefined;
+    head?: string | undefined;
+};
+export declare function changedFiles({ base, head }: DiffScope): string[];

package/dist/lib/gtm-container.d.ts

@@ -0,0 +1,41 @@
+export type Macro = {
+    function?: unknown;
+    vtp_name?: unknown;
+};
+export type Tag = {
+    function?: unknown;
+    vtp_eventName?: unknown;
+    vtp_tagId?: unknown;
+};
+export type Predicate = {
+    function?: unknown;
+    arg0?: unknown;
+    arg1?: unknown;
+};
+export type ContainerResource = {
+    macros: Macro[];
+    tags: Tag[];
+    predicates: Predicate[];
+    rules: unknown[][];
+};
+/** Un tag evento GA4 e le condizioni che lo fanno scattare. `unsupported` porta quello che
+ *  il lettore non sa interpretare, così un trigger saltato a metà non risulta mai compreso. */
+export type Trigger = {
+    eventName: string;
+    firesOn: string[];
+    selectors: string[];
+    urlContains: string[];
+    unsupported: string[];
+};
+/** Il container arriva come un solo file JS che contiene un unico letterale `var data = {…}`,
+ *  e a isolarlo è solo un conteggio di graffe che conosce le stringhe: i valori ne contengono. */
+export declare function parseContainerData(source: string): ContainerResource;
+/** L'id del container come lo serve la produzione, incorporato con `define:vars`. Pubblico per
+ *  costruzione, ed è l'unica risposta a "quale container gira su questo host". */
+export declare function extractGtmId(html: string): string;
+/** Le proprietà GA4 che il container configura. Senza nemmeno una, ogni tag evento scatta nel
+ *  vuoto: un elenco vuoto è un fallimento, non una nota. */
+export declare function googleTagIds(container: ContainerResource): string[];
+/** GTM tiene separati tag e condizioni: una regola elenca clausole, con `if` e `unless` che
+ *  nominano predicati e `add` e `block` che nominano tag. Un trigger per regola che aggiunge il tag. */
+export declare function extractTriggers(container: ContainerResource): Trigger[];