@lingo.dev/_spec 0.24.2

package/build/index.mjs

@@ -0,0 +1,496 @@
+// src/locales.ts
+import Z from "zod";
+var localeMap = {
+  // Urdu (Pakistan)
+  ur: ["ur-PK"],
+  // Vietnamese (Vietnam)
+  vi: ["vi-VN"],
+  // Turkish (Turkey)
+  tr: ["tr-TR"],
+  // Tamil (India)
+  ta: ["ta-IN"],
+  // Serbian
+  sr: [
+    "sr-RS",
+    // Serbian (Latin)
+    "sr-Latn-RS",
+    // Serbian (Latin)
+    "sr-Cyrl-RS"
+    // Serbian (Cyrillic)
+  ],
+  // Hungarian (Hungary)
+  hu: ["hu-HU"],
+  // Hebrew (Israel)
+  he: ["he-IL"],
+  // Estonian (Estonia)
+  et: ["et-EE"],
+  // Greek (Greece)
+  el: ["el-GR"],
+  // Danish (Denmark)
+  da: ["da-DK"],
+  // Azerbaijani (Azerbaijan)
+  az: ["az-AZ"],
+  // Thai (Thailand)
+  th: ["th-TH"],
+  // Swedish (Sweden)
+  sv: ["sv-SE"],
+  // English
+  en: [
+    "en-US",
+    // United States
+    "en-GB",
+    // United Kingdom
+    "en-AU",
+    // Australia
+    "en-CA"
+    // Canada
+  ],
+  // Spanish
+  es: [
+    "es-ES",
+    // Spain
+    "es-419",
+    // Latin America
+    "es-MX",
+    // Mexico
+    "es-AR"
+    // Argentina
+  ],
+  // French
+  fr: [
+    "fr-FR",
+    // France
+    "fr-CA",
+    // Canada
+    "fr-BE"
+    // Belgium
+  ],
+  // Catalan (Spain)
+  ca: ["ca-ES"],
+  // Japanese (Japan)
+  ja: ["ja-JP"],
+  // German
+  de: [
+    "de-DE",
+    // Germany
+    "de-AT",
+    // Austria
+    "de-CH"
+    // Switzerland
+  ],
+  // Portuguese
+  pt: [
+    "pt-PT",
+    // Portugal
+    "pt-BR"
+    // Brazil
+  ],
+  // Italian
+  it: [
+    "it-IT",
+    // Italy
+    "it-CH"
+    // Switzerland
+  ],
+  // Russian
+  ru: [
+    "ru-RU",
+    // Russia
+    "ru-BY"
+    // Belarus
+  ],
+  // Ukrainian (Ukraine)
+  uk: ["uk-UA"],
+  // Belarusian (Belarus)
+  be: ["be-BY"],
+  // Hindi (India)
+  hi: ["hi-IN"],
+  // Chinese
+  zh: [
+    "zh-CN",
+    // Simplified Chinese (China)
+    "zh-TW",
+    // Traditional Chinese (Taiwan)
+    "zh-HK",
+    // Traditional Chinese (Hong Kong)
+    "zh-Hans",
+    // Simplified Chinese
+    "zh-Hant",
+    // Traditional Chinese
+    "zh-Hant-HK",
+    // Traditional Chinese (Hong Kong)
+    "zh-Hant-TW",
+    // Traditional Chinese (Taiwan)
+    "zh-Hant-CN",
+    // Traditional Chinese (China)
+    "zh-Hans-HK",
+    // Simplified Chinese (Hong Kong)
+    "zh-Hans-TW",
+    // Simplified Chinese (China)
+    "zh-Hans-CN"
+    // Simplified Chinese (China)
+  ],
+  // Korean (South Korea)
+  ko: ["ko-KR"],
+  // Arabic
+  ar: [
+    "ar-EG",
+    // Egypt
+    "ar-SA",
+    // Saudi Arabia
+    "ar-AE",
+    // United Arab Emirates
+    "ar-MA"
+    // Morocco
+  ],
+  // Bulgarian (Bulgaria)
+  bg: ["bg-BG"],
+  // Czech (Czech Republic)
+  cs: ["cs-CZ"],
+  // Dutch
+  nl: [
+    "nl-NL",
+    // Netherlands
+    "nl-BE"
+    // Belgium
+  ],
+  // Polish (Poland)
+  pl: ["pl-PL"],
+  // Indonesian (Indonesia)
+  id: ["id-ID"],
+  // Malay (Malaysia)
+  ms: ["ms-MY"],
+  // Finnish (Finland)
+  fi: ["fi-FI"],
+  // Basque (Spain)
+  eu: ["eu-ES"],
+  // Croatian (Croatia)
+  hr: ["hr-HR"],
+  // Hebrew (Israel) - alternative code
+  iw: ["iw-IL"],
+  // Khmer (Cambodia)
+  km: ["km-KH"],
+  // Latvian (Latvia)
+  lv: ["lv-LV"],
+  // Lithuanian (Lithuania)
+  lt: ["lt-LT"],
+  // Norwegian (Norway)
+  no: ["no-NO"],
+  // Romanian (Romania)
+  ro: ["ro-RO"],
+  // Slovak (Slovakia)
+  sk: ["sk-SK"],
+  // Swahili
+  sw: [
+    "sw-TZ",
+    // Tanzania
+    "sw-KE"
+    // Kenya
+  ],
+  // Persian (Iran)
+  fa: ["fa-IR"],
+  // Filipino (Philippines)
+  fil: ["fil-PH"],
+  // Punjabi
+  pa: [
+    "pa-IN",
+    // India
+    "pa-PK"
+    // Pakistan
+  ],
+  // Bengali
+  bn: [
+    "bn-BD",
+    // Bangladesh
+    "bn-IN"
+    // India
+  ],
+  // Irish (Ireland)
+  ga: ["ga-IE"],
+  // Maltese (Malta)
+  mt: ["mt-MT"],
+  // Slovenian (Slovenia)
+  sl: ["sl-SI"],
+  // Albanian (Albania)
+  sq: ["sq-AL"],
+  // Bavarian (Germany)
+  bar: ["bar-DE"],
+  // Neapolitan (Italy)
+  nap: ["nap-IT"],
+  // Afrikaans (South Africa)
+  af: ["af-ZA"],
+  // Somali (Somalia)
+  so: ["so-SO"],
+  // Tigrinya (Ethiopia)
+  ti: ["ti-ET"],
+  // Standard Moroccan Tamazight (Morocco)
+  zgh: ["zgh-MA"],
+  // Tagalog (Philippines)
+  tl: ["tl-PH"],
+  // Telugu (India)
+  te: ["te-IN"]
+};
+var localeCodesShort = Object.keys(localeMap);
+var localeCodesFull = Object.values(localeMap).flat();
+var localeCodesFullUnderscore = localeCodesFull.map((value) => value.replace("-", "_"));
+var localeCodesFullExplicitRegion = localeCodesFull.map((value) => {
+  const chunks = value.split("-");
+  const result = [chunks[0], "-r", chunks.slice(1).join("-")].join("");
+  return result;
+});
+var localeCodes = [
+  ...localeCodesShort,
+  ...localeCodesFull,
+  ...localeCodesFullUnderscore,
+  ...localeCodesFullExplicitRegion
+];
+var localeCodeSchema = Z.string().refine((value) => localeCodes.includes(value), {
+  message: "Invalid locale code"
+});
+var resolveLocaleCode = (value) => {
+  const existingFullLocaleCode = Object.values(localeMap).flat().includes(value);
+  if (existingFullLocaleCode) {
+    return value;
+  }
+  const existingShortLocaleCode = Object.keys(localeMap).includes(value);
+  if (existingShortLocaleCode) {
+    const correspondingFullLocales = localeMap[value];
+    const fallbackFullLocale = correspondingFullLocales[0];
+    return fallbackFullLocale;
+  }
+  throw new Error(`Invalid locale code: ${value}`);
+};
+var getAlternativeLocaleCodes = (locale) => {
+  if (locale.includes("-")) {
+    return [locale.replace(/-/g, "_")];
+  } else if (locale.includes("_")) {
+    return [locale.replace(/_/g, "-")];
+  } else {
+    return [];
+  }
+};
+var getLocaleCodeDelimiter = (locale) => {
+  if (locale.includes("_")) {
+    return "_";
+  } else if (locale.includes("-")) {
+    return "-";
+  } else {
+    return null;
+  }
+};
+var resolveOverridenLocale = (locale, delimiter) => {
+  if (!delimiter) {
+    return locale;
+  }
+  const currentDelimiter = getLocaleCodeDelimiter(locale);
+  if (!currentDelimiter) {
+    return locale;
+  }
+  return locale.replace(currentDelimiter, delimiter);
+};
+
+// src/formats.ts
+import Z2 from "zod";
+var bucketTypes = [
+  "android",
+  "csv",
+  "flutter",
+  "html",
+  "json",
+  "markdown",
+  "xcode-strings",
+  "xcode-stringsdict",
+  "xcode-xcstrings",
+  "yaml",
+  "yaml-root-key",
+  "properties",
+  "po",
+  "xliff",
+  "xml",
+  "srt",
+  "dato",
+  "compiler",
+  "vtt"
+];
+var bucketTypeSchema = Z2.enum(bucketTypes);
+
+// src/config.ts
+import Z3 from "zod";
+var localeSchema = Z3.object({
+  source: localeCodeSchema,
+  targets: Z3.array(localeCodeSchema)
+});
+var createConfigDefinition = (definition) => definition;
+var extendConfigDefinition = (definition, params) => {
+  const schema = params.createSchema(definition.schema);
+  const defaultValue = params.createDefaultValue(definition.defaultValue);
+  const upgrader = (config) => params.createUpgrader(config, schema, defaultValue);
+  return createConfigDefinition({
+    schema,
+    defaultValue,
+    parse: (rawConfig) => {
+      const safeResult = schema.safeParse(rawConfig);
+      if (safeResult.success) {
+        return safeResult.data;
+      }
+      const localeErrors = safeResult.error.errors.filter((issue) => issue.message.includes("Invalid locale code")).map((issue) => {
+        let unsupportedLocale = "";
+        const path = issue.path;
+        const config = rawConfig;
+        if (config.locale) {
+          unsupportedLocale = path.reduce((acc, key) => {
+            if (acc && typeof acc === "object" && key in acc) {
+              return acc[key];
+            }
+            return acc;
+          }, config.locale);
+        }
+        return `Unsupported locale: ${unsupportedLocale}`;
+      });
+      if (localeErrors.length > 0) {
+        throw new Error(`
+${localeErrors.join("\n")}`);
+      }
+      const baseConfig = definition.parse(rawConfig);
+      const result = upgrader(baseConfig);
+      return result;
+    }
+  });
+};
+var configV0Schema = Z3.object({
+  version: Z3.number().default(0)
+});
+var configV0Definition = createConfigDefinition({
+  schema: configV0Schema,
+  defaultValue: { version: 0 },
+  parse: (rawConfig) => {
+    return configV0Schema.parse(rawConfig);
+  }
+});
+var configV1Definition = extendConfigDefinition(configV0Definition, {
+  createSchema: (baseSchema) => baseSchema.extend({
+    locale: localeSchema,
+    buckets: Z3.record(Z3.string(), bucketTypeSchema).default({}).optional()
+  }),
+  createDefaultValue: () => ({
+    version: 1,
+    locale: {
+      source: "en",
+      targets: ["es"]
+    },
+    buckets: {}
+  }),
+  createUpgrader: () => ({
+    version: 1,
+    locale: {
+      source: "en",
+      targets: ["es"]
+    },
+    buckets: {}
+  })
+});
+var configV1_1Definition = extendConfigDefinition(configV1Definition, {
+  createSchema: (baseSchema) => baseSchema.extend({
+    buckets: Z3.record(
+      bucketTypeSchema,
+      Z3.object({
+        include: Z3.array(Z3.string()).default([]),
+        exclude: Z3.array(Z3.string()).default([]).optional()
+      })
+    ).default({})
+  }),
+  createDefaultValue: (baseDefaultValue) => ({
+    ...baseDefaultValue,
+    version: 1.1,
+    buckets: {}
+  }),
+  createUpgrader: (oldConfig, schema) => {
+    const upgradedConfig = {
+      ...oldConfig,
+      version: 1.1,
+      buckets: {}
+    };
+    if (oldConfig.buckets) {
+      for (const [bucketPath, bucketType] of Object.entries(oldConfig.buckets)) {
+        if (!upgradedConfig.buckets[bucketType]) {
+          upgradedConfig.buckets[bucketType] = {
+            include: []
+          };
+        }
+        upgradedConfig.buckets[bucketType]?.include.push(bucketPath);
+      }
+    }
+    return upgradedConfig;
+  }
+});
+var configV1_2Definition = extendConfigDefinition(configV1_1Definition, {
+  createSchema: (baseSchema) => baseSchema.extend({
+    locale: localeSchema.extend({
+      extraSource: localeCodeSchema.optional()
+    })
+  }),
+  createDefaultValue: (baseDefaultValue) => ({
+    ...baseDefaultValue,
+    version: 1.2
+  }),
+  createUpgrader: (oldConfig) => ({
+    ...oldConfig,
+    version: 1.2
+  })
+});
+var bucketItemSchema = Z3.object({
+  path: Z3.string(),
+  delimiter: Z3.union([Z3.literal("-"), Z3.literal("_"), Z3.literal(null)]).optional()
+});
+var configV1_3Definition = extendConfigDefinition(configV1_2Definition, {
+  createSchema: (baseSchema) => baseSchema.extend({
+    buckets: Z3.record(
+      bucketTypeSchema,
+      Z3.object({
+        include: Z3.array(Z3.union([Z3.string(), bucketItemSchema])).default([]),
+        exclude: Z3.array(Z3.union([Z3.string(), bucketItemSchema])).default([]).optional()
+      })
+    ).default({})
+  }),
+  createDefaultValue: (baseDefaultValue) => ({
+    ...baseDefaultValue,
+    version: 1.3
+  }),
+  createUpgrader: (oldConfig) => ({
+    ...oldConfig,
+    version: 1.3
+  })
+});
+var LATEST_CONFIG_DEFINITION = configV1_3Definition;
+function parseI18nConfig(rawConfig) {
+  try {
+    const result = LATEST_CONFIG_DEFINITION.parse(rawConfig);
+    return result;
+  } catch (error) {
+    throw new Error(`Failed to parse config: ${error.message}`);
+  }
+}
+var defaultConfig = LATEST_CONFIG_DEFINITION.defaultValue;
+export {
+  bucketItemSchema,
+  bucketTypeSchema,
+  bucketTypes,
+  configV0Definition,
+  configV1Definition,
+  configV1_1Definition,
+  configV1_2Definition,
+  configV1_3Definition,
+  defaultConfig,
+  getAlternativeLocaleCodes,
+  getLocaleCodeDelimiter,
+  localeCodeSchema,
+  localeCodes,
+  localeCodesFull,
+  localeCodesFullExplicitRegion,
+  localeCodesFullUnderscore,
+  localeCodesShort,
+  localeSchema,
+  parseI18nConfig,
+  resolveLocaleCode,
+  resolveOverridenLocale
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@lingo.dev/_spec",
+  "version": "0.24.2",
+  "description": "Lingo.dev open specification",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "types": "build/index.d.ts",
+  "module": "build/index.mjs",
+  "main": "build/index.cjs",
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsc --noEmit && tsup",
+    "test": "vitest run"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5"
+  }
+}