@i18nprune/core 0.1.0

package/dist/syncSegment-Bx6He2Mu.d.ts

@@ -0,0 +1,149 @@
+import { T as TranslationSurfaceLeaf, L as LocaleReadDiagnostic, R as ResolvedLocalesLayout } from './coreContext-DMaWLvmB.js';
+
+/** Single segment in a dotted path (`a.b[0].c`). */
+type PathSegment = string | number;
+
+type CliErrorCode = 'CONFIG_INVALID' | 'CONFIG_MISSING' | 'IO' | 'VALIDATION' | 'TRANSLATE' | 'USAGE' | 'INTERNAL';
+type NormalizedCliError = {
+    code: CliErrorCode;
+    message: string;
+    cause?: unknown;
+};
+
+type SourceScanResult = {
+    files: string[];
+    text: string;
+};
+
+/** Output of `mask()`: MT input text + `{{...}}` originals in sentinel order. */
+type MaskedText = {
+    text: string;
+    originals: string[];
+};
+
+type ReadFlatLocaleJsonSurfaceResult = {
+    ok: true;
+    document: unknown;
+    leaves: TranslationSurfaceLeaf[];
+    text: string;
+    diagnostics: LocaleReadDiagnostic[];
+} | {
+    ok: false;
+    leaves: [];
+    diagnostics: LocaleReadDiagnostic[];
+};
+type ReadLocaleBundleResult = ReadFlatLocaleJsonSurfaceResult;
+
+type WriteFlatLocaleJsonDocumentResult = {
+    ok: true;
+    diagnostics: LocaleReadDiagnostic[];
+} | {
+    ok: false;
+    diagnostics: LocaleReadDiagnostic[];
+};
+
+/**
+ * Limits for uploaded project zip archives (worker ingest + web local preview).
+ * Share payload preparation (`buildProjectPayload`) uses the same caps.
+ */
+declare const PROJECT_UPLOAD_ZIP_LIMITS: {
+    readonly maxZipBytes: number;
+    readonly maxFiles: 15000;
+    readonly maxTextBytes: number;
+};
+declare const PROJECT_UPLOAD_MAX_ZIP_BYTES: number;
+declare const PROJECT_UPLOAD_MAX_FILES: 15000;
+declare const PROJECT_UPLOAD_MAX_TEXT_BYTES: number;
+/** Wire format version for `POST /v1/projects` prepared snapshot ingest. */
+declare const HOSTED_PROJECT_SNAPSHOT_SCHEMA_VERSION: 1;
+
+type WalkedJsonSegment = {
+    absolutePath: string;
+    relativePath: string;
+};
+
+/**
+ * One on-disk JSON segment that contributes to a logical locale (bundle root–relative paths).
+ *
+ * @remarks `relativePath` uses POSIX `/` separators. For `locale_file`, this is typically `en.json`;
+ * for `locale_per_dir`, `en/auth.json`; for `feature_bundle`, `auth/en.json`.
+ */
+type LocaleSegmentRef = {
+    /** BCP-47-ish locale code inferred from layout rules. */
+    locale: string;
+    /** Path relative to {@link ResolvedLocalesLayout.directoryAbsolute}. */
+    relativePath: string;
+    /** Absolute path to the segment JSON file. */
+    absolutePath: string;
+};
+type ListLocaleSegmentsResult = {
+    segments: LocaleSegmentRef[];
+    diagnostics: LocaleReadDiagnostic[];
+};
+type ListLocaleCodesResult = {
+    codes: string[];
+    diagnostics: LocaleReadDiagnostic[];
+};
+
+/** Normalized target selector for sync-style ops (`parseSyncLangSelection` return shape). */
+type SyncLangSelection = {
+    mode: 'all';
+} | {
+    mode: 'codes';
+    codes: string[];
+};
+
+type LocaleSegmentTarget = LocaleSegmentRef & {
+    /** Stable report key: segment `relativePath` (e.g. `en.json`, `en/auth.json`). */
+    reportKey: string;
+};
+type ResolveLocaleSegmentTargetsInput = {
+    selection: SyncLangSelection;
+};
+
+type LocaleLeafProjection = {
+    /**
+     * Leaf map keyed by canonical dotted paths (e.g. `routes.index.title`).
+     * When both dotted and nested representations exist for the same logical path,
+     * the nested representation wins.
+     */
+    byPath: Map<string, TranslationSurfaceLeaf>;
+    /** True when at least one object key contained a `.` segment. */
+    sawDottedKey: boolean;
+    /** Count of leaf conflicts where nested beat dotted. */
+    conflicts: number;
+};
+
+/** Role of a segment in a read/write plan. */
+type LocaleSegmentWriteRole = 'source' | 'target' | 'existing_target';
+/**
+ * One on-disk JSON segment under the configured locales directory.
+ *
+ * @remarks `relativePath` is bundle-root–relative (`en.json`, `en/auth.json`, `auth/en.json`).
+ */
+type LocaleSegmentWriteTarget = {
+    locale: string;
+    relativePath: string;
+    absolutePath: string;
+    role: LocaleSegmentWriteRole;
+};
+/** How generate (or future sync bootstrap) writes one logical target locale. */
+type LocaleSegmentWritePlan = {
+    targetLocale: string;
+    layout: ResolvedLocalesLayout;
+    /** Segments to read/write for this target (PR 1: one derived or one existing primary). */
+    segments: LocaleSegmentWriteTarget[];
+    /** Planned segments not yet on disk (subset of `segments`). */
+    missingSegments: LocaleSegmentWriteTarget[];
+};
+
+type SyncSegmentSourcePlan = {
+    sourceRelativePath: string;
+    sourceAbsolutePath: string;
+    sourceRaw: unknown;
+    effectiveSourceLeaves: TranslationSurfaceLeaf[];
+    template: unknown;
+    sourceMap: Map<string, string>;
+};
+
+export { type CliErrorCode as C, HOSTED_PROJECT_SNAPSHOT_SCHEMA_VERSION as H, type ListLocaleCodesResult as L, type MaskedText as M, type NormalizedCliError as N, type PathSegment as P, type ReadFlatLocaleJsonSurfaceResult as R, type SourceScanResult as S, type WalkedJsonSegment as W, type ListLocaleSegmentsResult as a, type LocaleLeafProjection as b, type LocaleSegmentRef as c, type LocaleSegmentTarget as d, type LocaleSegmentWritePlan as e, type LocaleSegmentWriteRole as f, type LocaleSegmentWriteTarget as g, type ReadLocaleBundleResult as h, type ResolveLocaleSegmentTargetsInput as i, type SyncLangSelection as j, type SyncSegmentSourcePlan as k, type WriteFlatLocaleJsonDocumentResult as l, PROJECT_UPLOAD_MAX_FILES as m, PROJECT_UPLOAD_MAX_TEXT_BYTES as n, PROJECT_UPLOAD_MAX_ZIP_BYTES as o, PROJECT_UPLOAD_ZIP_LIMITS as p };

package/dist/targets-EmtKyr6F.d.ts

@@ -0,0 +1,23 @@
+import { R as RuntimePathPort } from './path-Bfn3SAts.js';
+import { R as ResolveLocaleTargetCodesInput } from './localeTargetCodes-BBIQjauw.js';
+
+declare const ALL_LOCALES_TOKEN = "all";
+/** Comma-separated locale basenames, or `all` (case-insensitive). */
+declare function parseLocaleCodesList(raw: string): string[];
+declare function isAllLocaleToken(raw: string): boolean;
+/** Normalized target selector (single value, list, or `all`). */
+declare function pickTargetSelector(target?: string): string | undefined;
+/**
+ * `sync`: omit -> all non-source locales; `all` -> same; else comma-separated codes.
+ */
+declare function parseSyncLangSelection(lang: string | undefined): {
+    mode: 'all';
+} | {
+    mode: 'codes';
+    codes: string[];
+};
+declare function resolveTargetLocaleSlugs(path: RuntimePathPort, localeSlugs: string[], sourceLocalePath: string): string[];
+/** Pure target resolution with no prompting or CLI side effects. */
+declare function resolveLocaleTargetCodes(input: ResolveLocaleTargetCodesInput): string[];
+
+export { ALL_LOCALES_TOKEN as A, parseLocaleCodesList as a, pickTargetSelector as b, resolveTargetLocaleSlugs as c, isAllLocaleToken as i, parseSyncLangSelection as p, resolveLocaleTargetCodes as r };

package/dist/template-CGM-_WLT.d.ts

@@ -0,0 +1,139 @@
+import { I as Issue } from './index-X50E1FIX.js';
+import { R as RuntimeFsPort } from './fs-BUYD8ZhA.js';
+import { R as RuntimePathPort } from './path-Bfn3SAts.js';
+
+/** Curated starter bundles for **`i18nprune init --preset`**. */
+type InitPresetId = 'generic' | 'i18next' | 'lingui' | 'next-i18next' | 'next-intl' | 'react-intl';
+/** One explainable scoring dimension (library, topology, convention, …). */
+type InitScoreFactor = {
+    /** Stable machine id, e.g. **`npm.next-intl`**, **`dir.messages`**. */
+    id: string;
+    /** Contribution after weighting (non-negative). */
+    contribution: number;
+    /** Short human/SDK-facing note. */
+    detail: string;
+};
+/** A single preset’s aggregate score from weighted heuristics. */
+type InitPresetScore = {
+    preset: InitPresetId;
+    /** Sum of weighted contributions before conflict damping (0–1+). */
+    rawScore: number;
+    /** Score after conflict / ambiguity damping (0–1). */
+    score: number;
+    /** Normalized confidence for this preset (0–1). */
+    confidence: number;
+    factors: InitScoreFactor[];
+};
+/** Parsed **`package.json`** dependency maps (empty when file missing / invalid). */
+type InitPackageJsonSignals = {
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+};
+/** Confident `locales.mode` / `locales.structure` inferred from on-disk JSON segments. */
+type InitLocaleLayoutHint = {
+    mode: 'flat_file' | 'locale_directory';
+    structure: 'locale_file' | 'locale_per_dir' | 'feature_bundle';
+    /** Normalized confidence (1 when all segments agree). */
+    confidence: number;
+    /** Number of JSON segment files that contributed to the hint. */
+    segmentCount: number;
+};
+/** Filesystem hints under **`projectRoot`** (locale roots, framework markers). */
+type InitTopologySignals = {
+    /** Project-relative directory roots that exist and look like locale containers. */
+    localeRoots: string[];
+    /** True when **`next.config.js`**, **`.mjs`**, or **`.ts`** exists at project root. */
+    nextConfigPresent: boolean;
+};
+type InitProjectSignals = {
+    packageJson: InitPackageJsonSignals | null;
+    topology: InitTopologySignals;
+};
+type InitRunOptions = {
+    /**
+     * When true, pick a preset from scored heuristics (may refuse if ambiguous).
+     * Ignored when **`preset`** is set — explicit preset always wins.
+     */
+    auto?: boolean;
+    /** Force a specific preset id; overrides **`auto`**. */
+    preset?: string;
+    /** Same as CLI **`--rich`** — expanded starter template. */
+    rich?: boolean;
+    /** Module specifier for **`defineConfig`** (default **`i18nprune/core/config`**). */
+    importSpecifier?: string;
+};
+/**
+ * Host filesystem + path ports for **`runInit`** (no config load — **`projectRoot`** is absolute).
+ *
+ * @remarks Uses the same **`fs`** + **`path`** ports as project scanning; init never uses **`network`**.
+ */
+type InitFilesystemHost = {
+    fs: RuntimeFsPort;
+    path: RuntimePathPort;
+};
+/** Host input for **`runInit`** — filesystem ports plus absolute **`projectRoot`**. */
+type RunInitHostInput = InitFilesystemHost & {
+    /** Absolute project directory (the directory where a config file would be written). */
+    projectRoot: string;
+    /** When true, the host found an existing **`i18nprune.config.*`** — core skips template generation. */
+    skippedExistingConfig: boolean;
+};
+type InitJsonPayload = {
+    kind: 'init';
+    /** Payload contract version for **`--json`** stability. */
+    schemaVersion: 1;
+    /** Whether an on-disk config already exists — host supplies; no write attempted. */
+    skippedExistingConfig: boolean;
+    /** Resolved preset for the proposed template (after **`auto`** / **`preset`** rules). */
+    preset: InitPresetId;
+    /** Full config file contents the host may write (UTF-8 text). */
+    proposedConfigSource: string;
+    /** Relative filename only, e.g. **`i18nprune.config.ts`**. */
+    proposedConfigFileName: string;
+    /** Detection + scoring (omitted when **`skippedExistingConfig`**). */
+    detection?: {
+        signals: InitProjectSignals;
+        scores: InitPresetScore[];
+        ambiguous: boolean;
+        /** Present when segment paths under the preset `locales.directory` agree on one layout. */
+        localeLayout?: InitLocaleLayoutHint | null;
+    };
+};
+type InitRunResult = {
+    payload: InitJsonPayload;
+    issues: Issue[];
+    /** CLI exit code: **`0`** on success / benign skip; **`1`** on blocking issues. */
+    exitCode: number;
+};
+
+type InitDetectResult = {
+    signals: InitProjectSignals;
+    scores: InitPresetScore[];
+};
+
+/** Curated **`locales` / `src` / `functions`** defaults per preset. */
+type InitPresetConfigFields = {
+    locales: {
+        source: string;
+        directory: string;
+    };
+    src: string;
+    functions: string[];
+};
+
+type InitConfigFormat = 'ts' | 'mts' | 'js' | 'mjs';
+type BuildInitConfigTemplateOptions = {
+    /** Module specifier for **`defineConfig`** / **`I18nPruneConfig`** (default core config surface). */
+    importSpecifier?: string;
+    /** When true, include every supported top-level namespace with safe defaults (starting point for customization). */
+    rich?: boolean;
+    /**
+     * Curated starter bundle — seeds **`locales.source`**, **`locales.directory`**, **`src`**, and **`functions`**.
+     * Defaults to **`generic`**.
+     */
+    preset?: InitPresetId;
+    /** When set, emitted into the `locales` block (from on-disk segment classification). */
+    localeLayout?: InitLocaleLayoutHint | null;
+};
+
+export type { BuildInitConfigTemplateOptions as B, InitConfigFormat as I, RunInitHostInput as R, InitRunOptions as a, InitRunResult as b, InitPackageJsonSignals as c, InitFilesystemHost as d, InitTopologySignals as e, InitLocaleLayoutHint as f, InitPresetScore as g, InitPresetId as h, InitProjectSignals as i, InitDetectResult as j, InitPresetConfigFields as k, InitJsonPayload as l, InitScoreFactor as m };

package/dist/translate-CIHYp7wi.d.ts

@@ -0,0 +1,77 @@
+import { I as Issue } from './index-X50E1FIX.js';
+import { T as TranslationProviderId } from './providers-0uMEfT6q.js';
+import { T as TranslatePolicy } from './root-2-kCaBvQ.js';
+
+type TranslateStartRateLimit = {
+    /** Requests per minute ceiling. */
+    rpm?: number;
+    /** Requests per second ceiling (supports fractions like 0.5). */
+    rps?: number;
+    /** Hard minimum spacing between request starts. */
+    intervalMs?: number;
+};
+type ProviderRateLimitProfile = Required<TranslateStartRateLimit> & {
+    maxConcurrency: number;
+};
+type ProviderRateLimitRegistry = Readonly<Record<TranslationProviderId, ProviderRateLimitProfile>>;
+
+type TranslateRateLimitConfigInput = {
+    maxConcurrency?: number;
+    rpm?: number;
+    rps?: number;
+    intervalMs?: number;
+};
+type TranslateProviderRowInputBase = {
+    enabled?: boolean;
+    rateLimit?: TranslateRateLimitConfigInput;
+};
+type TranslateProviderRowInputGoogle = TranslateProviderRowInputBase & {
+    id: 'google';
+};
+type TranslateProviderRowInputMymemory = TranslateProviderRowInputBase & {
+    id: 'mymemory';
+    contactEmail?: string;
+};
+type TranslateProviderRowInputLibre = TranslateProviderRowInputBase & {
+    id: 'libre';
+    baseUrl?: string;
+};
+type TranslateProviderRowInputDeepl = TranslateProviderRowInputBase & {
+    id: 'deepl';
+    apiKey?: string;
+};
+type TranslateProviderRowInputLlm = TranslateProviderRowInputBase & {
+    id: 'llm';
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+};
+type TranslateProviderRowInput = TranslateProviderRowInputGoogle | TranslateProviderRowInputMymemory | TranslateProviderRowInputLibre | TranslateProviderRowInputDeepl | TranslateProviderRowInputLlm;
+/**
+ * Authoring shape (input) for the translate-policy block — the same surface SDK consumers
+ * pass through `defineConfig`. Re-export of {@link TranslatePolicy} so the config-input
+ * barrel under `types/config/` carries the full verb dictionary.
+ */
+type TranslatePolicyConfigInput = TranslatePolicy;
+type TranslateConfigInput = {
+    primary?: TranslationProviderId;
+    providers?: TranslateProviderRowInput[];
+    policy?: TranslatePolicyConfigInput;
+    workers?: number;
+};
+type ResolvedTranslateProviderRow = {
+    id: TranslationProviderId;
+    profile: ProviderRateLimitProfile;
+    startRateLimit?: TranslateStartRateLimit;
+};
+type ResolvedTranslateConfig = {
+    providerOrder: TranslationProviderId[];
+    effectiveProviderId: TranslationProviderId;
+    requestedWorkers: number;
+    effectiveWorkers: number;
+    providers: Record<TranslationProviderId, ResolvedTranslateProviderRow>;
+    routing: 'single' | 'auto';
+};
+type ResolveTranslateWarning = Issue;
+
+export type { ProviderRateLimitProfile as P, ResolvedTranslateConfig as R, TranslateConfigInput as T, TranslateStartRateLimit as a, ResolveTranslateWarning as b, ResolvedTranslateProviderRow as c, TranslatePolicyConfigInput as d, TranslateProviderRowInput as e, TranslateRateLimitConfigInput as f, ProviderRateLimitRegistry as g };

package/dist/types/shared.d.ts

@@ -0,0 +1,21 @@
+export { C as CleanupCounts, D as DoctorCounts, G as GenerateCounts, j as GeneratePhase, k as GenerateProgressEvent, l as LocalesDynamicCounts, M as MissingCounts, O as OperationId, P as ProgressEvent, Q as QualityCounts, m as ReportCounts, n as ReviewCounts, o as RunCompletedEvent, p as RunCountsByOperation, R as RunEmitter, q as RunErrorEvent, a as RunEvent, r as RunEventBase, s as RunFailedEvent, t as RunMessageChannel, u as RunMessageEvent, v as RunMessageLevel, w as RunShareLinksEvent, x as RunShareManifestEvent, y as RunShareSkippedEvent, z as RunShareUploadedEvent, A as RunStartedEvent, B as RunSummaryEvent, E as RunWarningEvent, F as ShareCounts, I as SyncCounts, J as SyncPhase, S as SyncProgressEvent, V as ValidateCounts, K as ValidatePhase, N as ValidateProgressEvent } from '../index-BgG01AKL.js';
+import '../index-X50E1FIX.js';
+import '../providers-0uMEfT6q.js';
+
+/**
+ * Precomputed scan-exclusion rules for {@link listSourceFiles} / {@link compileScanExclude}
+ * in **`shared/scanner/files.ts`** (built once per walk; hot path uses **`Set`** + small arrays).
+ */
+type CompiledScanExclude = {
+    defaultDirs: ReadonlySet<string> | null;
+    dirStrings: Set<string>;
+    dirRegexes: RegExp[];
+    fileStrings: Set<string>;
+    fileRegexes: RegExp[];
+    extStrings: Set<string>;
+    extRegexes: RegExp[];
+    pathPatterns: RegExp[];
+    userRulesEmpty: boolean;
+};
+
+export type { CompiledScanExclude };

package/dist/types/shared.js

@@ -0,0 +1 @@
+