@bleedingdev/modern-js-renderer-octane 0.0.0-stage → 3.9.3-ultramodern.10

package/dist/esm/i18n-external-snapshot.mjs

@@ -0,0 +1,576 @@
+import { createNativeI18n, createNativeI18nInstance, getNativeI18nRewriteSnapshot, getNativeI18nSnapshotSeed, invalidateNativeI18nSnapshot } from "@modern-js/i18n-runtime-extensions/native";
+import i18next from "i18next";
+import { I18nContext } from "./i18n/context.mjs";
+import { OCTANE_WORKER_CONTEXT_KEYS, registerOctaneWorkerContext, registerOctaneWorkerRouterRewrite } from "./worker-federation-contexts.mjs";
+const defaultProfile = {
+    key: 'ultramodern.i18next',
+    version: '1'
+};
+const profiles = new Map();
+const associations = new WeakMap();
+const restored = new WeakSet();
+const disposals = new WeakMap();
+const disposedContexts = new WeakSet();
+const retiredInstances = new WeakSet();
+const MAX_BYTES = 4194304;
+const MAX_NODES = 100000;
+const MAX_DEPTH = 32;
+const MAX_OPTIONS_BYTES = 65536;
+function record(value) {
+    return 'object' == typeof value && null !== value && (Object.getPrototypeOf(value) === Object.prototype || null === Object.getPrototypeOf(value));
+}
+function copyJson(value, maxBytes = MAX_BYTES) {
+    let bytes = 0;
+    let nodes = 0;
+    const ancestors = new Set();
+    const charge = (value, quoted = true)=>{
+        if (value.length > maxBytes) throw new Error('i18n snapshot exceeds its budget');
+        bytes += new TextEncoder().encode(quoted ? JSON.stringify(value) : value).byteLength;
+        if (bytes > maxBytes) throw new Error('i18n snapshot exceeds its budget');
+    };
+    const visit = (input, depth)=>{
+        if (++nodes > MAX_NODES || depth > MAX_DEPTH) throw new Error('i18n snapshot exceeds its structural budget');
+        if (null === input || 'boolean' == typeof input) {
+            charge(String(input), false);
+            return input;
+        }
+        if ('number' == typeof input) {
+            if (!Number.isFinite(input)) throw new Error('i18n snapshot numbers must be finite');
+            charge(String(input), false);
+            return input;
+        }
+        if ('string' == typeof input) {
+            charge(input);
+            return input;
+        }
+        if ('object' != typeof input || null === input || (Array.isArray(input) ? Object.getPrototypeOf(input) !== Array.prototype : !record(input))) throw new Error('i18n snapshots contain only plain JSON data');
+        if (ancestors.has(input)) throw new Error('i18n snapshots cannot contain cycles');
+        ancestors.add(input);
+        const result = Array.isArray(input) ? [] : {};
+        const keys = Reflect.ownKeys(input);
+        if (Array.isArray(input) && (input.length > MAX_NODES || keys.length !== input.length + 1 || keys.slice(0, -1).some((key, index)=>key !== String(index)))) throw new Error('i18n snapshot arrays must be dense');
+        charge(Array.isArray(input) ? '[]' : '{}', false);
+        let entries = 0;
+        for (const key of keys){
+            if (Array.isArray(input) && 'length' === key) continue;
+            const descriptor = Object.getOwnPropertyDescriptor(input, key);
+            if ('string' != typeof key || '__proto__' === key || 'prototype' === key || 'constructor' === key || !descriptor || !descriptor.enumerable || !('value' in descriptor)) throw new Error('i18n snapshots cannot contain special properties or accessors');
+            if (entries++) charge(',', false);
+            if (!Array.isArray(input)) {
+                charge(key);
+                charge(':', false);
+            }
+            Object.defineProperty(result, key, {
+                value: visit(descriptor.value, depth + 1),
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        }
+        ancestors.delete(input);
+        return result;
+    };
+    return visit(value, 0);
+}
+function jsonRecord(value, maxBytes = MAX_BYTES) {
+    const copied = copyJson(value, maxBytes);
+    if (!record(copied)) throw new Error('i18n snapshot must contain an object');
+    return copied;
+}
+function canonicalJson(value) {
+    if (Array.isArray(value)) return value.map(canonicalJson);
+    if (null !== value && 'object' == typeof value) {
+        const result = {};
+        for (const key of Object.keys(value).sort())result[key] = canonicalJson(value[key]);
+        return result;
+    }
+    return value;
+}
+function sameResourcesKey(value) {
+    return JSON.stringify(canonicalJson(copyJson(value)));
+}
+function exactKeys(value, allowed) {
+    if (Object.keys(value).some((key)=>!allowed.includes(key))) throw new Error('Unknown i18n snapshot field');
+}
+function language(value) {
+    if ('string' != typeof value || !value || value.length > 128) throw new Error('Invalid i18n snapshot language');
+    return value;
+}
+function profileId(value) {
+    if (!record(value)) throw new Error('Invalid i18n snapshot profile');
+    exactKeys(value, [
+        'key',
+        'version'
+    ]);
+    const key = language(value.key);
+    const version = language(value.version);
+    return {
+        key,
+        version
+    };
+}
+function profileKey(profile) {
+    return JSON.stringify([
+        profile.key,
+        profile.version
+    ]);
+}
+function genuineInstance(value) {
+    if ('object' != typeof value || null === value) return false;
+    for (const key of [
+        'options',
+        'services',
+        'store',
+        'language'
+    ]){
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !('value' in descriptor)) return false;
+    }
+    const services = Object.getOwnPropertyDescriptor(value, 'services')?.value;
+    const connector = services && 'object' == typeof services ? Object.getOwnPropertyDescriptor(services, 'backendConnector')?.value : void 0;
+    const state = connector && 'object' == typeof connector ? Object.getOwnPropertyDescriptor(connector, 'state')?.value : void 0;
+    const pending = record(state) && Object.values(Object.getOwnPropertyDescriptors(state)).some((descriptor)=>!('value' in descriptor) || 1 === descriptor.value);
+    return Object.getPrototypeOf(value) === Object.getPrototypeOf(i18next) && Object.getOwnPropertyDescriptor(value, 'isInitialized')?.value === true && Object.getOwnPropertyDescriptor(value, 'isInitializing')?.value !== true && !Object.getOwnPropertyDescriptor(value, 'isLanguageChangingTo')?.value && 'string' == typeof Object.getOwnPropertyDescriptor(value, 'language')?.value && !pending;
+}
+function stringList(value, allowFalse = false) {
+    return allowFalse && false === value || 'string' == typeof value || Array.isArray(value) && value.every((item)=>'string' == typeof item);
+}
+const booleanOptions = new Set([
+    'debug',
+    'nonExplicitSupportedLngs',
+    'lowerCaseLng',
+    'cleanCode',
+    'ignoreJSONStructure',
+    'returnNull',
+    'returnEmptyString',
+    'returnObjects',
+    'returnDetails',
+    'appendNamespaceToMissingKey',
+    'appendNamespaceToCIMode',
+    'cacheInBuiltFormats'
+]);
+const stringOptions = new Set([
+    'pluralSeparator',
+    'contextSeparator'
+]);
+const interpolationBooleans = new Set([
+    'alwaysFormat',
+    'escapeValue',
+    'useRawValueToEscape',
+    'skipOnVariables'
+]);
+const interpolationStrings = new Set([
+    'formatSeparator',
+    'prefix',
+    'suffix',
+    'prefixEscaped',
+    'suffixEscaped',
+    'unescapeSuffix',
+    'unescapePrefix',
+    'nestingPrefix',
+    'nestingSuffix',
+    'nestingPrefixEscaped',
+    'nestingSuffixEscaped',
+    'nestingOptionsSeparator'
+]);
+function validatePortableOptions(options) {
+    for (const [key, value] of Object.entries(options)){
+        let valid = false;
+        if (booleanOptions.has(key)) valid = 'boolean' == typeof value;
+        else if (stringOptions.has(key)) valid = 'string' == typeof value;
+        else if ([
+            'keySeparator',
+            'nsSeparator',
+            'joinArrays'
+        ].includes(key)) valid = false === value || 'string' == typeof value;
+        else if ([
+            'ns',
+            'defaultNS',
+            'fallbackNS'
+        ].includes(key)) valid = stringList(value, 'ns' !== key);
+        else if ('preload' === key) valid = false === value || Array.isArray(value) && stringList(value);
+        else if ('supportedLngs' === key) valid = false === value || Array.isArray(value) && stringList(value);
+        else if ('fallbackLng' === key) valid = stringList(value, true) || record(value) && Object.values(value).every((item)=>Array.isArray(item) && stringList(item));
+        else if ('load' === key) valid = 'string' == typeof value && [
+            'all',
+            'currentOnly',
+            'languageOnly'
+        ].includes(value);
+        else if ('enableSelector' === key) valid = 'boolean' == typeof value || 'optimize' === value || 'strict' === value;
+        else if ('compatibilityJSON' === key) valid = 'v4' === value;
+        else if ('postProcess' === key) valid = false === value || Array.isArray(value) && 0 === value.length;
+        else if ([
+            'saveMissing',
+            'updateMissing'
+        ].includes(key)) valid = false === value;
+        else if ('interpolation' === key && record(value)) valid = Object.entries(value).every(([name, field])=>{
+            if (interpolationBooleans.has(name)) return 'boolean' == typeof field;
+            if (interpolationStrings.has(name)) return 'string' == typeof field;
+            if ('defaultVariables' === name) return record(field);
+            return 'maxReplaces' === name && 'number' == typeof field && Number.isSafeInteger(field) && field >= 0 && field <= 100000;
+        });
+        if (!valid) throw new Error(`i18n option ${key} requires an explicit Worker profile`);
+    }
+}
+function i18n_external_snapshot_resources(value) {
+    const copied = jsonRecord(value);
+    if (Object.keys(copied).length > 64) throw new Error('Too many i18n snapshot languages');
+    const result = {};
+    for (const [lng, namespaces] of Object.entries(copied)){
+        language(lng);
+        if (!record(namespaces) || Object.keys(namespaces).length > 256) throw new Error('Invalid i18n snapshot namespaces');
+        const bundles = {};
+        for (const [namespace, bundle] of Object.entries(namespaces)){
+            language(namespace);
+            if ('string' != typeof bundle && !record(bundle)) throw new Error('Invalid i18n snapshot resource bundle');
+            bundles[namespace] = bundle;
+        }
+        result[lng] = bundles;
+    }
+    return result;
+}
+function loadedResources(instance) {
+    const result = {};
+    const descriptor = Object.getOwnPropertyDescriptor(instance.store, 'data');
+    if (!descriptor || !('value' in descriptor)) throw new Error('Loaded i18n resources cannot use accessors');
+    const loaded = jsonRecord(descriptor.value);
+    for (const lng of Object.keys(loaded)){
+        const data = jsonRecord(instance.getDataByLanguage(lng));
+        const bundles = {};
+        for (const namespace of Object.keys(data)){
+            const bundle = instance.getResourceBundle(lng, namespace);
+            if ('string' != typeof bundle && !record(bundle)) throw new Error('Invalid loaded i18n resource bundle');
+            bundles[namespace] = bundle;
+        }
+        result[lng] = bundles;
+    }
+    return i18n_external_snapshot_resources(result);
+}
+function localizedUrls(value) {
+    if (void 0 === value || 'boolean' == typeof value) return value;
+    if (!record(value)) throw new Error('Invalid i18n snapshot localized URLs');
+    const result = {};
+    for (const [path, map] of Object.entries(value)){
+        if (!record(map)) throw new Error('Invalid i18n snapshot localized URL map');
+        const paths = {};
+        for (const [lng, target] of Object.entries(map)){
+            language(lng);
+            if ('string' != typeof target) throw new Error('Invalid localized URL target');
+            paths[lng] = target;
+        }
+        result[path] = paths;
+    }
+    return result;
+}
+function rewriteSnapshot(value) {
+    const input = jsonRecord(value, MAX_OPTIONS_BYTES);
+    exactKeys(input, [
+        'language',
+        'languages',
+        'localisedUrls'
+    ]);
+    const lng = language(input.language);
+    if (!Array.isArray(input.languages) || !input.languages.length || input.languages.length > 64) throw new Error('Invalid i18n rewrite languages');
+    const languages = input.languages.map(language);
+    if (new Set(languages).size !== languages.length || !languages.includes(lng)) throw new Error('Invalid i18n rewrite language selection');
+    const urls = localizedUrls(input.localisedUrls);
+    return {
+        language: lng,
+        languages,
+        ...void 0 === urls ? {} : {
+            localisedUrls: urls
+        }
+    };
+}
+function captureOctaneI18nRewriteSnapshot(rewrite) {
+    const snapshot = getNativeI18nRewriteSnapshot(rewrite);
+    if (!snapshot) throw new Error('Unknown i18n router rewrite requires a named profile');
+    return rewriteSnapshot(snapshot);
+}
+function restoreOctaneI18nRewriteSnapshot(value) {
+    const snapshot = rewriteSnapshot(value);
+    return createNativeI18n({
+        languages: snapshot.languages,
+        fallbackLanguage: snapshot.language,
+        localisedUrls: snapshot.localisedUrls
+    }, {}).rewrite(()=>snapshot.language);
+}
+function registerOctaneI18nSnapshotProfile(profile) {
+    const id = profileId({
+        key: profile.key,
+        version: profile.version
+    });
+    if ('function' != typeof profile.captureOptions || 'function' != typeof profile.validateOptions || 'function' != typeof profile.create || void 0 !== profile.dispose && 'function' != typeof profile.dispose) throw new Error('Invalid i18n Worker profile implementation');
+    const key = profileKey(id);
+    if (key === profileKey(defaultProfile) || profiles.has(key)) throw new Error('Duplicate i18n Worker profile');
+    const captured = Object.freeze({
+        ...id,
+        captureOptions: profile.captureOptions,
+        validateOptions: profile.validateOptions,
+        create: profile.create,
+        ...profile.dispose ? {
+            dispose: profile.dispose
+        } : {}
+    });
+    profiles.set(key, captured);
+    return ()=>{
+        if (profiles.get(key) === captured) profiles.delete(key);
+    };
+}
+function associateOctaneI18nSnapshotProfile(instance, id) {
+    const copied = profileId(jsonRecord(id));
+    const profile = profiles.get(profileKey(copied));
+    if (!genuineInstance(instance) || retiredInstances.has(instance)) throw new Error('Profiles require a live genuine i18n instance');
+    if (!profile) throw new Error('The exact i18n Worker profile must be registered locally');
+    if (restored.has(instance)) {
+        const association = associations.get(instance);
+        if (association?.profile !== profile || profileKey(association.id) !== profileKey(copied)) throw new Error('A restored i18n context retains its owning profile');
+        return;
+    }
+    associations.set(instance, {
+        id: copied,
+        profile
+    });
+}
+function captureOctaneI18nSnapshot(value) {
+    const instance = value.instance;
+    if (disposedContexts.has(value) || retiredInstances.has(instance)) throw new Error('Cannot capture a disposed i18n Worker context');
+    if (!genuineInstance(instance)) throw new Error('Worker i18n snapshots require a genuine settled i18next instance');
+    if (instance.language !== value.language) throw new Error('Worker i18n context language must be settled');
+    const association = associations.get(instance);
+    const selected = association?.id ?? defaultProfile;
+    let options;
+    if (profileKey(selected) === profileKey(defaultProfile)) {
+        const seed = getNativeI18nSnapshotSeed(instance);
+        const { lng, resources, initAsync, partialBundledLanguages, ...portable } = seed;
+        options = jsonRecord(portable, MAX_OPTIONS_BYTES);
+        validatePortableOptions(options);
+    } else {
+        const profile = profiles.get(profileKey(selected));
+        if (!profile || association?.profile !== profile) throw new Error('Missing or changed exact i18n Worker profile');
+        options = jsonRecord(profile.captureOptions(instance), MAX_OPTIONS_BYTES);
+        profile.validateOptions(options);
+    }
+    return parseSnapshot({
+        version: 1,
+        profile: selected,
+        language: value.language,
+        languages: [
+            ...value.languages
+        ],
+        ...void 0 === value.localisedUrls ? {} : {
+            localisedUrls: value.localisedUrls
+        },
+        options,
+        resources: loadedResources(instance)
+    });
+}
+function parseSnapshot(value) {
+    const input = jsonRecord(value);
+    exactKeys(input, [
+        'version',
+        'profile',
+        'language',
+        'languages',
+        'localisedUrls',
+        'options',
+        'resources'
+    ]);
+    if (1 !== input.version) throw new Error('Unsupported i18n snapshot version');
+    const lng = language(input.language);
+    if (!Array.isArray(input.languages) || !input.languages.length || input.languages.length > 64) throw new Error('Invalid i18n snapshot supported languages');
+    const languages = input.languages.map(language);
+    if (new Set(languages).size !== languages.length || !languages.includes(lng)) throw new Error('Invalid i18n snapshot language selection');
+    const options = jsonRecord(input.options, MAX_OPTIONS_BYTES);
+    const urls = localizedUrls(input.localisedUrls);
+    return {
+        version: 1,
+        profile: profileId(input.profile),
+        language: lng,
+        languages,
+        ...void 0 === urls ? {} : {
+            localisedUrls: urls
+        },
+        options,
+        resources: i18n_external_snapshot_resources(input.resources)
+    };
+}
+function throwIfAborted(signal) {
+    signal?.throwIfAborted();
+}
+function disposeInstance(instance) {
+    for (const event of [
+        'initialized',
+        'loaded',
+        'failedLoading',
+        'languageChanging',
+        'languageChanged',
+        'missingKey',
+        '*'
+    ])instance.off(event);
+    instance.store.off('added');
+    instance.store.off('removed');
+}
+function retireInstance(instance) {
+    if ('object' != typeof instance || null === instance || Object.getPrototypeOf(instance) !== Object.getPrototypeOf(i18next)) return;
+    retiredInstances.add(instance);
+    associations.delete(instance);
+    invalidateNativeI18nSnapshot(instance);
+}
+function cleanupFreshInstance(instance, dispose) {
+    if (restored.has(instance)) return;
+    retireInstance(instance);
+    if (genuineInstance(instance)) disposeInstance(instance);
+    dispose?.();
+}
+function createProfileInstance(profile, snapshot, signal) {
+    return new Promise((resolve, reject)=>{
+        let finished = false;
+        const abort = ()=>{
+            if (finished) return;
+            finished = true;
+            signal?.removeEventListener('abort', abort);
+            reject(signal?.reason ?? new Error('i18n restoration aborted'));
+        };
+        signal?.addEventListener('abort', abort, {
+            once: true
+        });
+        if (signal?.aborted) abort();
+        Promise.resolve().then(()=>{
+            if (finished) throw signal?.reason ?? new Error('i18n restoration aborted');
+            return profile.create({
+                language: snapshot.language,
+                options: snapshot.options,
+                resources: i18n_external_snapshot_resources(snapshot.resources),
+                ...signal ? {
+                    signal
+                } : {}
+            });
+        }).then((instance)=>{
+            if (finished) {
+                try {
+                    cleanupFreshInstance(instance, ()=>profile.dispose?.(instance));
+                } catch  {}
+                return;
+            }
+            finished = true;
+            signal?.removeEventListener('abort', abort);
+            resolve(instance);
+        }, (error)=>{
+            if (finished) return;
+            finished = true;
+            signal?.removeEventListener('abort', abort);
+            reject(error);
+        });
+    });
+}
+async function restoreOctaneI18nSnapshot(value, signal) {
+    throwIfAborted(signal);
+    const snapshot = parseSnapshot(value);
+    const expectedResources = sameResourcesKey(snapshot.resources);
+    let instance;
+    let dispose;
+    let restoredProfile;
+    if (profileKey(snapshot.profile) === profileKey(defaultProfile)) {
+        validatePortableOptions(snapshot.options);
+        instance = createNativeI18nInstance({
+            ...snapshot.options,
+            lng: snapshot.language,
+            resources: i18n_external_snapshot_resources(snapshot.resources),
+            initAsync: false,
+            partialBundledLanguages: false
+        });
+    } else {
+        const profile = profiles.get(profileKey(snapshot.profile));
+        if (!profile) throw new Error('Missing exact i18n Worker profile');
+        restoredProfile = profile;
+        profile.validateOptions(snapshot.options);
+        instance = await createProfileInstance(profile, snapshot, signal);
+        if (profile.dispose) dispose = ()=>profile.dispose?.(instance);
+    }
+    try {
+        throwIfAborted(signal);
+        if (restoredProfile && profiles.get(profileKey(snapshot.profile)) !== restoredProfile) throw new Error('The i18n Worker profile changed during restoration');
+        if (!genuineInstance(instance) || instance.language !== snapshot.language || restored.has(instance)) throw new Error('An i18n Worker profile must create a fresh settled instance');
+        const current = loadedResources(instance);
+        if (sameResourcesKey(current) !== expectedResources) throw new Error('An i18n Worker profile must restore every loaded resource');
+        restored.add(instance);
+        if (restoredProfile) associations.set(instance, {
+            id: {
+                ...snapshot.profile
+            },
+            profile: restoredProfile
+        });
+        const context = {
+            instance,
+            language: snapshot.language,
+            languages: snapshot.languages,
+            ...void 0 === snapshot.localisedUrls ? {} : {
+                localisedUrls: snapshot.localisedUrls
+            }
+        };
+        let disposed = false;
+        disposals.set(context, ()=>{
+            if (disposed) return;
+            disposed = true;
+            disposedContexts.add(context);
+            retireInstance(instance);
+            disposeInstance(instance);
+            dispose?.();
+        });
+        return context;
+    } catch (error) {
+        cleanupFreshInstance(instance, dispose);
+        throw error;
+    }
+}
+function disposeOctaneI18nSnapshot(value) {
+    const dispose = disposals.get(value);
+    disposals.delete(value);
+    dispose?.();
+}
+let registrations = 0;
+let releaseContext;
+function registerOctaneI18nWorkerContexts() {
+    if (!releaseContext) {
+        const releaseRewrite = registerOctaneWorkerRouterRewrite({
+            capture: captureOctaneI18nRewriteSnapshot,
+            restore: restoreOctaneI18nRewriteSnapshot
+        });
+        try {
+            const unregisterContext = registerOctaneWorkerContext(I18nContext, {
+                key: OCTANE_WORKER_CONTEXT_KEYS.i18n,
+                encode: (value)=>{
+                    if (null === value) throw new Error('Missing i18n context provider');
+                    return captureOctaneI18nSnapshot(value);
+                },
+                decode: restoreOctaneI18nSnapshot,
+                dispose: (value)=>{
+                    if (null !== value) disposeOctaneI18nSnapshot(value);
+                },
+                isProvided: (value)=>null !== value
+            });
+            releaseContext = ()=>{
+                try {
+                    unregisterContext();
+                } finally{
+                    releaseRewrite();
+                }
+            };
+        } catch (error) {
+            releaseRewrite();
+            throw error;
+        }
+    }
+    registrations++;
+    let released = false;
+    return ()=>{
+        if (released) return;
+        released = true;
+        if (0 === --registrations) {
+            releaseContext?.();
+            releaseContext = void 0;
+        }
+    };
+}
+export { associateOctaneI18nSnapshotProfile, captureOctaneI18nRewriteSnapshot, captureOctaneI18nSnapshot, disposeOctaneI18nSnapshot, registerOctaneI18nSnapshotProfile, registerOctaneI18nWorkerContexts, restoreOctaneI18nRewriteSnapshot, restoreOctaneI18nSnapshot };

package/dist/esm/index.mjs

@@ -0,0 +1,8 @@
+const OCTANE_RUNTIME_PROFILE = Object.freeze({
+    renderer: 'octane',
+    runtime: '0.13.8',
+    router: '0.2.10',
+    routerCore: '1.171.34',
+    history: '1.162.4'
+});
+export { OCTANE_RUNTIME_PROFILE };