@cozeloop/intl 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# @cozeloop/intl
+
+Internationalization(intl) runtime for CozeLoop

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { intlClient } from './intl-client';
+export type { IntlClientOptions } from './intl-client';

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intlClient = void 0;
+var intl_client_1 = require("./intl-client");
+Object.defineProperty(exports, "intlClient", { enumerable: true, get: function () { return intl_client_1.intlClient; } });
+//# sourceMappingURL=index.js.map

package/dist/intl-client.d.ts

@@ -0,0 +1,18 @@
+import { type DetectorOptions } from 'i18next-browser-languagedetector';
+import { type InitOptions } from 'i18next';
+export interface IntlClientOptions extends InitOptions {
+    /** {@link DetectorOptions} for i18next-browser-languagedetector  */
+    detection?: DetectorOptions;
+}
+export declare class IntlClient {
+    get i18next(): import("i18next").i18n;
+    get lang(): string;
+    get language(): string;
+    setLang(lng: string): Promise<void>;
+    init(options: IntlClientOptions): Promise<void>;
+    t(key: string, defaultValue?: string): string;
+    t(key: string, interpolation?: Record<string, unknown>, defaultValue?: string): string;
+    /** i18n unsafely, **TRUST THE KEY :)** */
+    unsafeT(key: string, interpolation?: Record<string, unknown>, defaultValue?: string): string;
+}
+export declare const intlClient: IntlClient;

package/dist/intl-client.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intlClient = exports.IntlClient = void 0;
+const i18next_browser_languagedetector_1 = __importDefault(require("i18next-browser-languagedetector"));
+const i18next_1 = __importDefault(require("i18next"));
+const react_postprocessor_1 = require("./react-postprocessor");
+const intl_format_1 = require("./intl-format");
+class IntlClient {
+    get i18next() {
+        return i18next_1.default;
+    }
+    get lang() {
+        return i18next_1.default.language;
+    }
+    get language() {
+        return i18next_1.default.language;
+    }
+    async setLang(lng) {
+        await i18next_1.default.changeLanguage(lng);
+    }
+    async init(options) {
+        await i18next_1.default
+            .use(i18next_browser_languagedetector_1.default)
+            .use(intl_format_1.IntlFormat)
+            .use(new react_postprocessor_1.ReactPostprocessor())
+            .init({
+            ...options,
+            postProcess: [react_postprocessor_1.ReactPostprocessor.processorName],
+        });
+    }
+    t(key, interpolationOrDefaultValue, defaultValue) {
+        var _a, _b;
+        if (typeof interpolationOrDefaultValue === 'string') {
+            return ((_a = i18next_1.default.t(key, { defaultValue: interpolationOrDefaultValue })) !== null && _a !== void 0 ? _a : key);
+        }
+        return ((_b = i18next_1.default.t(key, { ...interpolationOrDefaultValue, defaultValue })) !== null && _b !== void 0 ? _b : key);
+    }
+    /** i18n unsafely, **TRUST THE KEY :)** */
+    unsafeT(key, interpolation, defaultValue) {
+        try {
+            return i18next_1.default.t(key, { ...interpolation, defaultValue });
+        }
+        catch (e) {
+            console.warn('Unsafe translate', e);
+            return defaultValue !== null && defaultValue !== void 0 ? defaultValue : key;
+        }
+    }
+}
+exports.IntlClient = IntlClient;
+exports.intlClient = new IntlClient();
+//# sourceMappingURL=intl-client.js.map

package/dist/intl-format.d.ts

@@ -0,0 +1,18 @@
+import { type ModuleType, type i18n as I18next, type TOptions } from 'i18next';
+interface Resolved {
+    res: string;
+    usedKey: string;
+    exactUsedKey: string;
+    usedLng: string;
+    usedNS: string;
+}
+export declare class IntlFormat {
+    static type: ModuleType;
+    private readonly cache;
+    init(i18next: I18next): void;
+    parse(res: string, options: TOptions & Record<string, unknown>, lng: string, ns: string, key: string, info?: {
+        resolved?: Resolved;
+    }): unknown;
+    clearCache(): void;
+}
+export {};

package/dist/intl-format.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntlFormat = void 0;
+/* eslint-disable max-params -- skip */
+const intl_messageformat_1 = __importDefault(require("intl-messageformat"));
+const utils_1 = require("./utils");
+class IntlFormat {
+    constructor() {
+        this.cache = new Map();
+    }
+    init(i18next) {
+        // init with i18next
+        this.cache.clear();
+    }
+    parse(res, options, lng, ns, key, info) {
+        var _a, _b;
+        try {
+            const message = ((_a = info === null || info === void 0 ? void 0 : info.resolved) === null || _a === void 0 ? void 0 : _a.res)
+                ? res
+                : `${(_b = options.defaultValue) !== null && _b !== void 0 ? _b : key}`;
+            const cacheKey = `${ns}###${key}###${res}`;
+            const messageFormat = this.cache.has(cacheKey)
+                ? this.cache.get(cacheKey)
+                : this.cache
+                    .set(cacheKey, new intl_messageformat_1.default(message, lng, undefined, {}))
+                    .get(cacheKey);
+            return messageFormat
+                ? messageFormat.format((0, utils_1.fillMissingOptions)(messageFormat, options))
+                : res;
+        }
+        catch (e) {
+            console.warn(`Failed to parse ${key}, ${e}`);
+            return res;
+        }
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+}
+exports.IntlFormat = IntlFormat;
+IntlFormat.type = 'i18nFormat';
+//# sourceMappingURL=intl-format.js.map

package/dist/react-postprocessor.d.ts

@@ -0,0 +1,7 @@
+import { type PostProcessorModule, type TOptions } from 'i18next';
+export declare class ReactPostprocessor implements PostProcessorModule {
+    readonly type = "postProcessor";
+    readonly name = "ReactPostprocessor";
+    static processorName: string;
+    process(value: string | unknown[], key: string | string[], options: TOptions): string;
+}

package/dist/react-postprocessor.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactPostprocessor = void 0;
+const react_1 = require("react");
+const utils_1 = require("./utils");
+class ReactPostprocessor {
+    constructor() {
+        this.type = 'postProcessor';
+        this.name = 'ReactPostprocessor';
+    }
+    process(value, key, options) {
+        // won't happen, only in case
+        if (!value || !value.length) {
+            return `${options.defaultValue || key}`;
+        }
+        if (Array.isArray(value)) {
+            const v = value;
+            const hasReactElements = v.some(it => (0, react_1.isValidElement)(it));
+            if (!hasReactElements) {
+                return v.map(it => (0, utils_1.stringifyVal)(it)).join('');
+            }
+            return (0, react_1.createElement)(react_1.Fragment, null, ...v.map((it, index) => {
+                var _a;
+                return (0, react_1.isValidElement)(it)
+                    ? (0, react_1.cloneElement)(it, { key: (_a = it.key) !== null && _a !== void 0 ? _a : index, ...it.props })
+                    : (0, utils_1.stringifyVal)(it);
+            }));
+        }
+        return value;
+    }
+}
+exports.ReactPostprocessor = ReactPostprocessor;
+ReactPostprocessor.processorName = 'ReactPostprocessor';
+//# sourceMappingURL=react-postprocessor.js.map

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+import type IntlMessageFormat from 'intl-messageformat';
+export declare function stringifyVal(val: unknown): string;
+export declare function fillMissingOptions(messageFormat: IntlMessageFormat, options: Record<string, unknown>): {
+    [x: string]: unknown;
+} | undefined;

package/dist/utils.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyVal = stringifyVal;
+exports.fillMissingOptions = fillMissingOptions;
+function stringifyVal(val) {
+    switch (typeof val) {
+        case 'number':
+        case 'bigint':
+            return `${val}`;
+        case 'boolean':
+            return val ? 'true' : 'false';
+        case 'string':
+        case 'symbol':
+            return val.toString();
+        case 'object':
+            return val === null
+                ? ''
+                : val instanceof Date
+                    ? val.toISOString()
+                    : JSON.stringify(val);
+        default:
+            return '';
+    }
+}
+function fillMissingOptions(messageFormat, options) {
+    const ast = messageFormat.getAst();
+    if (!(ast === null || ast === void 0 ? void 0 : ast.length)) {
+        return undefined;
+    }
+    const missing = {};
+    for (const element of ast) {
+        // TYPE.ARGUMENT = 1
+        if (element.type !== 1) {
+            continue;
+        }
+        if (element.value in options) {
+            continue;
+        }
+        missing[element.value] = '';
+    }
+    return { ...options, ...missing };
+}
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@cozeloop/intl",
+  "version": "0.0.1",
+  "description": "Intl runtime For CozeLoop",
+  "author": "qihai@bytedance.com",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "exit 0",
+    "build:sdk": "tsc -b tsconfig.build.json",
+    "lint": "eslint ./ --cache",
+    "test": "vitest --run --passWithNoTests",
+    "test:cov": "npm run test -- --coverage",
+    "vitest": "vitest"
+  },
+  "dependencies": {
+    "i18next": ">= 19.0.0",
+    "i18next-browser-languagedetector": "8.0.4",
+    "intl-messageformat": "^10.7.16"
+  },
+  "devDependencies": {
+    "@coze-arch/eslint-config": "workspace:*",
+    "@coze-arch/ts-config": "workspace:*",
+    "@coze-arch/vitest-config": "workspace:*",
+    "@types/react": "18.2.37",
+    "@vitest/coverage-v8": "~3.0.5",
+    "react": "~18.2.0",
+    "typescript": "~5.8.2",
+    "vitest": "~3.0.5"
+  },
+  "peerDependencies": {
+    "react": ">=18.2.0"
+  },
+  "publishRegistries": [
+    "npm"
+  ],
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ]
+}