@i18nprune/core 0.1.0

package/dist/sourceContext-1LQg3HiQ.d.ts

@@ -0,0 +1,36 @@
+import { C as CoreContext } from './coreContext-DMaWLvmB.js';
+import { R as RuntimePathPort } from './path-Bfn3SAts.js';
+
+type LocaleListRow = {
+    code: string;
+    localePath: string;
+    /** On-disk JSON segments for this locale code (e.g. `app/en.json`, `common/en.json`). */
+    segmentCount: number;
+    segmentRelativePaths: string[];
+    leafCount: number;
+    englishIdenticalLeafCount: number | null;
+    isSourceLocale: boolean;
+};
+
+type ResolveResumeTargetCodesFromRawInput = {
+    commandName: string;
+    /** Non-empty selector string (after `pickTargetSelector`), including `all` or comma-separated codes. */
+    raw: string;
+    ctx: CoreContext;
+};
+
+type AssertGenerateTargetCodesInput = {
+    commandName: string;
+    codes: readonly string[];
+    sourceLocalePath: string;
+    path: RuntimePathPort;
+};
+
+type SourceLocaleContext = {
+    paths: {
+        sourceLocale: string;
+    };
+    path: RuntimePathPort;
+};
+
+export type { AssertGenerateTargetCodesInput as A, LocaleListRow as L, ResolveResumeTargetCodesFromRawInput as R, SourceLocaleContext as S };

package/dist/sourceSurface-mDtwGo1E.d.ts

@@ -0,0 +1,122 @@
+import { D as DynamicKeySite } from './index-DdjljwMj.js';
+import { I as Issue } from './index-X50E1FIX.js';
+import { S as StringLeaf } from './index-BQuLEQ9b.js';
+import { S as StringPresencePolicy } from './root-2-kCaBvQ.js';
+import { R as RunEmitter } from './index-BgG01AKL.js';
+
+/**
+ * Folded summary of key-site observations for usage detection (`cleanup`, `missing`, reference rules).
+ * Built with per-file const maps (avoids cross-file `const` identifier collisions).
+ */
+type ProjectLiteralKeyUsage = {
+    /** Fully resolved `literal` and `template_resolved` keys. */
+    resolvedKeys: ReadonlySet<string>;
+    /** Static prefixes from `template_partial` when `uncertainPrefix` is set. */
+    uncertainPrefixes: ReadonlySet<string>;
+    /** First path segment (or bracket segment) of each resolved or uncertain path — prefix matching for “used under root”. */
+    usedRoots: ReadonlySet<string>;
+};
+
+type CleanupStringPresenceEvidence = {
+    key: string;
+    kind: 'guard_skipped' | 'warn_hit';
+    locations: string[];
+};
+type ResolveCleanupKeysWithStringPresenceInput = {
+    candidates: readonly string[];
+    leaves: readonly StringLeaf[];
+    stringPresence: StringPresencePolicy;
+    stringPresenceMaxHitsPerKey: number;
+    skipStringPresenceCheck: boolean;
+    stringPresenceAvailable: boolean;
+    hasStringPresence: (sample: string) => boolean;
+    getStringPresenceLocations: (sample: string, maxHits: number) => string[];
+    shouldRunStringPresenceForKey?: (input: {
+        key: string;
+        value: string;
+    }) => boolean;
+};
+/**
+ * Pure policy evaluator for cleanup string-presence handling.
+ * Host provides the underlying presence probe and optional locations lookup.
+ */
+declare function resolveCleanupKeysWithStringPresencePolicy(input: ResolveCleanupKeysWithStringPresenceInput): {
+    safeToRemove: string[];
+    evidence: CleanupStringPresenceEvidence[];
+};
+
+type CleanupJsonRunSummary = {
+    durationMs: number;
+    command: 'cleanup';
+    ok: boolean;
+    counts: {
+        remove: number;
+        dynamicKeySites: number;
+    };
+};
+type CleanupJsonOutput = {
+    wouldRemove: number;
+    keys: string[];
+    dynamicKeySites: number;
+    uncertainPrefixes: string[];
+    /** Present when the CLI emits the final `cleanup` envelope. */
+    summary?: CleanupJsonRunSummary;
+};
+type CleanupRunOptions = {
+    /** Report candidates only; do not write (CLI `--dry-run`). */
+    dryRun?: boolean;
+    /** Skip host string-presence (ripgrep) probes — static unused-key list only. */
+    skipStringPresenceCheck?: boolean;
+};
+type CleanupHostHooks = {
+    emit?: RunEmitter;
+    runId?: string;
+    isStringPresenceAvailable: () => boolean;
+    hasStringPresence: (sample: string) => boolean;
+    getStringPresenceLocations: (sample: string, maxHits: number) => string[];
+    /**
+     * When false, core skips the string-presence guard for this key (CLI sets false for all keys when `--no-rg`).
+     * Default: apply guard per {@link reference.stringPresence} when probes are enabled.
+     */
+    shouldRunStringPresenceForKey?: (input: {
+        key: string;
+        value: string;
+    }) => boolean;
+};
+type CleanupSegmentWrite = {
+    sourcePath: string;
+    relativePath: string;
+    nextSourceJson: unknown;
+    removedPaths: string[];
+};
+type CleanupWritePlan = {
+    /** Segment file writes (one for flat_file, many for locale_directory layouts). */
+    writes: CleanupSegmentWrite[];
+    keys: string[];
+    /** Primary path for legacy messages (first write). */
+    sourcePath: string;
+    nextSourceJson: unknown;
+    removedPaths: string[];
+};
+type CleanupRunResult = {
+    payload: CleanupJsonOutput;
+    issues: Issue[];
+    writePlan: CleanupWritePlan;
+    sourceLeaves: StringLeaf[];
+    allKeyPathCount: number;
+    candidateKeys: string[];
+    safeToRemove: string[];
+    excludedUncertain: number;
+    dynamicSites: readonly DynamicKeySite[];
+    keyObservationsCount: number;
+    stringPresenceAvailable: boolean;
+    stringPresenceEvidence: CleanupStringPresenceEvidence[];
+};
+
+/** One on-disk source locale segment file for cleanup read/write. */
+type CleanupSourceSegmentRef = {
+    absolutePath: string;
+    relativePath: string;
+};
+
+export { type CleanupWritePlan as C, type ProjectLiteralKeyUsage as P, type ResolveCleanupKeysWithStringPresenceInput as R, type CleanupHostHooks as a, type CleanupRunOptions as b, type CleanupRunResult as c, type CleanupSourceSegmentRef as d, type CleanupJsonOutput as e, type CleanupJsonRunSummary as f, type CleanupSegmentWrite as g, type CleanupStringPresenceEvidence as h, resolveCleanupKeysWithStringPresencePolicy as r };

package/dist/sync.d.ts

@@ -0,0 +1,86 @@
+import { M as MergeToTemplateOptions } from './prune-c6hKZCv_.js';
+export { m as mergeToTemplateShape, p as pruneToTemplateShape } from './prune-c6hKZCv_.js';
+import { a as PreservePolicy } from './root-2-kCaBvQ.js';
+import { C as CoreContext } from './coreContext-DMaWLvmB.js';
+import { L as LocaleMetadataReport } from './index-DLwTogCo.js';
+import { S as SyncHostHooks, a as SyncRunResult, b as SyncRunOptions, c as SyncHumanLeafSummary } from './humanEmit-ygNlYX-S.js';
+export { d as SyncFileLine, e as SyncJsonOutput, f as SyncLocaleDisplayGroup } from './humanEmit-ygNlYX-S.js';
+import { S as StringLeaf } from './index-BQuLEQ9b.js';
+import { p as parseSyncLangSelection } from './targets-EmtKyr6F.js';
+import 'zod';
+import './path-Bfn3SAts.js';
+import './fs-BUYD8ZhA.js';
+import './providers-0uMEfT6q.js';
+import './capabilities-x74cD2Hu.js';
+import './adapters-gp1lXp0T.js';
+import './index-DdjljwMj.js';
+import './index-X50E1FIX.js';
+import './index-BgG01AKL.js';
+import './index-DeIw-cZd.js';
+import './localeTargetCodes-BBIQjauw.js';
+
+/**
+ * Merge + prune a target locale JSON toward the source template shape (sync semantics).
+ * Pure: no filesystem; use in `sync` and tests.
+ */
+declare function computeSyncedLocaleJson(template: unknown, cur: unknown, preserve: PreservePolicy | undefined, mergeOpts: MergeToTemplateOptions | undefined): {
+    next: unknown;
+    wouldChange: boolean;
+};
+/**
+ * Convert structured locale terminals (`{ value: string, ... }`) into plain string leaves.
+ * Keeps unrelated object/array structure intact.
+ */
+declare function stripStructuredLeafMetadata(root: unknown): unknown;
+
+/** Per-file `localeMetadataReports` row when sync does not apply a metadata mode. */
+declare function idleLocaleMetadataReportForSkippedSync(totalSourceLeafPaths: number): LocaleMetadataReport;
+declare function emitSyncHumanMessages(host: Pick<SyncHostHooks, 'emit' | 'runId'>, input: {
+    result: SyncRunResult;
+    dryRun: boolean;
+    listLimit: number;
+    explicitStripMetadata: boolean;
+    explicitMetadata: boolean;
+}): void;
+declare function runSync(ctx: CoreContext, opts: SyncRunOptions, host: SyncHostHooks): SyncRunResult;
+
+/**
+ * Human-readable leaf string at a source template dotted path (plain terminal or `{ value }` object).
+ */
+declare function readLeafDisplayString(root: unknown, pathStr: string): string | undefined;
+/**
+ * Map a collected string-leaf path (may end in `.value` for structured leaves) to a template path, if any.
+ */
+declare function canonicalTemplatePathForCollectedLeaf(leafPath: string, templatePaths: ReadonlySet<string>): string | null;
+/**
+ * Derive **`hydrated` / preserved / pruned-extra** counts for stderr messaging.
+ *
+ * **`mergedLocaleJson`** should be **`computeSyncedLocaleJson`…`next`** (**before** `--metadata` / `--strip-metadata`)
+ * so “extra path removed” reflects template merge/prune, not metadata reshaping alone.
+ *
+ * - **Hydrated**: template paths with no readable leaf (`string` or structured `.value`) in the locale before sync.
+ * - **Preserved**: template paths where a readable leaf already existed beforehand.
+ * - **Pruned extras**: logical translation paths from **`collectTranslationSurfaceLeaves(before)`** that do not map to any template path and
+ *   are absent from **`mergedLocaleJson`** (best-effort; compares raw collected paths).
+ */
+declare function summarizeSyncLeavesForHumanLog(sourceLeaves: readonly StringLeaf[], cur: unknown, mergedLocaleJson: unknown): SyncHumanLeafSummary;
+
+/** Normalized `sync --target` selection (same as {@link parseSyncLangSelection}). */
+type SyncLangSelection = ReturnType<typeof parseSyncLangSelection>;
+/**
+ * Decide which locale JSON files sync should touch, and which requested codes have no file yet.
+ * Pure: no I/O. Caller runs {@link assertNotSourceTargetLocale} for each code when `mode === 'codes'`.
+ *
+ * @param localeJsonBasenames — Every `*.json` basename in `localesDir` (e.g. `en.json`, `fr.json`).
+ * @param sourceJsonBasename — Source-of-truth file basename (e.g. `en.json`).
+ */
+declare function resolveSyncTargetFiles(input: {
+    localeJsonBasenames: readonly string[];
+    sourceJsonBasename: string;
+    selection: SyncLangSelection;
+}): {
+    targetFiles: string[];
+    missingLocaleCodes: string[];
+};
+
+export { SyncHostHooks, SyncHumanLeafSummary, type SyncLangSelection, SyncRunOptions, SyncRunResult, canonicalTemplatePathForCollectedLeaf, computeSyncedLocaleJson, emitSyncHumanMessages, idleLocaleMetadataReportForSkippedSync, readLeafDisplayString, resolveSyncTargetFiles, runSync, stripStructuredLeafMetadata, summarizeSyncLeavesForHumanLog };