smartloc 1.2.2 → 2.0.1

package/{graphql.js → src/graphql.ts}

@@ -1,23 +1,19 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.localizedContextObject = exports.localizedContext = exports.localizeSchema = exports.GLocString = void 0;
-const graphql_1 = require("graphql");
-const graphql_2 = require("graphql");
-const _1 = require(".");
-const accept_language_parser_1 = __importDefault(require("accept-language-parser"));
-const smartloc_1 = require("./core/smartloc");
-const json_utils_1 = require("./core/json-utils");
-const language_1 = require("graphql/language");
+import { GraphQLSchema, GraphQLObjectType } from 'graphql';
+import { GraphQLScalarType, GraphQLList, GraphQLUnionType, GraphQLInterfaceType, GraphQLField, GraphQLNonNull, } from 'graphql';
+import express from 'express';
+import { isLocStr } from '.';
+import parser from 'accept-language-parser';
+import { withLocales, multiLoc, singleLoc } from './core/smartloc';
+import { translateInContext } from './core/json-utils';
+import { Kind } from 'graphql/language';
+
 const INVALID_MSG = `Invalid localizable string input. Expecting either a string in the default locale, or an object like {"en": "English translation", "fr": "Traduction française"}`;
-function parseValue(value) {
+function parseValue(value: any) {
     if (!value) {
         return null;
     }
     if (typeof value === 'string') {
-        return new smartloc_1.SingleLoc(value);
+        return singleLoc(value);
     }
     if (typeof value === 'object') {
         for (const v of Object.values(value)) {
@@ -25,21 +21,22 @@ function parseValue(value) {
                 throw new TypeError(INVALID_MSG);
             }
         }
-        return new smartloc_1.MultiLoc(value);
+        return multiLoc(value);
     }
     throw new TypeError(INVALID_MSG);
 }
-function parseObject(ast, variables) {
+
+function parseObject(ast: any, variables: any) {
     const value = Object.create(null);
     let hasValue = false;
-    ast.fields.forEach(field => {
-        let val;
+    ast.fields.forEach((field: any) => {
+        let val: string;
         switch (field.value.kind) {
-            case language_1.Kind.STRING:
+            case Kind.STRING:
                 val = field.value.value;
                 break;
-            case language_1.Kind.VARIABLE: {
-                val = variables === null || variables === void 0 ? void 0 : variables[field.value.name.value];
+            case Kind.VARIABLE: {
+                val = variables?.[field.value.name.value];
                 break;
             }
             default:
@@ -57,17 +54,18 @@ function parseObject(ast, variables) {
     if (!hasValue) {
         return null;
     }
-    return new smartloc_1.MultiLoc(value);
+    return multiLoc(value);
 }
-function parseLiteral(ast, variables) {
+
+function parseLiteral(ast: any, variables: any) {
     switch (ast.kind) {
-        case language_1.Kind.STRING:
-            return new smartloc_1.SingleLoc(ast.value);
-        case language_1.Kind.OBJECT:
+        case Kind.STRING:
+            return singleLoc(ast.value);
+        case Kind.OBJECT:
             return parseObject(ast, variables);
-        case language_1.Kind.NULL:
+        case Kind.NULL:
             return null;
-        case language_1.Kind.VARIABLE: {
+        case Kind.VARIABLE: {
             const name = ast.name.value;
             return variables ? parseValue(variables[name]) : undefined;
         }
@@ -75,27 +73,32 @@ function parseLiteral(ast, variables) {
             throw new TypeError(`Invalid localizable string input (${ast.kind}). Expecting either a string in the default locale, or an object like {"en": "English translation", "fr": "Traduction française"}`);
     }
 }
+
 const localeTag = Symbol('_smartloc_locale');
-exports.GLocString = new graphql_2.GraphQLScalarType({
+export const GLocString = new GraphQLScalarType({
     name: 'LocalizedString',
     description: 'A string which value depends on Accept-Language request headers.',
     serialize(value) {
-        if (_1.isLocStr(value)) {
+        if (isLocStr(value)) {
             throw new TypeError(`You must apply the localizeSchema() patch to fix your schema when using LocalizedString`);
         }
+
         if (value === null || value === undefined || typeof value === 'string') {
             return value;
         }
+
         throw new TypeError(`Graphql field of type LocalizedString expecting a localizable string`);
     },
     parseValue,
     parseLiteral,
 });
+
+
 const patchedTag = Symbol('_smartloc_patched');
-function localizeSchema(schema) {
+export function localizeSchema(schema: GraphQLSchema) {
     const patched = new Set();
-    function patchObject(type) {
-        if (!(type instanceof graphql_1.GraphQLObjectType)) {
+    function patchObject(type: GraphQLObjectType) {
+        if (!(type instanceof GraphQLObjectType)) {
             return;
         }
         const fields = type.getFields();
@@ -104,91 +107,100 @@ function localizeSchema(schema) {
         }
         patched.add(type);
         for (const [id, field] of Object.entries(fields)) {
-            let ft = field.type;
+            let ft = (field as any).type;
             if (!ft) {
                 continue;
             }
+
             while (true) {
-                if (ft instanceof graphql_2.GraphQLList || ft instanceof graphql_2.GraphQLNonNull) {
+                if (ft instanceof GraphQLList || ft instanceof GraphQLNonNull) {
                     ft = ft.ofType;
-                }
-                else {
+                } else {
                     break;
                 }
             }
-            if (ft instanceof graphql_2.GraphQLUnionType) {
+            if (ft instanceof GraphQLUnionType) {
                 for (const t of ft.getTypes()) {
                     patchObject(t);
                 }
             }
-            if (ft instanceof graphql_2.GraphQLInterfaceType) {
+            if (ft instanceof GraphQLInterfaceType) {
                 for (const t of schema.getPossibleTypes(ft)) {
                     patchObject(t);
                 }
-            }
-            else if (ft instanceof graphql_1.GraphQLObjectType) {
+            } else if (ft instanceof GraphQLObjectType) {
                 patchObject(ft);
-            }
-            else if (ft === exports.GLocString) {
+            } else if (ft === GLocString) {
                 patchField(id, field);
-            }
-            else if (ft instanceof graphql_2.GraphQLScalarType && (ft.name === 'JSON' || ft.name === 'JSONObject')) {
+            } else if (ft instanceof GraphQLScalarType && (ft.name === 'JSON' || ft.name === 'JSONObject')) {
                 patchField(id, field);
             }
         }
     }
-    patchObject(schema.getQueryType());
-    patchObject(schema.getMutationType());
+
+    patchObject(schema.getQueryType() as GraphQLObjectType);
+    patchObject(schema.getMutationType() as GraphQLObjectType);
     return schema;
 }
-exports.localizeSchema = localizeSchema;
-function patchField(id, field) {
-    var _a;
-    if ((_a = field.resolve) === null || _a === void 0 ? void 0 : _a[patchedTag]) {
+
+function patchField(id: string, field: GraphQLField<any, any>) {
+    if ((field.resolve as any)?.[patchedTag]) {
         return;
     }
     const or = field.resolve;
     field.resolve = async function (source, args, ctx, info) {
         const value = or
             ? await or.apply(this, [source, args, ctx, info])
-            : source === null || source === void 0 ? void 0 : source[id];
+            : source?.[id];
         const locales = ctx && typeof ctx === 'object'
-            ? ctx === null || ctx === void 0 ? void 0 : ctx[localeTag] : null;
-        return smartloc_1.withLocales(locales, () => json_utils_1.translateInContext(value));
+            ? ctx?.[localeTag]
+            : null;
+        return withLocales(locales, () => translateInContext(value));
     };
-    field.resolve[patchedTag] = true;
+    (field.resolve as any)[patchedTag] = true;
 }
-function localizedContext(context) {
+
+
+
+export interface ExpressContext {
+    req: express.Request;
+    res: express.Response;
+}
+export type Context<T = object> = T;
+export type ContextFunction<FunctionParams = any, ProducedContext = object> = (
+    context: FunctionParams,
+) => Context<ProducedContext> | Promise<Context<ProducedContext>>;
+
+export function localizedContext(context: ContextFunction<ExpressContext, Context>): ContextFunction<ExpressContext, Context> {
     return app => {
         const ctx = context(app);
         if ('then' in ctx && typeof ctx.then === 'function') {
             return ctx.then(x => patchContextObj(app.req, x));
         }
         return patchContextObj(app.req, ctx);
-    };
+    }
 }
-exports.localizedContext = localizedContext;
-function localizedContextObject(ctx, locales) {
+
+export function localizedContextObject<T>(ctx: T, locales: string[]): T {
     if (!ctx || typeof ctx !== 'object') {
         return ctx;
     }
-    ctx[localeTag] = locales;
+    (ctx as any)[localeTag] = locales;
     return ctx;
 }
-exports.localizedContextObject = localizedContextObject;
-function patchContextObj(req, ctx) {
-    var _a, _b;
+
+function patchContextObj(req: express.Request, ctx: any) {
     if (!ctx || typeof ctx !== 'object') {
         return ctx;
     }
     if (ctx[localeTag]) {
         return ctx;
     }
-    const lh = (_a = req === null || req === void 0 ? void 0 : req.headers) === null || _a === void 0 ? void 0 : _a['accept-language'];
+    const lh = req?.headers?.['accept-language'];
     if (!lh) {
         return ctx;
     }
-    ctx[localeTag] = (_b = accept_language_parser_1.default.parse(lh)) === null || _b === void 0 ? void 0 : _b.map(x => x.region ? `${x.code}-${x.region}` : x.code);
+    ctx[localeTag] = parser.parse(lh)
+        ?.map(x => x.region ? `${x.code}-${x.region}` : x.code);
     return ctx;
-}
-//# sourceMappingURL=graphql.js.map
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export { changeLocale, addLocale, clearLocales, removeLocale, setDefaultLocale, getDefaultLocale } from './core/locale-list';
+export { loc } from './core/tag';
+export { withLocales, singleLoc, multiLoc, joinArray, withSerializationContext, useAsString } from './core/smartloc';
+export { isLocStr } from './core/literal';
+export type { LocStr, TranslationOf, StorableOf } from './core/interfaces';
+export { translateInContext, jsonParseLocalized, toJsonStorable, translateObject, toLocalizable } from './core/json-utils';
+export { loadJsonLocale } from './core/load';

package/src/node/index.ts

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

package/src/node/load.ts

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,162 @@
+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);
+    });
+});