@contractspec/lib.contracts-spec 2.0.0

package/dist/node/translations/spec.js

@@ -0,0 +1,36 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/translations/spec.ts
+var defineTranslation = (spec) => spec;
+export {
+  defineTranslation
+};

package/dist/node/translations/validation.js

@@ -0,0 +1,392 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/translations/validation.ts
+function validateTranslationSpec(spec) {
+  const issues = [];
+  validateMeta(spec, issues);
+  validateLocale(spec, issues);
+  validateMessages(spec, issues);
+  validatePluralRules(spec, issues);
+  return {
+    valid: issues.filter((i) => i.level === "error").length === 0,
+    issues
+  };
+}
+function validateMeta(spec, issues) {
+  const { meta } = spec;
+  if (!meta.key?.trim()) {
+    issues.push({
+      level: "error",
+      message: "Translation spec must have a non-empty key",
+      path: "meta.key"
+    });
+  }
+  if (!meta.version?.trim()) {
+    issues.push({
+      level: "error",
+      message: "Translation spec must have a non-empty version",
+      path: "meta.version"
+    });
+  }
+  if (!meta.domain?.trim()) {
+    issues.push({
+      level: "error",
+      message: "Translation spec must have a non-empty domain",
+      path: "meta.domain"
+    });
+  }
+  if (!meta.owners?.length) {
+    issues.push({
+      level: "warning",
+      message: "Translation spec should specify owners",
+      path: "meta.owners"
+    });
+  }
+}
+function validateLocale(spec, issues) {
+  if (!spec.locale?.trim()) {
+    issues.push({
+      level: "error",
+      message: "Translation spec must specify a locale",
+      path: "locale"
+    });
+  } else if (!isValidLocaleFormat(spec.locale)) {
+    issues.push({
+      level: "warning",
+      message: `Locale "${spec.locale}" may not be a valid ISO 639-1 code`,
+      path: "locale"
+    });
+  }
+  if (spec.fallback && !isValidLocaleFormat(spec.fallback)) {
+    issues.push({
+      level: "warning",
+      message: `Fallback locale "${spec.fallback}" may not be a valid ISO 639-1 code`,
+      path: "fallback"
+    });
+  }
+  if (spec.fallback === spec.locale) {
+    issues.push({
+      level: "warning",
+      message: "Fallback locale is the same as primary locale",
+      path: "fallback"
+    });
+  }
+}
+function validateMessages(spec, issues) {
+  const { messages } = spec;
+  if (!messages || Object.keys(messages).length === 0) {
+    issues.push({
+      level: "warning",
+      message: "Translation spec has no messages",
+      path: "messages"
+    });
+    return;
+  }
+  for (const [key, message] of Object.entries(messages)) {
+    const path = `messages.${key}`;
+    if (!message.value?.trim()) {
+      issues.push({
+        level: "error",
+        message: `Message "${key}" has an empty value`,
+        path: `${path}.value`
+      });
+    }
+    const valueParams = extractPlaceholders(message.value);
+    const declaredPlaceholders = message.placeholders ?? [];
+    for (const placeholder of declaredPlaceholders) {
+      if (!valueParams.includes(placeholder.name)) {
+        issues.push({
+          level: "warning",
+          message: `Placeholder "${placeholder.name}" is defined but not used in message "${key}"`,
+          path: `${path}.placeholders`
+        });
+      }
+    }
+    if (message.placeholders !== undefined) {
+      for (const param of valueParams) {
+        const declared = declaredPlaceholders.find((p) => p.name === param);
+        if (!declared) {
+          issues.push({
+            level: "info",
+            message: `Placeholder "{${param}}" used in message "${key}" but not declared`,
+            path: `${path}.placeholders`
+          });
+        }
+      }
+    }
+    const icuResult = validateICUFormat(message.value);
+    if (!icuResult.valid) {
+      issues.push({
+        level: "error",
+        message: `Message "${key}" has invalid ICU format: ${icuResult.error}`,
+        path: `${path}.value`
+      });
+    }
+    if (message.variants?.length) {
+      const seenVariants = new Set;
+      for (const variant of message.variants) {
+        const variantKey = `${variant.type}:${variant.key}`;
+        if (seenVariants.has(variantKey)) {
+          issues.push({
+            level: "warning",
+            message: `Duplicate variant "${variantKey}" in message "${key}"`,
+            path: `${path}.variants`
+          });
+        }
+        seenVariants.add(variantKey);
+        if (!variant.value?.trim()) {
+          issues.push({
+            level: "error",
+            message: `Variant "${variantKey}" has an empty value in message "${key}"`,
+            path: `${path}.variants`
+          });
+        }
+      }
+    }
+    if (message.maxLength !== undefined) {
+      if (message.maxLength <= 0) {
+        issues.push({
+          level: "error",
+          message: `Message "${key}" has invalid maxLength (must be positive)`,
+          path: `${path}.maxLength`
+        });
+      } else if (message.value.length > message.maxLength) {
+        issues.push({
+          level: "warning",
+          message: `Message "${key}" value exceeds maxLength (${message.value.length} > ${message.maxLength})`,
+          path: `${path}.value`
+        });
+      }
+    }
+  }
+}
+function validatePluralRules(spec, issues) {
+  if (!spec.pluralRules?.length)
+    return;
+  for (let i = 0;i < spec.pluralRules.length; i++) {
+    const rule = spec.pluralRules[i];
+    if (!rule)
+      continue;
+    const path = `pluralRules[${i}]`;
+    if (!rule.variable?.trim()) {
+      issues.push({
+        level: "error",
+        message: "Plural rule must specify a variable name",
+        path: `${path}.variable`
+      });
+    }
+    if (!rule.rules?.length) {
+      issues.push({
+        level: "error",
+        message: "Plural rule must have at least one category",
+        path: `${path}.rules`
+      });
+    } else {
+      const hasOther = rule.rules.some((r) => r.category === "other");
+      if (!hasOther) {
+        issues.push({
+          level: "error",
+          message: `Plural rule "${rule.variable}" must have an "other" category`,
+          path: `${path}.rules`
+        });
+      }
+    }
+  }
+}
+function validateICUFormat(message) {
+  const placeholders = [];
+  const plurals = [];
+  const selects = [];
+  let braceDepth = 0;
+  let currentPlaceholder = "";
+  let inPlaceholder = false;
+  try {
+    for (let i = 0;i < message.length; i++) {
+      const char = message[i];
+      const prevChar = i > 0 ? message[i - 1] : "";
+      if (char === "'" && i + 1 < message.length) {
+        const nextChar = message[i + 1];
+        if (nextChar === "{" || nextChar === "}") {
+          i++;
+          continue;
+        }
+      }
+      if (char === "{") {
+        if (prevChar !== "'") {
+          braceDepth++;
+          if (braceDepth === 1) {
+            inPlaceholder = true;
+            currentPlaceholder = "";
+          }
+        }
+      } else if (char === "}") {
+        if (prevChar !== "'") {
+          braceDepth--;
+          if (braceDepth === 0 && inPlaceholder) {
+            const placeholder = currentPlaceholder.trim();
+            processPlaceholder(placeholder, placeholders, plurals, selects);
+            inPlaceholder = false;
+          }
+          if (braceDepth < 0) {
+            return {
+              valid: false,
+              error: "Unbalanced closing brace",
+              placeholders: [],
+              plurals: [],
+              selects: []
+            };
+          }
+        }
+      } else if (inPlaceholder) {
+        currentPlaceholder += char;
+      }
+    }
+    if (braceDepth !== 0) {
+      return {
+        valid: false,
+        error: "Unbalanced opening brace",
+        placeholders: [],
+        plurals: [],
+        selects: []
+      };
+    }
+    return {
+      valid: true,
+      placeholders,
+      plurals,
+      selects
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+      placeholders: [],
+      plurals: [],
+      selects: []
+    };
+  }
+}
+function processPlaceholder(placeholder, placeholders, plurals, selects) {
+  const parts = placeholder.split(",").map((p) => p.trim());
+  const name = parts[0];
+  const type = parts[1]?.toLowerCase();
+  if (name && !placeholders.includes(name)) {
+    placeholders.push(name);
+  }
+  if (type === "plural" || type === "selectordinal") {
+    if (name && !plurals.includes(name)) {
+      plurals.push(name);
+    }
+  } else if (type === "select") {
+    if (name && !selects.includes(name)) {
+      selects.push(name);
+    }
+  }
+}
+function findMissingTranslations(sourceSpec, targetSpec) {
+  const missing = [];
+  for (const [key, message] of Object.entries(sourceSpec.messages)) {
+    if (!targetSpec.messages[key]) {
+      missing.push({
+        messageKey: key,
+        sourceLocale: sourceSpec.locale,
+        targetLocale: targetSpec.locale,
+        sourceMessage: message
+      });
+    }
+  }
+  return missing;
+}
+function findAllMissingTranslations(registry, specKey, baseLocale) {
+  const result = new Map;
+  const baseSpec = registry.getLatest(specKey, baseLocale);
+  if (!baseSpec)
+    return result;
+  const locales = registry.listLocales(specKey);
+  for (const locale of locales) {
+    if (locale === baseLocale)
+      continue;
+    const targetSpec = registry.getLatest(specKey, locale);
+    if (targetSpec) {
+      const missing = findMissingTranslations(baseSpec, targetSpec);
+      if (missing.length > 0) {
+        result.set(locale, missing);
+      }
+    }
+  }
+  return result;
+}
+function validateTranslationRegistry(registry) {
+  const issues = [];
+  for (const spec of registry.list()) {
+    const specResult = validateTranslationSpec(spec);
+    issues.push(...specResult.issues.map((i) => ({
+      ...i,
+      path: `${spec.meta.key}.v${spec.meta.version}:${spec.locale}${i.path ? `.${i.path}` : ""}`
+    })));
+  }
+  return {
+    valid: issues.filter((i) => i.level === "error").length === 0,
+    issues
+  };
+}
+
+class TranslationValidationError extends Error {
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+    this.name = "TranslationValidationError";
+  }
+}
+function assertTranslationSpecValid(spec) {
+  const result = validateTranslationSpec(spec);
+  if (!result.valid) {
+    throw new TranslationValidationError(`Translation ${spec.meta.key}.v${spec.meta.version}:${spec.locale} is invalid`, result.issues);
+  }
+}
+function isValidLocaleFormat(locale) {
+  return /^[a-z]{2}(-[A-Z]{2})?$/.test(locale);
+}
+function extractPlaceholders(value) {
+  const result = validateICUFormat(value);
+  return result.placeholders;
+}
+export {
+  validateTranslationSpec,
+  validateTranslationRegistry,
+  validateICUFormat,
+  findMissingTranslations,
+  findAllMissingTranslations,
+  assertTranslationSpecValid,
+  TranslationValidationError
+};

package/dist/node/versioning/index.js

@@ -0,0 +1,274 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/versioning/refs.ts
+function isVersionedSpecRef(ref) {
+  return typeof ref === "object" && ref !== null && "key" in ref && typeof ref.key === "string" && ref.key.length > 0 && "version" in ref && typeof ref.version === "string" && ref.version.length > 0;
+}
+function isOptionalVersionedSpecRef(ref) {
+  if (typeof ref !== "object" || ref === null)
+    return false;
+  if (!("key" in ref))
+    return false;
+  if (typeof ref.key !== "string" || ref.key.length === 0) {
+    return false;
+  }
+  if ("version" in ref && ref.version != null) {
+    return typeof ref.version === "string";
+  }
+  return true;
+}
+function isSpecKeyRef(ref) {
+  return typeof ref === "object" && ref !== null && "key" in ref && typeof ref.key === "string" && ref.key.length > 0;
+}
+function createVersionedRef(key, version) {
+  if (!key || key.trim().length === 0) {
+    throw new Error("Spec key cannot be empty");
+  }
+  if (!version || version.trim().length === 0) {
+    throw new Error("Spec version cannot be empty");
+  }
+  return { key: key.trim(), version: version.trim() };
+}
+function createOptionalRef(key, version) {
+  if (!key || key.trim().length === 0) {
+    throw new Error("Spec key cannot be empty");
+  }
+  const ref = { key: key.trim() };
+  if (version != null && version.trim().length > 0) {
+    ref.version = version.trim();
+  }
+  return ref;
+}
+function createKeyRef(key) {
+  if (!key || key.trim().length === 0) {
+    throw new Error("Spec key cannot be empty");
+  }
+  return { key: key.trim() };
+}
+function formatVersionedRefKey(ref) {
+  return `${ref.key}.v${ref.version}`;
+}
+function parseVersionedRefKey(refKey) {
+  const match = refKey.match(/^(.+)\.v(\d+\.\d+\.\d+(?:-.+)?)$/);
+  if (!match)
+    return;
+  const key = match[1];
+  const version = match[2];
+  if (!key || !version)
+    return;
+  return { key, version };
+}
+
+// src/versioning/types.ts
+function isChangelogDocBlock(doc) {
+  return doc.kind === "changelog" && "specKey" in doc && "entries" in doc;
+}
+function isVersionBumpType(value) {
+  return value === "patch" || value === "minor" || value === "major";
+}
+function isChangeType(value) {
+  const validTypes = [
+    "added",
+    "changed",
+    "fixed",
+    "removed",
+    "deprecated",
+    "breaking",
+    "security"
+  ];
+  return typeof value === "string" && validTypes.includes(value);
+}
+
+// src/versioning/utils.ts
+var SEMVER_REGEX = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9]+(?:\.[a-zA-Z0-9]+)*))?(?:\+([a-zA-Z0-9]+(?:\.[a-zA-Z0-9]+)*))?$/;
+function parseVersion(version) {
+  const match = version.trim().match(SEMVER_REGEX);
+  if (!match) {
+    return null;
+  }
+  const majorStr = match[1];
+  const minorStr = match[2];
+  const patchStr = match[3];
+  const prerelease = match[4];
+  const build = match[5];
+  if (!majorStr || !minorStr || !patchStr) {
+    return null;
+  }
+  return {
+    major: parseInt(majorStr, 10),
+    minor: parseInt(minorStr, 10),
+    patch: parseInt(patchStr, 10),
+    ...prerelease && { prerelease },
+    ...build && { build }
+  };
+}
+function parseVersionStrict(version) {
+  const parsed = parseVersion(version);
+  if (!parsed) {
+    throw new Error(`Invalid semantic version: "${version}"`);
+  }
+  return parsed;
+}
+function formatVersion(version) {
+  let result = `${version.major}.${version.minor}.${version.patch}`;
+  if (version.prerelease) {
+    result += `-${version.prerelease}`;
+  }
+  if (version.build) {
+    result += `+${version.build}`;
+  }
+  return result;
+}
+function compareVersions(a, b) {
+  const versionA = parseVersionStrict(a);
+  const versionB = parseVersionStrict(b);
+  if (versionA.major !== versionB.major) {
+    return versionA.major > versionB.major ? 1 : -1;
+  }
+  if (versionA.minor !== versionB.minor) {
+    return versionA.minor > versionB.minor ? 1 : -1;
+  }
+  if (versionA.patch !== versionB.patch) {
+    return versionA.patch > versionB.patch ? 1 : -1;
+  }
+  if (versionA.prerelease && !versionB.prerelease) {
+    return -1;
+  }
+  if (!versionA.prerelease && versionB.prerelease) {
+    return 1;
+  }
+  if (versionA.prerelease && versionB.prerelease) {
+    return versionA.prerelease < versionB.prerelease ? -1 : versionA.prerelease > versionB.prerelease ? 1 : 0;
+  }
+  return 0;
+}
+function isVersionGreater(a, b) {
+  return compareVersions(a, b) === 1;
+}
+function isVersionLess(a, b) {
+  return compareVersions(a, b) === -1;
+}
+function isVersionEqual(a, b) {
+  return compareVersions(a, b) === 0;
+}
+function bumpVersion(current, bumpType) {
+  const version = parseVersionStrict(current);
+  switch (bumpType) {
+    case "major":
+      return formatVersion({
+        major: version.major + 1,
+        minor: 0,
+        patch: 0
+      });
+    case "minor":
+      return formatVersion({
+        major: version.major,
+        minor: version.minor + 1,
+        patch: 0
+      });
+    case "patch":
+      return formatVersion({
+        major: version.major,
+        minor: version.minor,
+        patch: version.patch + 1
+      });
+  }
+}
+function determineBumpType(hasBreaking, hasNonBreaking) {
+  if (hasBreaking) {
+    return "major";
+  }
+  if (hasNonBreaking) {
+    return "minor";
+  }
+  return "patch";
+}
+function getBumpTypePriority(bumpType) {
+  switch (bumpType) {
+    case "major":
+      return 3;
+    case "minor":
+      return 2;
+    case "patch":
+      return 1;
+  }
+}
+function getMaxBumpType(bumpTypes) {
+  if (bumpTypes.length === 0) {
+    return null;
+  }
+  return bumpTypes.reduce((max, current) => getBumpTypePriority(current) > getBumpTypePriority(max) ? current : max);
+}
+function isValidVersion(version) {
+  return parseVersion(version) !== null;
+}
+function validateVersion(version) {
+  const errors = [];
+  if (!version || typeof version !== "string") {
+    errors.push("Version must be a non-empty string");
+    return errors;
+  }
+  const trimmed = version.trim();
+  if (trimmed !== version) {
+    errors.push("Version should not have leading or trailing whitespace");
+  }
+  if (!parseVersion(trimmed)) {
+    errors.push(`Invalid semantic version format: "${version}". Expected format: MAJOR.MINOR.PATCH[-prerelease][+build]`);
+  }
+  return errors;
+}
+export {
+  validateVersion,
+  parseVersionedRefKey,
+  parseVersionStrict,
+  parseVersion,
+  isVersionedSpecRef,
+  isVersionLess,
+  isVersionGreater,
+  isVersionEqual,
+  isVersionBumpType,
+  isValidVersion,
+  isSpecKeyRef,
+  isOptionalVersionedSpecRef,
+  isChangelogDocBlock,
+  isChangeType,
+  getMaxBumpType,
+  getBumpTypePriority,
+  formatVersionedRefKey,
+  formatVersion,
+  determineBumpType,
+  createVersionedRef,
+  createOptionalRef,
+  createKeyRef,
+  compareVersions,
+  bumpVersion
+};