@linguanahq/catalog 0.1.1 → 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

@@ -81,7 +81,10 @@ export declare const diagnosticSchema: z.ZodObject<{
     remediation: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const manifestIntegrationSchema: z.ZodObject<{
-    tool: z.ZodLiteral<"vite">;
+    tool: z.ZodEnum<{
+        vite: "vite";
+        next: "next";
+    }>;
     toolVersion: z.ZodString;
     framework: z.ZodEnum<{
         react: "react";
@@ -103,7 +106,10 @@ export declare const manifestSchema: z.ZodObject<{
     sourceLocale: z.ZodString;
     sourceRevision: z.ZodOptional<z.ZodString>;
     integration: z.ZodOptional<z.ZodObject<{
-        tool: z.ZodLiteral<"vite">;
+        tool: z.ZodEnum<{
+            vite: "vite";
+            next: "next";
+        }>;
         toolVersion: z.ZodString;
         framework: z.ZodEnum<{
             react: "react";
@@ -199,3 +205,5 @@ export declare function stableMessageId(input: {
 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

@@ -1,21 +1,170 @@
 // src/index.ts
 import {
-  parse,
-  TYPE
+  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 = z.object({
-  file: z.string().min(1),
-  line: z.number().int().positive(),
-  column: z.number().int().nonnegative()
+var messageLocationSchema = z2.object({
+  file: z2.string().min(1),
+  line: z2.number().int().positive(),
+  column: z2.number().int().nonnegative()
 });
-var placeholderSchema = z.object({
-  name: z.string().min(1),
-  kind: z.enum([
+var placeholderSchema = z2.object({
+  name: z2.string().min(1),
+  kind: z2.enum([
     "value",
     "component",
     "plural",
@@ -25,46 +174,46 @@ var placeholderSchema = z.object({
     "time"
   ])
 });
-var messageContextSchema = z.object({
-  kind: z.enum(["text", "attribute", "explicit"]),
-  element: z.string().optional(),
-  attribute: z.string().optional(),
-  developer: z.string().optional()
+var messageContextSchema = z2.object({
+  kind: z2.enum(["text", "attribute", "explicit"]),
+  element: z2.string().optional(),
+  attribute: z2.string().optional(),
+  developer: z2.string().optional()
 });
-var manifestMessageSchema = z.object({
-  id: z.string().min(1),
-  source: z.string().min(1),
-  normalized: z.string().min(1),
-  contentHash: z.string().length(64),
+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: z.array(placeholderSchema).default([]),
-  confidence: z.enum(["high", "explicit"]),
-  locations: z.array(messageLocationSchema).min(1)
+  placeholders: z2.array(placeholderSchema).default([]),
+  confidence: z2.enum(["high", "explicit"]),
+  locations: z2.array(messageLocationSchema).min(1)
 });
-var diagnosticSchema = z.object({
-  code: z.string().min(1),
-  severity: z.enum(["info", "warning", "error"]),
-  message: z.string().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: z.string().optional()
+  remediation: z2.string().optional()
 });
-var 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()
+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 = 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(),
+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: z.array(manifestMessageSchema),
-  diagnostics: z.array(diagnosticSchema).default([])
+  messages: z2.array(manifestMessageSchema),
+  diagnostics: z2.array(diagnosticSchema).default([])
 }).superRefine((manifest, context) => {
   if (manifest.schemaVersion === MANIFEST_SCHEMA_VERSION && !manifest.integration) {
     context.addIssue({
@@ -74,16 +223,16 @@ var manifestSchema = z.object({
     });
   }
 });
-var 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)
+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);
@@ -123,36 +272,36 @@ function parseMessagePlaceholders(source) {
   const visit = (elements) => {
     for (const element of elements) {
       switch (element.type) {
-        case TYPE.argument:
+        case TYPE2.argument:
           add(element.value, "value");
           break;
-        case TYPE.number:
+        case TYPE2.number:
           add(element.value, "number");
           break;
-        case TYPE.date:
+        case TYPE2.date:
           add(element.value, "date");
           break;
-        case TYPE.time:
+        case TYPE2.time:
           add(element.value, "time");
           break;
-        case TYPE.select:
+        case TYPE2.select:
           add(element.value, "select");
           for (const option of Object.values(element.options))
             visit(option.value);
           break;
-        case TYPE.plural:
+        case TYPE2.plural:
           add(element.value, "plural");
           for (const option of Object.values(element.options))
             visit(option.value);
           break;
-        case TYPE.tag:
+        case TYPE2.tag:
           add(element.value, "component");
           visit(element.children);
           break;
       }
     }
   };
-  visit(parse(source, { captureLocation: false, ignoreTag: false }));
+  visit(parse2(source, { captureLocation: false, ignoreTag: false }));
   return [...descriptors.values()].sort(
     (left, right) => left.name.localeCompare(right.name)
   );
@@ -184,17 +333,24 @@ export {
   canonicalJson,
   catalogSchema,
   contentHash,
+  contextProfileSchema,
   createCatalog,
   diagnosticSchema,
   manifestHash,
   manifestIntegrationSchema,
   manifestMessageSchema,
   manifestSchema,
+  meaningSchema,
   messageContextSchema,
   messageLocationSchema,
   normalizeSource,
   parseMessagePlaceholders,
   placeholderSchema,
+  resolveContextProfile,
+  runtimeBatchSchema,
+  runtimeContentKey,
+  runtimeItemSchema,
   stableMessageId,
+  validateIcuSemantics,
   verifyCatalog
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linguanahq/catalog",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "Linguana catalog integration",
   "exports": {