chore: improve TS

Author: robrechtme

CONTRIBUTING.md

@@ -1,7 +1,34 @@
 # Contributing to Loco CLI
 
-## Publish a new version
+## Development Setup
 
-1. Update the version in `package.json`: `npm version <major|minor|patch>`
-2. Run `yarn build`
-3. Run `npm publish`
+```bash
+pnpm install
+pnpm build
+```
+
+To test the CLI locally:
+
+```bash
+pnpm loco-cli <command>
+```
+
+## Before Submitting a PR
+
+```bash
+pnpm test
+pnpm lint
+pnpm format:check
+```
+
+## Code Style
+
+- 2-space indent, 100 char width, single quotes, semicolons required
+- Prefer typed code over `any`
+- No barrel exports; use explicit imports
+
+## Publishing (maintainers)
+
+1. `npm version <major|minor|patch>`
+2. `pnpm build`
+3. `npm publish`

src/commands/push.ts

@@ -7,7 +7,7 @@ import { diff } from '../lib/diff';
 import { readFiles } from '../lib/readFiles';
 import { getGlobalOptions } from '../util/options';
 import { printDiff } from '../util/print';
-import { dotObject } from '../lib/dotObject';
+import { flattenTranslations } from '../lib/dotObject';
 import { log } from '../util/logger';
 
 interface CommandOptions {
@@ -94,7 +94,7 @@ const push = async ({ yes, status, tag }: CommandOptions, program: Command) => {
   progressbar.start(length, 0);
   for (const [locale, translations] of Object.entries(local)) {
     progressbar.increment();
-    await apiPush(accessKey, locale, dotObject(translations), pushOptions);
+    await apiPush(accessKey, locale, flattenTranslations(translations), pushOptions);
   }
   progressbar.stop();
 

src/lib/api.ts

@@ -1,5 +1,11 @@
 import fetch from 'isomorphic-unfetch';
-import { ProjectLocale, PullOptions, PushOptions, Translations } from '../../types';
+import {
+  FlatTranslations,
+  ProjectLocale,
+  PullOptions,
+  PushOptions,
+  Translations
+} from '../../types';
 
 const BASE_URL = 'https://localise.biz/api';
 
@@ -29,29 +35,28 @@ const fetchApi = async <T>(
 export const apiPull = async (key: string, options: PullOptions = {}) => {
   const translations = await fetchApi<Translations>(key, '/export/all.json', options);
   const locales = await fetchApi<ProjectLocale[]>(key, '/locales');
-  if (locales?.length === 1) {
-    return { [locales[0].code]: translations };
+  const firstLocale = locales[0];
+  if (locales.length === 1 && firstLocale) {
+    return { [firstLocale.code]: translations };
   }
   return translations;
 };
 
 export const apiPush = (
   key: string,
   locale: string,
-  translations: Translations[string],
+  translations: FlatTranslations,
   options: PushOptions = {}
 ) =>
   fetchApi<void>(
     key,
     '/import/json',
     {
       locale,
-      ...Object.keys(options).reduce(
-        (acc, key) => ({
-          ...acc,
-          [key]: options[key as keyof PushOptions]?.toString()
-        }),
-        {}
+      ...Object.fromEntries(
+        Object.entries(options)
+          .filter(([, v]) => v !== undefined)
+          .map(([k, v]) => [k, String(v)])
       )
     },
     {

src/lib/diff.ts

@@ -1,14 +1,29 @@
 import { detailedDiff } from 'deep-object-diff';
-import { PushOptions, Translations } from '../../types';
+import { DiffRecord, PushOptions, Translations, TranslationValue } from '../../types';
 import { dotObject } from './dotObject';
 
 interface DetailedDiff {
-  added: object;
-  updated: object;
-  deleted: object;
+  added: TranslationValue;
+  updated: TranslationValue;
+  deleted: TranslationValue;
 }
 
-export const diff = (local: Translations, remote: Translations, options?: PushOptions) => {
+export interface DiffResult {
+  totalCount: number;
+  added: DiffRecord;
+  addedCount: number;
+  updated: DiffRecord;
+  updatedCount: number;
+  deleted: DiffRecord;
+  deletedCount: number;
+}
+
+export const diff = (
+  local: Translations,
+  remote: Translations,
+  options?: PushOptions
+): DiffResult => {
+  // detailedDiff returns {added, updated, deleted} matching our DetailedDiff shape
   const { added, updated, deleted } = detailedDiff(local, remote) as DetailedDiff;
   const ignoreAdded = options?.['ignore-new'];
   const ignoreUpdated = options?.['ignore-existing'];

src/lib/dotObject.ts

@@ -1,18 +1,47 @@
+import { DiffRecord, TranslationValue } from '../../types';
+
+type DiffValue = string | undefined;
+type DiffObject = { [key: string]: DiffValue | DiffObject };
+
 /**
  * Transform nested JS object to key-value pairs using dot notation.
+ * Handles undefined values from diff operations (representing deletions).
  */
-export const dotObject = (obj: object): Record<string, string> => {
-  const res: Record<string, string> = {};
+export const dotObject = (obj: TranslationValue | DiffObject): DiffRecord => {
+  const res: DiffRecord = {};
 
-  function recurse(obj: object, keyPrefix?: string) {
-    for (const key in obj) {
-      const value = obj[key as keyof typeof obj];
+  function recurse(current: TranslationValue | DiffObject, keyPrefix?: string) {
+    for (const key of Object.keys(current)) {
+      const value = current[key];
       const newKey = keyPrefix ? `${keyPrefix}.${key}` : key;
-      if (value && typeof value === 'object') {
+      if (value !== undefined && typeof value === 'object') {
         // it's a nested object, so do it again
         recurse(value, newKey);
       } else {
-        // it's not an object, so set the property
+        // it's a string or undefined (deletion marker)
+        res[newKey] = value;
+      }
+    }
+  }
+  recurse(obj);
+  return res;
+};
+
+/**
+ * Transform nested JS object to key-value pairs using dot notation.
+ * Use this version when you know the input contains only strings (no diff undefined values).
+ */
+export const flattenTranslations = (obj: TranslationValue): Record<string, string> => {
+  const res: Record<string, string> = {};
+
+  function recurse(current: TranslationValue, keyPrefix?: string) {
+    for (const key of Object.keys(current)) {
+      const value = current[key];
+      if (value === undefined) continue;
+      const newKey = keyPrefix ? `${keyPrefix}.${key}` : key;
+      if (typeof value === 'object') {
+        recurse(value, newKey);
+      } else {
         res[newKey] = value;
       }
     }

src/lib/readFiles.ts

@@ -4,7 +4,7 @@ import { join } from 'path';
 import { Translations } from '../../types';
 import { log } from '../util/logger';
 
-const readJSON = async (path: string) => {
+const readJSON = async (path: string): Promise<Record<string, string>> => {
   if (!existsSync(path)) {
     log.error(`File not found: ${path}`);
     process.exit(1);
@@ -15,13 +15,16 @@ const readJSON = async (path: string) => {
       if (err) {
         reject(err);
       }
-      resolve(JSON.parse(data));
+      resolve(JSON.parse(data) as Record<string, string>);
     });
-  }) as Promise<Record<string, string>>;
+  });
 };
 
-const readFilesInDir = async (path: string, separator?: string) => {
-  const res = {};
+const readFilesInDir = async (
+  path: string,
+  separator?: string
+): Promise<Record<string, string>> => {
+  const res: Record<string, string> = {};
   if (!existsSync(path)) {
     log.error(`Directory not found: "${path}"`);
     process.exit(1);
@@ -32,10 +35,12 @@ const readFilesInDir = async (path: string, separator?: string) => {
     files.map(async file => {
       if (file.endsWith('.json')) {
         const json = await readJSON(join(path, file));
-        Object.keys(json).forEach(key => {
-          // @ts-expect-error Element implicitly has an any type because expression of type string can't be used to index type {}.
-          res[`${file.replace('.json', '')}${separator}${key}`] = json[key];
-        });
+        for (const key of Object.keys(json)) {
+          const value = json[key];
+          if (value !== undefined) {
+            res[`${file.replace('.json', '')}${separator}${key}`] = value;
+          }
+        }
       }
     })
   );

src/util/handleAsyncErrors.ts

@@ -1,10 +1,8 @@
 import chalk from 'chalk';
 
-type Fun = (...args: any[]) => Promise<void>;
-
-export const handleAsyncErrors = (fn: Fun) => {
-  return (...args: any[]) =>
-    fn(...args).catch(error => {
+export const handleAsyncErrors = <T extends unknown[]>(fn: (...args: T) => Promise<void>) => {
+  return (...args: T) =>
+    fn(...args).catch((error: Error) => {
       if (error.message === 'HTTPError: 401 Authorization Required') {
         console.log(
           `\n${chalk.red(

src/util/logger.ts

@@ -2,8 +2,8 @@ import chalk from 'chalk';
 
 export const log = {
   log: console.log,
-  info: (msg: string, ...args: any) => console.log(`💡 ${msg}`, ...args),
-  warn: (msg: string, ...args: any) => console.warn(`⚠️ ${msg}`, ...args),
-  error: (msg: string, ...args: any) => console.error(`${chalk.red('✗')} ${msg}`, ...args),
-  success: (msg: string, ...args: any) => console.log(`${chalk.green('✔')} ${msg}`, ...args)
+  info: (msg: string, ...args: unknown[]) => console.log(`💡 ${msg}`, ...args),
+  warn: (msg: string, ...args: unknown[]) => console.warn(`⚠️ ${msg}`, ...args),
+  error: (msg: string, ...args: unknown[]) => console.error(`${chalk.red('✗')} ${msg}`, ...args),
+  success: (msg: string, ...args: unknown[]) => console.log(`${chalk.green('✔')} ${msg}`, ...args)
 };

src/util/namespaces.ts

@@ -1,19 +1,19 @@
+import { TranslationValue } from '../../types';
+
 export const splitIntoNamespaces = (
-  json: object,
+  json: TranslationValue,
   { defaultNs = 'default', separator = ':' } = {}
-) =>
-  Object.entries(json).reduce<Record<string, object>>((acc, [key, value]) => {
+): Record<string, TranslationValue> =>
+  Object.entries(json).reduce<Record<string, TranslationValue>>((acc, [key, value]) => {
     // Pull out the group name from the key
     const chunks = key.split(new RegExp(`${separator}(.*)`, 's'));
-    const namespace = chunks.length > 1 ? chunks[0] : defaultNs;
-    const assetKey = chunks.length > 1 ? chunks[1] : chunks[0];
+    const hasNamespace = chunks.length > 1;
+    const namespace = (hasNamespace ? chunks[0] : defaultNs) ?? defaultNs;
+    const assetKey = (hasNamespace ? chunks[1] : chunks[0]) ?? key;
 
     // Check if the group exists, if not, create it
-    if (!acc[namespace]) {
-      acc[namespace] = {};
-    }
+    const group = acc[namespace] ?? (acc[namespace] = {});
     // Add the current entry to the result
-    // @ts-expect-error Element implicitly has an any type because expression of type string can't be used to index type {}.
-    acc[namespace][assetKey] = value;
+    group[assetKey] = value;
     return acc;
   }, {});

src/util/options.ts

@@ -8,7 +8,7 @@ export const getGlobalOptions = async (program: Command): Promise<Config> => {
     log.error('Something went wrong. Sorry!');
     process.exit(1);
   }
-  const cliOptions = program.parent.opts() as Partial<Config>;
+  const cliOptions = program.parent.opts<Partial<Config>>();
 
   const fileOptions = await readConfig();
 
@@ -31,7 +31,7 @@ export const getGlobalOptions = async (program: Command): Promise<Config> => {
     );
   }
   // Note: merge deep when options will be nested
-  const mergedOptions = {
+  const mergedOptions: Partial<Config> = {
     ...cliOptions,
     ...fileOptions
   };
@@ -41,6 +41,11 @@ export const getGlobalOptions = async (program: Command): Promise<Config> => {
     mergedOptions.maxFiles = parseInt(mergedOptions.maxFiles, 10);
   }
 
-  // accessKey is validated above, so this cast is safe
-  return mergedOptions as Config;
+  // accessKey is validated above; provide defaults for required fields
+  return {
+    accessKey: mergedOptions.accessKey!,
+    localesDir: mergedOptions.localesDir ?? '.',
+    namespaces: mergedOptions.namespaces ?? false,
+    ...mergedOptions
+  };
 };