fix(spec): fix locale codes imports/exports

Author: maxprilutskiy

.changeset/angry-pugs-smoke.md

@@ -0,0 +1,7 @@
+---
+"@replexica/spec": patch
+"@replexica/cli": patch
+"replexica": patch
+---
+
+Fix spec imports

packages/cli/src/cli/i18n.ts

@@ -4,7 +4,7 @@ import { loadConfig } from './../workers/config';
 import { loadSettings } from './../workers/settings';
 import Ora from 'ora';
 import _ from 'lodash';
-import { bucketTypeSchema, targetLocaleSchema } from '@replexica/spec';
+import { bucketTypeSchema, localeCodeSchema } from '@replexica/spec';
 import { createLockfileProcessor } from './../workers/lockfile';
 import { createAuthenticator } from './../workers/auth';
 import { ReplexicaEngine } from '@replexica/sdk';
@@ -216,9 +216,9 @@ export default new Command()
 
 async function loadFlags(options: any) {
   return Z.object({
-    locale: targetLocaleSchema.optional(),
+    locale: localeCodeSchema.optional(),
     bucket: bucketTypeSchema.optional(),
     force: Z.boolean().optional(),
     frozen: Z.boolean().optional(),
   }).parse(options);
-}
+}

packages/cli/src/cli/show/locale.ts

@@ -2,7 +2,7 @@ import { Command } from "commander";
 import _ from "lodash";
 import Z from 'zod';
 import Ora from 'ora';
-import { sourceLocales, targetLocales } from "@replexica/spec";
+import { localeCodes } from "@replexica/spec";
 
 export default new Command()
   .command("locale")
@@ -16,10 +16,10 @@ export default new Command()
       switch (type) {
         default: throw new Error(`Invalid type: ${type}`);
         case 'sources':
-          sourceLocales.forEach((locale) => console.log(locale));
+          localeCodes.forEach((locale) => console.log(locale));
           break;
         case 'targets':
-          targetLocales.forEach((locale) => console.log(locale));
+          localeCodes.forEach((locale) => console.log(locale));
           break;
       }
     } catch (error: any) {

packages/cli/src/workers/bucket/index.ts

@@ -1,4 +1,4 @@
-import { allLocalesSchema, bucketTypeSchema } from '@replexica/spec';
+import { localeCodeSchema, bucketTypeSchema } from '@replexica/spec';
 import Z from 'zod';
 import { createFileLoader, IBucketLoader } from './loader';
 import { createAndroidParser, createJsonParser, createMarkdownParser, createXcodeParser, createYamlParser, IBucketParser } from './parser';
@@ -63,15 +63,15 @@ type BucketProcessorParams = {
 
 function composeBucketProcessor(bucketPath: string, params: BucketProcessorParams) {
   return {
-    async load(locale: Z.infer<typeof allLocalesSchema>) {
+    async load(locale: Z.infer<typeof localeCodeSchema>) {
       const filePath = await params.pathResolver(locale, bucketPath);
       const content = await params.storage.load(locale, filePath);
       if (!content) { return {}; }
 
       const payload = await params.parser.deserialize(locale, content);
       return payload;
     },
-    async save(locale: Z.infer<typeof allLocalesSchema>, payload: Record<string, string>) {
+    async save(locale: Z.infer<typeof localeCodeSchema>, payload: Record<string, string>) {
       const serialized = await params.parser.serialize(locale, payload);
 
       const filePath = await params.pathResolver(locale, bucketPath);

packages/cli/src/workers/bucket/loader.ts

@@ -1,19 +1,19 @@
-import { allLocalesSchema } from "@replexica/spec";
+import { localeCodeSchema } from "@replexica/spec";
 import Z from 'zod';
 import path from 'path';
 import fs from 'fs';
 
 export interface IBucketLoader {
-  load: (locale: Z.infer<typeof allLocalesSchema>, localeFilePath: string) => Promise<any>;
-  save: (locale: Z.infer<typeof allLocalesSchema>, localeFilePath: string, content: any) => Promise<void>;
+  load: (locale: Z.infer<typeof localeCodeSchema>, localeFilePath: string) => Promise<any>;
+  save: (locale: Z.infer<typeof localeCodeSchema>, localeFilePath: string, content: any) => Promise<void>;
 }
 
 export function createFileLoader(): IBucketLoader {
   return {
-    async load(locale: Z.infer<typeof allLocalesSchema>, localeFilePath: string) {
+    async load(locale: Z.infer<typeof localeCodeSchema>, localeFilePath: string) {
       return fs.existsSync(localeFilePath) ? fs.readFileSync(localeFilePath, "utf8") : null;
     },
-    async save(locale: Z.infer<typeof allLocalesSchema>, localeFilePath: string, content: any) {
+    async save(locale: Z.infer<typeof localeCodeSchema>, localeFilePath: string, content: any) {
       fs.mkdirSync(path.dirname(localeFilePath), { recursive: true });
       fs.writeFileSync(localeFilePath, content, "utf8");
     }

packages/cli/src/workers/bucket/path-resolver.ts

@@ -1,16 +1,16 @@
-import { allLocalesSchema } from "@replexica/spec";
+import { localeCodeSchema } from "@replexica/spec";
 import Z from 'zod';
 import path from 'path';
 
 export type BucketPathResolver = {
-  (locale: Z.infer<typeof allLocalesSchema>, bucketPath: string): Promise<string>;
+  (locale: Z.infer<typeof localeCodeSchema>, bucketPath: string): Promise<string>;
 }
 
-export async function plainPathResolver(locale: Z.infer<typeof allLocalesSchema>, bucketPath: string) {
+export async function plainPathResolver(locale: Z.infer<typeof localeCodeSchema>, bucketPath: string) {
   return path.join(process.cwd(), bucketPath);
 }
 
-export async function patternPathResolver(locale: Z.infer<typeof allLocalesSchema>, bucketPath: string) {
+export async function patternPathResolver(locale: Z.infer<typeof localeCodeSchema>, bucketPath: string) {
   if (!bucketPath.includes('[locale]')) {
     throw new Error('Bucket path must contain [locale] placeholder');
   }
@@ -21,7 +21,7 @@ export async function patternPathResolver(locale: Z.infer<typeof allLocalesSchem
   return result;
 }
 
-export async function concreteNamePathResolveR(locale: Z.infer<typeof allLocalesSchema>, bucketPath: string) {
+export async function concreteNamePathResolveR(locale: Z.infer<typeof localeCodeSchema>, bucketPath: string) {
   const result = await plainPathResolver(locale, bucketPath);
 
   const filename = 'Localizable.xcstrings';
@@ -30,4 +30,4 @@ export async function concreteNamePathResolveR(locale: Z.infer<typeof allLocales
   }
 
   return result;
-}
+}

packages/spec/src/locales.ts

@@ -49,15 +49,16 @@ export type LocaleCodeShort = keyof typeof localeMap;
 export type LocaleCodeFull = typeof localeMap[LocaleCodeShort][number];
 export type LocaleCode = LocaleCodeShort | LocaleCodeFull;
 
-export const localeCodeSchema = Z.string().refine((value) => {
-  const existingShortLocaleCode = Object.keys(localeMap).includes(value);
-  if (existingShortLocaleCode) { return true; }
-
-  const existingFullLocaleCode = Object.values(localeMap).flat().includes(value as any);
-  if (existingFullLocaleCode) { return true; }
+export const localeCodesShort = Object.keys(localeMap) as LocaleCodeShort[];
+export const localeCodesFull = Object.values(localeMap).flat() as LocaleCodeFull[];
+export const localeCodes = [...localeCodesShort, ...localeCodesFull] as LocaleCode[];
 
-  return false;
-});
+export const localeCodeSchema = Z
+  .string()
+  .refine(
+    (value) => localeCodes.includes(value as any),
+    { message: 'Invalid locale code' },
+  );
 
 export const resolveLocaleCode = (value: LocaleCode): LocaleCodeFull => {
   const existingFullLocaleCode = Object.values(localeMap).flat().includes(value as any);