@linguanahq/catalog 0.1.0 → 0.1.2

package/dist/context.d.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+export declare const contextProfileSchema: z.ZodObject<{
+    product: z.ZodDefault<z.ZodString>;
+    audience: z.ZodDefault<z.ZodString>;
+    tone: z.ZodDefault<z.ZodString>;
+    formality: z.ZodDefault<z.ZodEnum<{
+        neutral: "neutral";
+        formal: "formal";
+        informal: "informal";
+    }>>;
+    preferred: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    discouraged: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    conventions: z.ZodDefault<z.ZodString>;
+    localeOverrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        product: z.ZodOptional<z.ZodString>;
+        audience: z.ZodOptional<z.ZodString>;
+        tone: z.ZodOptional<z.ZodString>;
+        formality: z.ZodOptional<z.ZodEnum<{
+            neutral: "neutral";
+            formal: "formal";
+            informal: "informal";
+        }>>;
+        preferred: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        discouraged: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        conventions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    glossary: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"active">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"pinned">;
+        versionId: z.ZodString;
+    }, z.core.$strip>], "mode">>;
+}, z.core.$strip>;
+export type ContextProfileContent = z.infer<typeof contextProfileSchema>;
+export declare function resolveContextProfile(content: ContextProfileContent, locale: string): {
+    product: string;
+    audience: string;
+    tone: string;
+    formality: "neutral" | "formal" | "informal";
+    preferred: string[];
+    discouraged: string[];
+    conventions: string;
+};
+export declare const meaningSchema: z.ZodString;
+export declare const runtimeItemSchema: z.ZodObject<{
+    source: z.ZodString;
+    format: z.ZodDefault<z.ZodEnum<{
+        plain: "plain";
+        icu: "icu";
+    }>>;
+    meaning: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type RuntimeItem = z.infer<typeof runtimeItemSchema>;
+export declare const runtimeBatchSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    environment: z.ZodString;
+    surface: z.ZodString;
+    sourceLocale: z.ZodString;
+    locale: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        format: z.ZodDefault<z.ZodEnum<{
+            plain: "plain";
+            icu: "icu";
+        }>>;
+        meaning: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RuntimeBatchInput = z.infer<typeof runtimeBatchSchema>;
+export declare function runtimeContentKey(input: {
+    sourceLocale: string;
+    surface: string;
+} & RuntimeItem): string;

package/dist/icu-validation.d.ts

@@ -0,0 +1,2 @@
+/** Compare semantic requirements, not translated branch prose or locale-specific categories. */
+export declare function validateIcuSemantics(source: string, target: string, targetLocale?: string): string[];

package/dist/index.d.ts

@@ -0,0 +1,209 @@
+import { z } from "zod";
+export declare const SCHEMA_VERSION: "1.0";
+export declare const MANIFEST_SCHEMA_VERSION: "2.0";
+export declare const messageLocationSchema: z.ZodObject<{
+    file: z.ZodString;
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+}, z.core.$strip>;
+export declare const placeholderSchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        number: "number";
+        value: "value";
+        component: "component";
+        plural: "plural";
+        select: "select";
+        date: "date";
+        time: "time";
+    }>;
+}, z.core.$strip>;
+export declare const messageContextSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        text: "text";
+        attribute: "attribute";
+        explicit: "explicit";
+    }>;
+    element: z.ZodOptional<z.ZodString>;
+    attribute: z.ZodOptional<z.ZodString>;
+    developer: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const manifestMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    normalized: z.ZodString;
+    contentHash: z.ZodString;
+    context: z.ZodObject<{
+        kind: z.ZodEnum<{
+            text: "text";
+            attribute: "attribute";
+            explicit: "explicit";
+        }>;
+        element: z.ZodOptional<z.ZodString>;
+        attribute: z.ZodOptional<z.ZodString>;
+        developer: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    placeholders: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            number: "number";
+            value: "value";
+            component: "component";
+            plural: "plural";
+            select: "select";
+            date: "date";
+            time: "time";
+        }>;
+    }, z.core.$strip>>>;
+    confidence: z.ZodEnum<{
+        explicit: "explicit";
+        high: "high";
+    }>;
+    locations: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const diagnosticSchema: z.ZodObject<{
+    code: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>;
+    message: z.ZodString;
+    location: z.ZodOptional<z.ZodObject<{
+        file: z.ZodString;
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, z.core.$strip>>;
+    remediation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const manifestIntegrationSchema: z.ZodObject<{
+    tool: z.ZodEnum<{
+        vite: "vite";
+        next: "next";
+    }>;
+    toolVersion: z.ZodString;
+    framework: z.ZodEnum<{
+        react: "react";
+        vue: "vue";
+        svelte: "svelte";
+        solid: "solid";
+    }>;
+    adapterVersion: z.ZodString;
+    ssr: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const manifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodEnum<{
+        "1.0": "1.0";
+        "2.0": "2.0";
+    }>;
+    compilerVersion: z.ZodString;
+    projectId: z.ZodString;
+    environment: z.ZodString;
+    sourceLocale: z.ZodString;
+    sourceRevision: z.ZodOptional<z.ZodString>;
+    integration: z.ZodOptional<z.ZodObject<{
+        tool: z.ZodEnum<{
+            vite: "vite";
+            next: "next";
+        }>;
+        toolVersion: z.ZodString;
+        framework: z.ZodEnum<{
+            react: "react";
+            vue: "vue";
+            svelte: "svelte";
+            solid: "solid";
+        }>;
+        adapterVersion: z.ZodString;
+        ssr: z.ZodBoolean;
+    }, z.core.$strip>>;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        normalized: z.ZodString;
+        contentHash: z.ZodString;
+        context: z.ZodObject<{
+            kind: z.ZodEnum<{
+                text: "text";
+                attribute: "attribute";
+                explicit: "explicit";
+            }>;
+            element: z.ZodOptional<z.ZodString>;
+            attribute: z.ZodOptional<z.ZodString>;
+            developer: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        placeholders: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                number: "number";
+                value: "value";
+                component: "component";
+                plural: "plural";
+                select: "select";
+                date: "date";
+                time: "time";
+            }>;
+        }, z.core.$strip>>>;
+        confidence: z.ZodEnum<{
+            explicit: "explicit";
+            high: "high";
+        }>;
+        locations: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        message: z.ZodString;
+        location: z.ZodOptional<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, z.core.$strip>>;
+        remediation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const catalogSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    projectId: z.ZodString;
+    environment: z.ZodString;
+    sourceLocale: z.ZodString;
+    locale: z.ZodString;
+    manifestHash: z.ZodString;
+    version: z.ZodNumber;
+    messages: z.ZodRecord<z.ZodString, z.ZodString>;
+    integrity: z.ZodString;
+}, z.core.$strip>;
+export type MessageLocation = z.infer<typeof messageLocationSchema>;
+export type Placeholder = z.infer<typeof placeholderSchema>;
+export type MessageContext = z.infer<typeof messageContextSchema>;
+export type ManifestMessage = z.infer<typeof manifestMessageSchema>;
+export type Diagnostic = z.infer<typeof diagnosticSchema>;
+export type Manifest = z.infer<typeof manifestSchema>;
+export type ManifestIntegration = z.infer<typeof manifestIntegrationSchema>;
+export type Catalog = z.infer<typeof catalogSchema>;
+export declare function canonicalJson(value: unknown): string;
+export declare function contentHash(value: unknown): string;
+export declare function normalizeSource(source: string): string;
+export declare function parseMessagePlaceholders(source: string): Placeholder[];
+export declare function stableMessageId(input: {
+    sourceLocale: string;
+    source: string;
+    context: MessageContext;
+    explicitId?: string;
+}): string;
+export declare function manifestHash(manifest: Manifest): string;
+export declare function createCatalog(input: Omit<Catalog, "integrity">): Catalog;
+export declare function verifyCatalog(catalog: Catalog): boolean;
+export * from "./context.ts";
+export * from "./icu-validation.ts";

package/dist/index.js

@@ -0,0 +1,356 @@
+// src/index.ts
+import {
+  parse as parse2,
+  TYPE as TYPE2
+} from "@formatjs/icu-messageformat-parser";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
+import { z as z2 } from "zod";
+
+// src/context.ts
+import { z } from "zod";
+var guidance = z.object({
+  product: z.string().max(2e3).default(""),
+  audience: z.string().max(1e3).default(""),
+  tone: z.string().max(1e3).default(""),
+  formality: z.enum(["neutral", "formal", "informal"]).default("neutral"),
+  preferred: z.array(z.string().max(512)).max(20).default([]),
+  discouraged: z.array(z.string().max(512)).max(20).default([]),
+  conventions: z.string().max(2e3).default("")
+});
+var contextProfileSchema = guidance.extend({
+  localeOverrides: z.record(
+    z.string(),
+    z.object({
+      product: guidance.shape.product.removeDefault().optional(),
+      audience: guidance.shape.audience.removeDefault().optional(),
+      tone: guidance.shape.tone.removeDefault().optional(),
+      formality: guidance.shape.formality.removeDefault().optional(),
+      preferred: guidance.shape.preferred.removeDefault().optional(),
+      discouraged: guidance.shape.discouraged.removeDefault().optional(),
+      conventions: guidance.shape.conventions.removeDefault().optional()
+    })
+  ).default({}),
+  glossary: z.discriminatedUnion("mode", [
+    z.object({ mode: z.literal("active") }),
+    z.object({ mode: z.literal("pinned"), versionId: z.string().min(1) })
+  ]).default({ mode: "active" })
+}).superRefine((value, ctx) => {
+  if (new TextEncoder().encode(canonicalJson(value)).byteLength > 16 * 1024)
+    ctx.addIssue({
+      code: "custom",
+      message: "Context profile exceeds 16 KiB"
+    });
+  for (const locale of Object.keys(value.localeOverrides)) {
+    try {
+      if (Intl.getCanonicalLocales(locale)[0] !== locale) throw new Error();
+    } catch {
+      ctx.addIssue({
+        code: "custom",
+        message: `Use a canonical locale tag: ${locale}`
+      });
+    }
+  }
+});
+function resolveContextProfile(content, locale) {
+  const { localeOverrides, glossary: _glossary, ...base } = content;
+  const canonical = Intl.getCanonicalLocales(locale)[0];
+  return {
+    ...base,
+    ...localeOverrides[canonical] ?? localeOverrides[canonical.split("-")[0]] ?? {}
+  };
+}
+var meaningSchema = z.string().refine(
+  (value) => [...value].length <= 512,
+  "Meaning exceeds 512 code points"
+);
+var runtimeItemSchema = z.object({
+  source: z.string().min(1),
+  format: z.enum(["plain", "icu"]).default("plain"),
+  meaning: meaningSchema.default("")
+});
+var runtimeBatchSchema = z.object({
+  projectId: z.string().min(1),
+  environment: z.string().min(1),
+  surface: z.string().min(1),
+  sourceLocale: z.string().min(2),
+  locale: z.string().min(2),
+  items: z.array(runtimeItemSchema).min(1).max(50)
+}).superRefine((value, ctx) => {
+  if (value.items.reduce((n, item) => n + [...item.source].length, 0) > 12e3)
+    ctx.addIssue({
+      code: "custom",
+      message: "Batch exceeds 12000 source code points"
+    });
+  if (new TextEncoder().encode(JSON.stringify(value)).byteLength > 256 * 1024)
+    ctx.addIssue({ code: "custom", message: "Batch exceeds 256 KiB" });
+});
+function runtimeContentKey(input) {
+  return contentHash({
+    normalizationVersion: 1,
+    sourceLocale: Intl.getCanonicalLocales(input.sourceLocale)[0],
+    surface: input.surface,
+    source: input.source.replace(/\r\n?/g, "\n").normalize("NFC"),
+    format: input.format,
+    meaning: input.meaning
+  });
+}
+
+// src/icu-validation.ts
+import {
+  parse,
+  TYPE
+} from "@formatjs/icu-messageformat-parser";
+function validateIcuSemantics(source, target, targetLocale) {
+  const issues = [];
+  function requirements(text, validateLocale) {
+    const entries = /* @__PURE__ */ new Set();
+    function visit(elements) {
+      for (const e of elements) {
+        if (e.type === TYPE.literal || e.type === TYPE.pound) continue;
+        const requirement = {
+          name: e.value,
+          type: e.type
+        };
+        if (e.type === TYPE.plural || e.type === TYPE.select) {
+          if (!("other" in e.options)) issues.push("ICU_OTHER_REQUIRED");
+          if (e.type === TYPE.plural) {
+            requirement.pluralType = e.pluralType;
+            requirement.offset = e.offset;
+            requirement.exact = Object.keys(e.options).filter((k) => k.startsWith("=")).sort();
+            if (validateLocale && targetLocale) {
+              const allowed = new Set(
+                new Intl.PluralRules(targetLocale, {
+                  type: e.pluralType
+                }).resolvedOptions().pluralCategories
+              );
+              for (const key of Object.keys(e.options))
+                if (!key.startsWith("=") && !allowed.has(key))
+                  issues.push("INVALID_PLURAL_CATEGORY");
+            }
+          } else requirement.selectors = Object.keys(e.options).sort();
+          for (const option of Object.values(e.options)) visit(option.value);
+        }
+        if (e.type === TYPE.number) {
+          requirement.style = typeof e.style === "object" && e.style ? e.style.tokens : e.style;
+        }
+        if (e.type === TYPE.tag) visit(e.children);
+        entries.add(canonicalJson(requirement));
+      }
+    }
+    visit(
+      parse(text, {
+        captureLocation: false,
+        ignoreTag: false,
+        requiresOtherClause: true
+      })
+    );
+    return [...entries].sort();
+  }
+  const left = requirements(source, false);
+  const right = requirements(target, true);
+  if (canonicalJson(left) !== canonicalJson(right))
+    issues.push("ICU_SEMANTICS_CHANGED");
+  return [...new Set(issues)];
+}
+
+// src/index.ts
+var SCHEMA_VERSION = "1.0";
+var MANIFEST_SCHEMA_VERSION = "2.0";
+var messageLocationSchema = z2.object({
+  file: z2.string().min(1),
+  line: z2.number().int().positive(),
+  column: z2.number().int().nonnegative()
+});
+var placeholderSchema = z2.object({
+  name: z2.string().min(1),
+  kind: z2.enum([
+    "value",
+    "component",
+    "plural",
+    "select",
+    "number",
+    "date",
+    "time"
+  ])
+});
+var messageContextSchema = z2.object({
+  kind: z2.enum(["text", "attribute", "explicit"]),
+  element: z2.string().optional(),
+  attribute: z2.string().optional(),
+  developer: z2.string().optional()
+});
+var manifestMessageSchema = z2.object({
+  id: z2.string().min(1),
+  source: z2.string().min(1),
+  normalized: z2.string().min(1),
+  contentHash: z2.string().length(64),
+  context: messageContextSchema,
+  placeholders: z2.array(placeholderSchema).default([]),
+  confidence: z2.enum(["high", "explicit"]),
+  locations: z2.array(messageLocationSchema).min(1)
+});
+var diagnosticSchema = z2.object({
+  code: z2.string().min(1),
+  severity: z2.enum(["info", "warning", "error"]),
+  message: z2.string().min(1),
+  location: messageLocationSchema.optional(),
+  remediation: z2.string().optional()
+});
+var manifestIntegrationSchema = z2.object({
+  tool: z2.enum(["vite", "next"]),
+  toolVersion: z2.string().min(1),
+  framework: z2.enum(["react", "vue", "svelte", "solid"]),
+  adapterVersion: z2.string().min(1),
+  ssr: z2.boolean()
+});
+var manifestSchema = z2.object({
+  schemaVersion: z2.enum([SCHEMA_VERSION, MANIFEST_SCHEMA_VERSION]),
+  compilerVersion: z2.string().min(1),
+  projectId: z2.string().min(1),
+  environment: z2.string().min(1),
+  sourceLocale: z2.string().min(2),
+  sourceRevision: z2.string().optional(),
+  integration: manifestIntegrationSchema.optional(),
+  messages: z2.array(manifestMessageSchema),
+  diagnostics: z2.array(diagnosticSchema).default([])
+}).superRefine((manifest, context) => {
+  if (manifest.schemaVersion === MANIFEST_SCHEMA_VERSION && !manifest.integration) {
+    context.addIssue({
+      code: "custom",
+      path: ["integration"],
+      message: "Manifest schema 2.0 requires integration metadata."
+    });
+  }
+});
+var catalogSchema = z2.object({
+  schemaVersion: z2.literal(SCHEMA_VERSION),
+  projectId: z2.string().min(1),
+  environment: z2.string().min(1),
+  sourceLocale: z2.string().min(2),
+  locale: z2.string().min(2),
+  manifestHash: z2.string().length(64),
+  version: z2.number().int().positive(),
+  messages: z2.record(z2.string(), z2.string()),
+  integrity: z2.string().length(64)
+});
+function sortValue(value) {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, sortValue(item)])
+    );
+  }
+  return value;
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortValue(value));
+}
+function contentHash(value) {
+  const input = typeof value === "string" ? value : canonicalJson(value);
+  return bytesToHex(sha256(utf8ToBytes(input)));
+}
+function normalizeSource(source) {
+  return source.replace(/\s+/g, " ").trim();
+}
+function parseMessagePlaceholders(source) {
+  const descriptors = /* @__PURE__ */ new Map();
+  const priority = {
+    value: 0,
+    number: 1,
+    date: 1,
+    time: 1,
+    select: 2,
+    plural: 3,
+    component: 4
+  };
+  const add = (name, kind) => {
+    const existing = descriptors.get(name);
+    if (!existing || priority[kind] > priority[existing.kind])
+      descriptors.set(name, { name, kind });
+  };
+  const visit = (elements) => {
+    for (const element of elements) {
+      switch (element.type) {
+        case TYPE2.argument:
+          add(element.value, "value");
+          break;
+        case TYPE2.number:
+          add(element.value, "number");
+          break;
+        case TYPE2.date:
+          add(element.value, "date");
+          break;
+        case TYPE2.time:
+          add(element.value, "time");
+          break;
+        case TYPE2.select:
+          add(element.value, "select");
+          for (const option of Object.values(element.options))
+            visit(option.value);
+          break;
+        case TYPE2.plural:
+          add(element.value, "plural");
+          for (const option of Object.values(element.options))
+            visit(option.value);
+          break;
+        case TYPE2.tag:
+          add(element.value, "component");
+          visit(element.children);
+          break;
+      }
+    }
+  };
+  visit(parse2(source, { captureLocation: false, ignoreTag: false }));
+  return [...descriptors.values()].sort(
+    (left, right) => left.name.localeCompare(right.name)
+  );
+}
+function stableMessageId(input) {
+  if (input.explicitId) return input.explicitId;
+  const descriptor = {
+    version: 1,
+    sourceLocale: input.sourceLocale,
+    source: normalizeSource(input.source),
+    context: input.context
+  };
+  return `lna_${contentHash(descriptor).slice(0, 24)}`;
+}
+function manifestHash(manifest) {
+  return contentHash(manifestSchema.parse(manifest));
+}
+function createCatalog(input) {
+  const integrity = contentHash(input);
+  return catalogSchema.parse({ ...input, integrity });
+}
+function verifyCatalog(catalog) {
+  const { integrity, ...payload } = catalogSchema.parse(catalog);
+  return contentHash(payload) === integrity;
+}
+export {
+  MANIFEST_SCHEMA_VERSION,
+  SCHEMA_VERSION,
+  canonicalJson,
+  catalogSchema,
+  contentHash,
+  contextProfileSchema,
+  createCatalog,
+  diagnosticSchema,
+  manifestHash,
+  manifestIntegrationSchema,
+  manifestMessageSchema,
+  manifestSchema,
+  meaningSchema,
+  messageContextSchema,
+  messageLocationSchema,
+  normalizeSource,
+  parseMessagePlaceholders,
+  placeholderSchema,
+  resolveContextProfile,
+  runtimeBatchSchema,
+  runtimeContentKey,
+  runtimeItemSchema,
+  stableMessageId,
+  validateIcuSemantics,
+  verifyCatalog
+};

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,25 +1,27 @@
 {
-	"name": "@linguanahq/catalog",
-	"version": "0.1.0",
-	"publishConfig": {
-		"access": "public"
-	},
-	"type": "module",
-	"exports": {
-		".": "./src/index.ts"
-	},
-	"scripts": {
-		"check-types": "tsc --noEmit",
-		"test": "bun test"
-	},
-	"dependencies": {
-		"@formatjs/icu-messageformat-parser": "^2.11.4",
-		"@noble/hashes": "^2.0.1",
-		"zod": "^4.4.3"
-	},
-	"devDependencies": {
-		"@linguana/config": "0.0.0",
-		"@types/bun": "^1.3.14",
-		"typescript": "^6"
-	}
+  "name": "@linguanahq/catalog",
+  "version": "0.1.2",
+  "type": "module",
+  "description": "Linguana catalog integration",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "dependencies": {
+    "@formatjs/icu-messageformat-parser": "^2.11.4",
+    "@noble/hashes": "^2.0.1",
+    "zod": "^4.4.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/src/index.ts

@@ -1,219 +0,0 @@
-import {
-	type MessageFormatElement,
-	parse,
-	TYPE,
-} from "@formatjs/icu-messageformat-parser";
-import { sha256 } from "@noble/hashes/sha2.js";
-import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
-import { z } from "zod";
-
-export const SCHEMA_VERSION = "1.0" as const;
-export const MANIFEST_SCHEMA_VERSION = "2.0" as const;
-
-export const messageLocationSchema = z.object({
-	file: z.string().min(1),
-	line: z.number().int().positive(),
-	column: z.number().int().nonnegative(),
-});
-
-export const placeholderSchema = z.object({
-	name: z.string().min(1),
-	kind: z.enum([
-		"value",
-		"component",
-		"plural",
-		"select",
-		"number",
-		"date",
-		"time",
-	]),
-});
-
-export const messageContextSchema = z.object({
-	kind: z.enum(["text", "attribute", "explicit"]),
-	element: z.string().optional(),
-	attribute: z.string().optional(),
-	developer: z.string().optional(),
-});
-
-export const manifestMessageSchema = z.object({
-	id: z.string().min(1),
-	source: z.string().min(1),
-	normalized: z.string().min(1),
-	contentHash: z.string().length(64),
-	context: messageContextSchema,
-	placeholders: z.array(placeholderSchema).default([]),
-	confidence: z.enum(["high", "explicit"]),
-	locations: z.array(messageLocationSchema).min(1),
-});
-
-export const diagnosticSchema = z.object({
-	code: z.string().min(1),
-	severity: z.enum(["info", "warning", "error"]),
-	message: z.string().min(1),
-	location: messageLocationSchema.optional(),
-	remediation: z.string().optional(),
-});
-
-export const manifestIntegrationSchema = z.object({
-	tool: z.literal("vite"),
-	toolVersion: z.string().min(1),
-	framework: z.enum(["react", "vue", "svelte", "solid"]),
-	adapterVersion: z.string().min(1),
-	ssr: z.boolean(),
-});
-
-export const manifestSchema = z
-	.object({
-		schemaVersion: z.enum([SCHEMA_VERSION, MANIFEST_SCHEMA_VERSION]),
-		compilerVersion: z.string().min(1),
-		projectId: z.string().min(1),
-		environment: z.string().min(1),
-		sourceLocale: z.string().min(2),
-		sourceRevision: z.string().optional(),
-		integration: manifestIntegrationSchema.optional(),
-		messages: z.array(manifestMessageSchema),
-		diagnostics: z.array(diagnosticSchema).default([]),
-	})
-	.superRefine((manifest, context) => {
-		if (
-			manifest.schemaVersion === MANIFEST_SCHEMA_VERSION &&
-			!manifest.integration
-		) {
-			context.addIssue({
-				code: "custom",
-				path: ["integration"],
-				message: "Manifest schema 2.0 requires integration metadata.",
-			});
-		}
-	});
-
-export const catalogSchema = z.object({
-	schemaVersion: z.literal(SCHEMA_VERSION),
-	projectId: z.string().min(1),
-	environment: z.string().min(1),
-	sourceLocale: z.string().min(2),
-	locale: z.string().min(2),
-	manifestHash: z.string().length(64),
-	version: z.number().int().positive(),
-	messages: z.record(z.string(), z.string()),
-	integrity: z.string().length(64),
-});
-
-export type MessageLocation = z.infer<typeof messageLocationSchema>;
-export type Placeholder = z.infer<typeof placeholderSchema>;
-export type MessageContext = z.infer<typeof messageContextSchema>;
-export type ManifestMessage = z.infer<typeof manifestMessageSchema>;
-export type Diagnostic = z.infer<typeof diagnosticSchema>;
-export type Manifest = z.infer<typeof manifestSchema>;
-export type ManifestIntegration = z.infer<typeof manifestIntegrationSchema>;
-export type Catalog = z.infer<typeof catalogSchema>;
-
-function sortValue(value: unknown): unknown {
-	if (Array.isArray(value)) return value.map(sortValue);
-	if (value && typeof value === "object") {
-		return Object.fromEntries(
-			Object.entries(value)
-				.sort(([left], [right]) => left.localeCompare(right))
-				.map(([key, item]) => [key, sortValue(item)]),
-		);
-	}
-	return value;
-}
-
-export function canonicalJson(value: unknown): string {
-	return JSON.stringify(sortValue(value));
-}
-
-export function contentHash(value: unknown): string {
-	const input = typeof value === "string" ? value : canonicalJson(value);
-	return bytesToHex(sha256(utf8ToBytes(input)));
-}
-
-export function normalizeSource(source: string): string {
-	return source.replace(/\s+/g, " ").trim();
-}
-
-export function parseMessagePlaceholders(source: string): Placeholder[] {
-	const descriptors = new Map<string, Placeholder>();
-	const priority: Record<Placeholder["kind"], number> = {
-		value: 0,
-		number: 1,
-		date: 1,
-		time: 1,
-		select: 2,
-		plural: 3,
-		component: 4,
-	};
-	const add = (name: string, kind: Placeholder["kind"]) => {
-		const existing = descriptors.get(name);
-		if (!existing || priority[kind] > priority[existing.kind])
-			descriptors.set(name, { name, kind });
-	};
-	const visit = (elements: MessageFormatElement[]) => {
-		for (const element of elements) {
-			switch (element.type) {
-				case TYPE.argument:
-					add(element.value, "value");
-					break;
-				case TYPE.number:
-					add(element.value, "number");
-					break;
-				case TYPE.date:
-					add(element.value, "date");
-					break;
-				case TYPE.time:
-					add(element.value, "time");
-					break;
-				case TYPE.select:
-					add(element.value, "select");
-					for (const option of Object.values(element.options))
-						visit(option.value);
-					break;
-				case TYPE.plural:
-					add(element.value, "plural");
-					for (const option of Object.values(element.options))
-						visit(option.value);
-					break;
-				case TYPE.tag:
-					add(element.value, "component");
-					visit(element.children);
-					break;
-			}
-		}
-	};
-	visit(parse(source, { captureLocation: false, ignoreTag: false }));
-	return [...descriptors.values()].sort((left, right) =>
-		left.name.localeCompare(right.name),
-	);
-}
-
-export function stableMessageId(input: {
-	sourceLocale: string;
-	source: string;
-	context: MessageContext;
-	explicitId?: string;
-}): string {
-	if (input.explicitId) return input.explicitId;
-	const descriptor = {
-		version: 1,
-		sourceLocale: input.sourceLocale,
-		source: normalizeSource(input.source),
-		context: input.context,
-	};
-	return `lna_${contentHash(descriptor).slice(0, 24)}`;
-}
-
-export function manifestHash(manifest: Manifest): string {
-	return contentHash(manifestSchema.parse(manifest));
-}
-
-export function createCatalog(input: Omit<Catalog, "integrity">): Catalog {
-	const integrity = contentHash(input);
-	return catalogSchema.parse({ ...input, integrity });
-}
-
-export function verifyCatalog(catalog: Catalog): boolean {
-	const { integrity, ...payload } = catalogSchema.parse(catalog);
-	return contentHash(payload) === integrity;
-}