smartloc 2.0.2 → 2.0.4

package/src/cli/cli.ts

@@ -1,137 +0,0 @@
-#!/usr/bin/env bun
-
-import yargs, { Argv } from 'yargs';
-import path from 'path';
-import { collect } from './collect';
-import { reconciliate } from './reconciliate';
-import { getAdapter } from '../adapters';
-
-// === arguments parsing ===
-
-function isValidLocale(x: string) {
-    return typeof x === 'string' && !!x && /^[a-zA-Z]+(\-[a-zA-Z]+)?$/.test(x);
-}
-
-function defaultArgs<T>(b: Argv<T>): Argv<T & { format: string; outDir: string; }> {
-    return b.positional('format', {
-        describe: 'The output format',
-        choices: ['json', 'xliff'],
-        default: 'xliff',
-    })
-        .positional('outDir', {
-            describe: 'The translation output directory',
-            default: 'i18n',
-            normalize: true,
-        })
-}
-
-yargs
-    .scriptName('smartloc')
-    .command('add', 'Add a new locale', b => defaultArgs(b).demandCommand()
-        , args => {
-            console.log(args);
-        })
-    .command('collect', 'Collects all strings to translate', b => defaultArgs(b)
-        .positional('source', {
-            describe: 'The source directory where to look for translations (defaults to current working directory)',
-            type: 'string',
-            normalize: true,
-        })
-        .positional('defaultLocale', {
-            description: 'Sets the default locale (the locale used in code for your strings)',
-            type: 'string',
-            coerce: x => {
-                if (!isValidLocale(x)) {
-                    console.error('Invalid locale ' + x);
-                    process.exit(1);
-                }
-                return x;
-            },
-        })
-        .positional('generateDefault', {
-            description: 'Also generates a translation file for the default locale',
-            type: 'boolean',
-        })
-        .positional('generateDefault', {
-            description: 'Also generates the default locale translation file (which does not need to be translated)',
-            type: 'boolean',
-        })
-        .positional('locales', {
-            description: 'Comma separated list of locales to generate (others than the default one)',
-            type: 'string',
-            coerce: x => {
-                if (typeof x !== 'string' || !x || !/^[a-zA-Z]+(\-[a-zA-Z]+)?$/.test(x)) {
-                    console.error('Invalid locale ' + x);
-                    process.exit(1);
-                }
-                return x;
-            },
-        })
-        , async args => {
-            try {
-
-                const locales = args.locales?.split(',')
-                    .map(x => x.trim())
-                    .filter(x => x !== args.defaultLocale);
-                if (!locales?.length) {
-                    console.error('You must provide at least one locale thats different from your default locale')
-                    process.exit(1);
-                }
-                if (locales.some(x => !isValidLocale(x))) {
-                    console.error('--locales argument is invalid')
-                    process.exit(1);
-                }
-
-                // create adapter
-                const outdir = path.join(process.cwd(), args.outDir);
-                const adapter = getAdapter(args.format, outdir);
-
-                // collect from sources
-                console.log('Collecting from sources...');
-                const { collected, files } = await collect(args.source || '.', adapter, args.defaultLocale);
-                console.log(`...found ${Object.keys(collected.resources).length} translatable items over ${files} files with default language ${collected.targetLanguage}`);
-
-
-                // load other locales
-                const others = (await adapter.loadLocales(locales))
-                    .filter(x => x.targetLanguage !== collected.targetLanguage);
-
-                console.log(`Updating ${others.length} other translations...`);
-
-                // reconciliate existing
-                for (const l of others) {
-                    const collectedCopy = JSON.parse(JSON.stringify(collected));
-                    const { dirty, missing, same } = reconciliate(l, collectedCopy);
-                    const feats: string[] = [];
-                    if (dirty) {
-                        feats.push(`${dirty} dirty translations (source changed)`);
-                    }
-                    if (missing) {
-                        feats.push(`${missing} missing translations`);
-                    }
-                    if (same.length) {
-                        feats.push(`${same.length} translations matching original (ex: ${same[0]})`);
-                    }
-                    if (!feats.length) {
-                        console.log(`${l.targetLanguage} is OK ♥`);
-                    } else {
-                        console.log(`${l.targetLanguage} has ${feats.join(', ')}`);
-                    }
-                }
-
-                // write others
-                console.log(`Writing results...`);
-                for (const l of others) {
-                    await adapter.write(l);
-                }
-
-                if (args.defaultLocale) {
-                    await adapter.write(collected);
-                }
-                console.log(`I'm done ♥`);
-            } catch (e) {
-                console.error('Command failed', e);
-                process.exit(1);
-            }
-        })
-    .argv;

package/src/core/load.ts

@@ -1,82 +0,0 @@
-import { addLocale } from './locale-list';
-import type { TranslationTarget } from './interfaces';
-
-/**
- * Loads a locale generated from CLI
- * @param filePath The file path to load
- * @param merge If true, then the translations will be merged with already existing translations.
- */
-export function loadJsonLocale(obj: GroupedTranslation, merge?: boolean): void
-export function loadJsonLocale(url: string, merge?: boolean): Promise<void>
-export function loadJsonLocale(urlOrObj: string | GroupedTranslation, merge?: boolean) {
-    if (typeof urlOrObj === 'string') {
-        return fetch(urlOrObj).then(async response => {
-            if (!response.ok) {
-                throw new Error(`Failed to fetch ${urlOrObj}: ${response.statusText}`);
-            }
-            const text = await response.json();
-            if (typeof text !== 'object') {
-                throw new Error(`Expecting ${urlOrObj} to be a JSON object`);
-            }
-            return loadJsonLocale(text, merge);
-        });
-    }
-
-    const transformed = convertLocale(ungroupTranslation(urlOrObj));
-    addLocale(urlOrObj.targetLanguage, transformed, merge);
-}
-
-
-export interface CollectItem {
-    source?: TranslationTarget;
-    target?: TranslationTarget | null;
-    dirty?: boolean;
-}
-
-export interface CollectResult {
-    [id: string]: CollectItem;
-}
-
-export interface Translation {
-    resources: CollectResult;
-    sourceLanguage?: string;
-    targetLanguage: string;
-}
-
-
-export interface GroupedTranslation {
-    resources: { [namespace: string]: CollectResult };
-    sourceLanguage?: string;
-    targetLanguage: string;
-}
-
-
-export function ungroupTranslation(translation: GroupedTranslation): Translation {
-    const result: Translation = {
-        targetLanguage: translation.targetLanguage,
-        sourceLanguage: translation.sourceLanguage,
-        resources: {},
-    };
-    for (const [namespace, data] of Object.entries(translation.resources)) {
-        for (const [id, val] of Object.entries(data ?? {})) {
-            if (namespace === '$default') {
-                result.resources[id] = val;
-            } else {
-                result.resources[`${namespace}.${id}`] = val;
-            }
-        }
-    }
-    return result;
-}
-
-
-
-export function convertLocale(locale: Translation): { [key: string]: TranslationTarget } {
-    const ret: { [key: string]: TranslationTarget } = {};
-    for (const [k, v] of Object.entries(locale.resources)) {
-        if (v.target) {
-            ret[k] = v.target;
-        }
-    }
-    return ret;
-}

package/src/core/tag.ts

@@ -1,48 +0,0 @@
-import { smartLoc } from './smartloc';
-import { LocLiteral, LocStr } from './interfaces';
-import { autoGenerateId } from './utils';
-
-
-type Templater = (literals: TemplateStringsArray, ...placeholders: LocLiteral[]) => LocStr;
-// just a signature.
-declare function _tagSig(id: string): Templater
-declare function _tagSig(literals: TemplateStringsArray, ...placeholders: LocLiteral[]): LocStr;
-type TagSignature = typeof _tagSig;
-type LocTag = TagSignature & {
-    /** Creates a pluralizable string (will have two versions to be translated based on the given count: singlular & plural) */
-    plural(count: number): TagSignature;
-    /** Does nothing, except that the translation will not be collected (use for formatting purposes) */
-    nocollect: LocTag
-};
-
-
-
-
-function __loc(count: number | undefined, idOrLiterals: string | TemplateStringsArray, ...ph: LocLiteral[]): Templater | LocStr {
-    if (typeof idOrLiterals === 'string') {
-        const id = idOrLiterals;
-        return (literals: TemplateStringsArray, ...placeholders: LocLiteral[]) => {
-            return smartLoc({ id, literals, placeholders, count });
-        };
-    }
-    return smartLoc({ id: autoGenerateId(idOrLiterals), literals: idOrLiterals, placeholders: ph, count });
-}
-
-function _loc(id: string): Templater;
-function _loc(idOrLiteralsOrCount: string | TemplateStringsArray, ...ph: LocLiteral[]): LocStr;
-function _loc(idOrLiteralsOrCount: string | TemplateStringsArray, ...ph: LocLiteral[]): Templater | LocStr {
-    return __loc(undefined, idOrLiteralsOrCount, ...ph);
-}
-_loc.plural = (count: number) => {
-    function templater(id: string): Templater;
-    function templater(template: TemplateStringsArray, ...placeholders: LocLiteral[]): Templater;
-    function templater(idOrLiterals: string | TemplateStringsArray, ...ph: LocLiteral[]): Templater | LocStr {
-        return __loc(count, idOrLiterals, ...ph);
-    }
-    return templater;
-};
-_loc.nocollect = () => {
-    return _loc;
-};
-
-export const loc: LocTag = _loc as any;

package/src/core/utils.tsx

@@ -1,24 +0,0 @@
-import { sha1 } from 'js-sha1';
-import React from 'react';
-
-export function autoGenerateId(str: TemplateStringsArray | string[]): string {
-    const sha = sha1(str.join('|'));
-    return 'sha1.' + sha;
-}
-
-export function getLocaleCode(locale: string) {
-    return locale && /^[a-z]+/.exec(locale.toLowerCase())?.[0] || undefined;
-}
-
-
-export function asFragment(children: React.ReactNode[]): React.ReactNode {
-    if (children.length === 1) {
-        return children[0];
-    }
-    return <React.Fragment>{children.map((x, i) => {
-        if (React.isValidElement(x) && !x.key) {
-            return <React.Fragment key={i}>{x}</React.Fragment>;
-        }
-        return x;
-    })}</React.Fragment>;
-}

package/src/node/index.ts

@@ -1 +0,0 @@
-export * from './load';

package/src/node/load.ts

@@ -1,32 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import { loadLocaleFrom } from '../adapters';
-import { addLocale } from '../core/locale-list';
-import { convertLocale } from 'src/core/load';
-
-/**
- * Loads all locales generated from CLI
- * @param dirPath The file directory where to look for translation
- * @param merge If true, then the translations will be merged with already existing translations.
- */
-export async function loadAllLocales(dirPath: string, merge?: boolean) {
-    for (const f of await fs.readdir(dirPath)) {
-        await loadLocale(path.join(dirPath, f), merge);
-    }
-}
-
-
-/**
- * Loads a locale generated from CLI
- * @param filePath The file path to load
- * @param merge If true, then the translations will be merged with already existing translations.
- */
-export async function loadLocale(filePath: string, merge?: boolean) {
-    const locale = await loadLocaleFrom(filePath);
-    if (!locale) {
-        return false;
-    }
-    const transformed = convertLocale(locale);
-    addLocale(locale.targetLanguage, transformed, merge);
-    return true;
-}

package/test/collect.spec.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-import { collectFromSource, Loc } from '../src/cli/collect';
-import { autoGenerateId } from '../src/core/utils';
-
-describe('Collection', () => {
-    function col(content: string) {
-        const all: Loc[] = [];
-        const ids = new Map();
-        collectFromSource(content, ids, all);
-        return all.map(x => {
-            const ret: { id: string; val: string; plural?: boolean } = {
-                id: x.id,
-                val: x.source,
-            };
-            if (x.plural) {
-                ret.plural = x.plural;
-            }
-            return ret;
-        });
-    }
-
-    it('collect with id', () => {
-        const all = col('blah`` loc("myId") `String ${with} some ${params}`');
-        expect(all).toEqual([
-            { id: 'myId', val: 'String {0} some {1}' }
-        ])
-    });
-
-
-    it('collect without id', () => {
-        const all = col('blah`` loc `String ${with} some ${params}`');
-        const id = autoGenerateId(['String ', ' some ', '']);
-        expect(all).toEqual([
-            { id, val: 'String {0} some {1}' }
-        ])
-    });
-
-    it('collects plural', () => {
-        const all = col('blah`` loc.plural(42) `String ${with} some ${params}`');
-        const id = autoGenerateId(['String ', ' some ', '']);
-        expect(all).toEqual([
-            { id, val: 'String {0} some {1}', plural: true }
-        ])
-    });
-});

package/test/reconciliation.spec.ts

@@ -1,132 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-import { reconciliate } from '../src/cli/reconciliate';
-import { CollectResult } from '../src/cli/interfaces';
-
-
-describe('Reconciliation', () => {
-
-    function recon(translated: CollectResult, orig: CollectResult) {
-        return reconciliate({
-            resources: translated,
-            sourceLanguage: 'en',
-            targetLanguage: 'fr',
-        }, {
-            resources: orig,
-            targetLanguage: 'en',
-        });
-    }
-
-    function setupAB() {
-        const orig: CollectResult = {
-            a: { target: 'Sentence A' },
-            b: { target: 'Sentence B' },
-        };
-        const trans: CollectResult = {
-            a: { source: 'Sentence A', target: 'Phrase A' },
-            b: { source: 'Sentence B', target: 'Phrase B' },
-        };
-        return { orig, trans };
-    }
-
-    it('does nothing when ok', () => {
-        const { orig, trans } = setupAB();
-        const { dirty, missing, same } = recon(trans, orig);
-        expect(dirty).toEqual(0);
-        expect(missing).toEqual(0);
-        expect(same).toEqual([]);
-    });
-
-
-    it('marks as dirty', () => {
-        const { orig, trans } = setupAB();
-
-        // change 'in code' sentence
-        orig.a.target = 'New sentence A';
-
-        const { dirty, missing, same } = recon(trans, orig);
-        expect(dirty).toEqual(1);
-        expect(missing).toEqual(0);
-        expect(same).toEqual([]);
-        expect(trans.a.dirty).toBe(true);
-        expect(trans.a.source).toEqual('New sentence A');
-    });
-
-
-    it('adds new sentence', () => {
-        const { orig, trans } = setupAB();
-
-        // add new 'in code' sentence
-        orig.c = { target: 'Sentence C' };
-
-        const { dirty, missing, same } = recon(trans, orig);
-        expect(dirty).toEqual(0);
-        expect(missing).toEqual(1);
-        expect(same).toEqual([]);
-        expect(trans.c.source).toEqual('Sentence C');
-        expect(trans.c.target).toBeUndefined();
-    });
-
-
-
-    it('finds on ID change', () => {
-        const { orig, trans } = setupAB();
-
-        // add new 'in code' sentence
-        orig.newb = orig.b;
-        delete orig.b;
-
-        const { dirty, missing, same } = recon(trans, orig);
-        expect(dirty).toEqual(0);
-        expect(missing).toEqual(0);
-        expect(same).toEqual([]);
-        expect(trans.b).toBeUndefined();
-        expect(trans.newb).toBeDefined();
-        expect(trans.newb.source).toEqual('Sentence B');
-    });
-
-
-    it('finds on ID and content change change', () => {
-        const { orig, trans } = setupAB();
-
-        // add new 'in code' sentence
-        orig.newb = orig.b;
-        orig.newb.target = 'Sentence B bis';
-        delete orig.b;
-
-        const { dirty, missing, same } = recon(trans, orig);
-        expect(dirty).toEqual(1); // source changed => dirty
-        expect(missing).toEqual(0);
-        expect(same).toEqual([]);
-        expect(trans.b).toBeUndefined();
-        expect(trans.newb).toBeDefined();
-        expect(trans.newb.source).toEqual('Sentence B bis');
-        expect(trans.newb.target).toEqual('Phrase B');
-    });
-
-
-
-    it('finds multiple ID and content change', () => {
-        const { orig, trans } = setupAB();
-
-        // add new 'in code' sentence
-        orig.newa = orig.a;
-        orig.newb = orig.b;
-        orig.newa.target = 'Sentence A bis';
-        orig.newb.target = 'Sentence B bis';
-        delete orig.b;
-        delete orig.a;
-
-        const { dirty, missing, same } = recon(trans, orig);
-        expect(dirty).toEqual(2); // source changed => dirty
-        expect(missing).toEqual(0);
-        expect(same).toEqual([]);
-        expect(trans.a).toBeUndefined();
-        expect(trans.b).toBeUndefined();
-        expect(trans.newa).toBeDefined();
-        expect(trans.newb).toBeDefined();
-        expect(trans.newa.source).toEqual('Sentence A bis');
-        expect(trans.newb.source).toEqual('Sentence B bis');
-        expect(trans.newa.target).toEqual('Phrase A');
-        expect(trans.newb.target).toEqual('Phrase B');
-    });
-});

package/test/serialization.spec.ts

@@ -1,162 +0,0 @@
-import { describe, it, expect, beforeEach } from 'bun:test';
-import { loc, setDefaultLocale, addLocale, withLocales, clearLocales, toJsonStorable, SingleLoc, MultiLoc, jsonParseLocalized, toLocalizable } from '../src';
-import { withSerializationContext, SmartLoc } from '../src/core/smartloc';
-
-
-describe('Json serialization', () => {
-
-    beforeEach(() => {
-        clearLocales();
-        setDefaultLocale('en-US');
-    })
-
-    it('toJsonStorable() handles singleloc values', () => {
-        const str = new SingleLoc(`a translation`);
-        expect(toJsonStorable(str)).toEqual('i18n/single:a translation')
-    });
-
-    it('toJsonStorable() handles singleloc props', () => {
-        const str = { value: new SingleLoc(`a translation`) };
-        expect(toJsonStorable(str)).toEqual({ value: 'i18n/single:a translation' })
-    });
-
-
-    it('toJsonStorable() handles singleloc arrays', () => {
-        const str = { value: [new SingleLoc(`first`), new SingleLoc(`second`)] };
-        expect(toJsonStorable(str)).toEqual({ value: ['i18n/single:first', 'i18n/single:second'] })
-    });
-
-
-    it('toJsonStorable() handles multiloc', () => {
-        const str = { value: new MultiLoc({ fr: 'FR value', en: 'EN value' }) };
-        expect(toJsonStorable(str)).toEqual({ value: { 'i18n:fr': 'FR value', 'i18n:en': 'EN value', } })
-    });
-
-
-    it('toJsonStorable() handles smartloc with translate option to "id"', () => {
-        const str = { value: loc('something')`Something` };
-        const received = toJsonStorable(str, { nonSelfDescriptive: 'id' });
-        expect(received).toEqual({ value: 'i18n/id:something' })
-    });
-
-    it('toJsonStorable() handles smartloc with countable translate', () => {
-        const str = { value: loc.plural(42)('something')`Something ${42}` };
-        expect(toJsonStorable(str, { nonSelfDescriptive: 'id' })).toEqual({ value: {
-            i18n: 'something',
-            data: [42],
-            count: 42
-        } })
-    });
-
-
-    it('toJsonStorable() handles smartloc with inclusions', () => {
-        const str = { value: loc('something')`Answer: ${42} with ${'str'}` };
-        expect(toJsonStorable(str, { nonSelfDescriptive: 'id' })).toEqual({
-            value: {
-                i18n: 'something',
-                data: [42, 'str']
-            }
-        })
-    });
-
-    it('toJsonStorable() handles smartloc with translate option to "toMulti"', () => {
-        const str = { value: loc('something')`Something` };
-        addLocale('fr', { something: 'Quelque chose' })
-        expect(toJsonStorable(str, { nonSelfDescriptive: 'toMulti' })).toEqual({ value: { 'i18n:fr': 'Quelque chose', 'i18n:en-US': 'Something', } })
-    });
-
-
-    it('toJsonStorable() handles smartloc with translate option to "skip/"', () => {
-        const str = { value: loc('something')`Something` };
-        addLocale('fr', { something: 'Quelque chose' })
-        const got = toJsonStorable(str, { nonSelfDescriptive: 'skip' });
-        expect(got).toEqual(str);
-    });
-
-    it('can parse a multiloc', () => {
-        const str = { value: new MultiLoc({ fr: 'FR value', en: 'EN value' }) };
-        const serial = withSerializationContext(() => JSON.stringify(str));
-        const deser = jsonParseLocalized(serial);
-        expect(deser.value).toBeInstanceOf(MultiLoc);
-        // check translation
-        addLocale('fr-FR', {});
-        const translated = withLocales(['fr'], () => JSON.stringify(deser));
-        expect(translated).toEqual('{"value":"FR value"}');
-    });
-
-
-    it('can parse a singleloc', () => {
-        const str = { value: [new SingleLoc(`first`), new SingleLoc(`second`)] };
-        const serial = withSerializationContext(() => JSON.stringify(str));
-        const deser = jsonParseLocalized(serial);
-        expect(deser.value).toBeInstanceOf(Array);
-        for (const k of deser.value) {
-            expect(k).toBeInstanceOf(SingleLoc);
-        }
-        // check translation
-        addLocale('fr-FR', {});
-        const translated = withLocales(['fr'], () => JSON.stringify(deser));
-        expect(translated).toEqual('{"value":["first","second"]}');
-    })
-
-
-    it('can parse a smartloc', () => {
-        // must be registered to deserialize ids
-        addLocale('fr', { something: 'Quelque chose' });
-        addLocale('en-US', { something: 'Something' });
-
-        const str = { value: [loc('something')`Something`] };
-        const serial = withSerializationContext(() => JSON.stringify(str));
-        const deser = jsonParseLocalized(serial);
-        expect(deser.value).toBeInstanceOf(Array);
-        for (const k of deser.value) {
-            expect(k).toBeInstanceOf(SmartLoc);
-        }
-        // check translation
-        let translated = withLocales(['fr'], () => JSON.stringify(deser));
-        expect(translated).toEqual('{"value":["Quelque chose"]}');
-        translated = withLocales(['en'], () => JSON.stringify(deser));
-        expect(translated).toEqual('{"value":["Something"]}');
-    })
-
-
-    it('can parse a smartloc with arguments', () => {
-        // must be registered to deserialize ids
-        addLocale('fr', { something: 'Quelque chose {0} {1}' });
-        addLocale('en-US', { something: 'Something {0} {1}' });
-
-        const str = { value: [loc('something')`Something ${'str'} ${42}`] };
-        const serial = withSerializationContext(() => JSON.stringify(str));
-        const deser = jsonParseLocalized(serial);
-        expect(deser.value).toBeInstanceOf(Array);
-        for (const k of deser.value) {
-            expect(k).toBeInstanceOf(SmartLoc);
-        }
-        // check translation
-        let translated = withLocales(['fr'], () => JSON.stringify(deser));
-        expect(translated).toEqual('{"value":["Quelque chose str 42"]}');
-        translated = withLocales(['en'], () => JSON.stringify(deser));
-        expect(translated).toEqual('{"value":["Something str 42"]}');
-    });
-
-
-    it('should return the same object instance if no smartloc instance', async () => {
-        const obj = {
-            a: { b: [42, { c: 51 }] }
-        };
-        const ret = toJsonStorable(obj);
-        expect(obj === ret).toBe(true);
-        const deser = toLocalizable(ret);
-        expect(obj === deser).toBe(true);
-    });
-
-    it('should return other instance if no smartloc instance', async () => {
-        const obj = {
-            a: { b: [42, { c: loc`Whatever` }] }
-        };
-        const ret = toJsonStorable(obj);
-        expect(obj === ret).toBe(false);
-        const deser = toLocalizable(ret);
-        expect(ret === deser).toBe(false);
-    });
-});