@linguanahq/catalog 0.1.0

package/package.json

@@ -0,0 +1,25 @@
+{
+	"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"
+	}
+}

package/src/index.ts

@@ -0,0 +1,219 @@
+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;
+}