@lynx-js/web-core-wasm-canary 0.0.0 → 0.0.1-canary-20260116-ce265e8f

package/dist/client/background/background-apis/createTimingSystem.d.ts

@@ -0,0 +1,8 @@
+import type { EventEmitter } from '../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export type TimingSystem = {
+    registerGlobalEmitter: (globalEventEmitter: EventEmitter) => void;
+    markTimingInternal: (timingKey: string, pipelineId?: string) => void;
+    pipelineIdToTimingFlags: Map<string, string[]>;
+};
+export declare function createTimingSystem(mainThreadRpc: Rpc, uiThreadRpc: Rpc): TimingSystem;

package/dist/client/background/background-apis/createTimingSystem.js

@@ -0,0 +1,86 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { dispatchLynxViewEventEndpoint, markTimingEndpoint, postTimingFlagsEndpoint, } from '../../endpoints.js';
+const ListenerKeys = {
+    onSetup: 'lynx.performance.timing.onSetup',
+    onUpdate: 'lynx.performance.timing.onUpdate',
+};
+export function createTimingSystem(mainThreadRpc, uiThreadRpc) {
+    let isFp = true;
+    const setupTiming = {};
+    const pipelineIdToTiming = new Map();
+    const pipelineIdToTimingFlags = new Map();
+    const dispatchLynxViewEvent = uiThreadRpc.createCall(dispatchLynxViewEventEndpoint);
+    let commonTimingFlags = [];
+    function markTimingInternal(markTimingRecords) {
+        for (let { timingKey, pipelineId, timeStamp } of markTimingRecords) {
+            if (!timeStamp)
+                timeStamp = performance.now() + performance.timeOrigin;
+            if (!pipelineId) {
+                setupTiming[timingKey] = timeStamp;
+                continue;
+            }
+            if (!pipelineIdToTiming.has(pipelineId)) {
+                pipelineIdToTiming.set(pipelineId, {});
+            }
+            const timingInfo = pipelineIdToTiming.get(pipelineId);
+            timingInfo[timingKey] = timeStamp;
+        }
+    }
+    const registerGlobalEmitter = (globalEventEmitter) => {
+        mainThreadRpc.registerHandler(postTimingFlagsEndpoint, (timingFlags, pipelineId) => {
+            if (!pipelineId) {
+                commonTimingFlags = commonTimingFlags.concat(timingFlags);
+            }
+            else
+                timingFlags = timingFlags.concat(commonTimingFlags);
+            if (isFp) {
+                const timingInfo = {
+                    extra_timing: {},
+                    setup_timing: setupTiming,
+                    update_timings: {},
+                    metrics: {},
+                    has_reload: false,
+                    thread_strategy: 0,
+                    url: '',
+                };
+                globalEventEmitter.emit(ListenerKeys.onSetup, [timingInfo]);
+                dispatchLynxViewEvent('timing', setupTiming);
+            }
+            else {
+                const timings = (pipelineId ? pipelineIdToTiming.get(pipelineId) : undefined) ?? {};
+                const flags = [
+                    ...timingFlags,
+                    ...(pipelineIdToTimingFlags.get(pipelineId) ?? []),
+                ];
+                const timingInfo = {
+                    extra_timing: {},
+                    setup_timing: {},
+                    update_timings: Object.fromEntries([...flags].map(flag => [flag, timings])),
+                    metrics: {},
+                    has_reload: false,
+                    thread_strategy: 0,
+                    url: '',
+                };
+                globalEventEmitter.emit(ListenerKeys.onUpdate, [timingInfo]);
+                dispatchLynxViewEvent('timing', timings);
+            }
+            if (pipelineId) {
+                pipelineIdToTimingFlags.delete(pipelineId);
+                pipelineIdToTiming.delete(pipelineId);
+            }
+            if (isFp) {
+                isFp = false;
+            }
+        });
+    };
+    mainThreadRpc.registerHandler(markTimingEndpoint, markTimingInternal);
+    uiThreadRpc.registerHandler(markTimingEndpoint, markTimingInternal);
+    return {
+        markTimingInternal: (timingKey, pipelineId, timeStamp) => markTimingInternal([{ timingKey, pipelineId, timeStamp }]),
+        registerGlobalEmitter,
+        pipelineIdToTimingFlags,
+    };
+}
+//# sourceMappingURL=createTimingSystem.js.map

package/dist/client/background/background-apis/crossThreadHandlers/createGetCustomSection.d.ts

@@ -0,0 +1,3 @@
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+import type { Cloneable } from '../../../../types/index.js';
+export declare function createGetCustomSection(rpc: Rpc, customSections: Record<string, Cloneable>): (key: string, callback: (object: Cloneable) => void) => void;

package/dist/client/background/background-apis/crossThreadHandlers/createGetCustomSection.js

@@ -0,0 +1,14 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { getCustomSectionsEndpoint } from '../../../endpoints.js';
+export function createGetCustomSection(rpc, customSections) {
+    const getCustomSections = rpc.createCall(getCustomSectionsEndpoint);
+    return (key, callback) => {
+        if (customSections[key]) {
+            return callback(customSections[key]);
+        }
+        getCustomSections(key).then(callback);
+    };
+}
+//# sourceMappingURL=createGetCustomSection.js.map

package/dist/client/background/background-apis/crossThreadHandlers/createGetPathInfo.d.ts

@@ -0,0 +1,3 @@
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+import type { NativeApp } from '../../../../types/index.js';
+export declare function createGetPathInfo(rpc: Rpc): NativeApp['getPathInfo'];

package/dist/client/background/background-apis/crossThreadHandlers/createGetPathInfo.js

@@ -0,0 +1,23 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { getPathInfoEndpoint } from '../../../endpoints.js';
+import { ErrorCode } from '../../../../constants.js';
+export function createGetPathInfo(rpc) {
+    return (type, identifier, component_id, first_only, callback, root_unique_id) => {
+        rpc.invoke(getPathInfoEndpoint, [
+            type,
+            identifier,
+            component_id,
+            first_only,
+            root_unique_id,
+        ]).then(callback).catch((error) => {
+            console.error(`[lynx-web] getPathInfo failed`, error);
+            callback({
+                code: ErrorCode.UNKNOWN,
+                data: error.message || '',
+            });
+        });
+    };
+}
+//# sourceMappingURL=createGetPathInfo.js.map

package/dist/client/background/background-apis/crossThreadHandlers/createInvokeUIMethod.d.ts

@@ -0,0 +1,3 @@
+import type { NativeApp } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function createInvokeUIMethod(rpc: Rpc): NativeApp['invokeUIMethod'];

package/dist/client/background/background-apis/crossThreadHandlers/createInvokeUIMethod.js

@@ -0,0 +1,24 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { invokeUIMethodEndpoint } from '../../../endpoints.js';
+import { ErrorCode } from '../../../../constants.js';
+export function createInvokeUIMethod(rpc) {
+    return (type, identifier, component_id, method, params, callback, root_unique_id) => {
+        rpc.invoke(invokeUIMethodEndpoint, [
+            type,
+            identifier,
+            component_id,
+            method,
+            params,
+            root_unique_id,
+        ]).then(callback).catch((error) => {
+            console.error(`[lynx-web] invokeUIMethod failed`, error);
+            callback({
+                code: ErrorCode.UNKNOWN,
+                data: '',
+            });
+        });
+    };
+}
+//# sourceMappingURL=createInvokeUIMethod.js.map

package/dist/client/background/background-apis/crossThreadHandlers/createJSObjectDestructionObserver.d.ts

@@ -0,0 +1,2 @@
+import type { NativeApp } from '../../../../types/index.js';
+export declare function createJSObjectDestructionObserver(): NativeApp['createJSObjectDestructionObserver'];

package/dist/client/background/background-apis/crossThreadHandlers/createJSObjectDestructionObserver.js

@@ -0,0 +1,12 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+export function createJSObjectDestructionObserver() {
+    const registry = new FinalizationRegistry((callback) => callback());
+    return (cleanupCallback) => {
+        const observedObject = {};
+        registry.register(observedObject, cleanupCallback);
+        return observedObject;
+    };
+}
+//# sourceMappingURL=createJSObjectDestructionObserver.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerDisposeHandler.d.ts

@@ -0,0 +1,3 @@
+import type { NativeApp } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerDisposeHandler(rpc: Rpc, nativeApp: NativeApp, destroyCard: typeof import('@lynx-js/lynx-core/web')['destroyCard'], callDestroyLifetimeFun: typeof import('@lynx-js/lynx-core/web')['callDestroyLifetimeFun']): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerDisposeHandler.js

@@ -0,0 +1,9 @@
+import { disposeEndpoint } from '../../../endpoints.js';
+export function registerDisposeHandler(rpc, nativeApp, destroyCard, callDestroyLifetimeFun) {
+    rpc.registerHandler(disposeEndpoint, () => {
+        const id = nativeApp.id;
+        callDestroyLifetimeFun(id);
+        destroyCard(id);
+    });
+}
+//# sourceMappingURL=registerDisposeHandler.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerPublicComponentEventHandler.d.ts

@@ -0,0 +1,3 @@
+import type { NativeTTObject } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerPublicComponentEventHandler(rpc: Rpc, tt: NativeTTObject): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerPublicComponentEventHandler.js

@@ -0,0 +1,8 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { publicComponentEventEndpoint } from '../../../endpoints.js';
+export function registerPublicComponentEventHandler(rpc, tt) {
+    rpc.registerHandlerLazy(publicComponentEventEndpoint, tt, 'publicComponentEvent');
+}
+//# sourceMappingURL=registerPublicComponentEventHandler.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerPublishEventHandler.d.ts

@@ -0,0 +1,3 @@
+import type { NativeTTObject } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerPublishEventHandler(rpc: Rpc, tt: NativeTTObject): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerPublishEventHandler.js

@@ -0,0 +1,8 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { publishEventEndpoint } from '../../../endpoints.js';
+export function registerPublishEventHandler(rpc, tt) {
+    rpc.registerHandlerLazy(publishEventEndpoint, tt, 'publishEvent');
+}
+//# sourceMappingURL=registerPublishEventHandler.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerSendGlobalEvent.d.ts

@@ -0,0 +1,3 @@
+import type { NativeTTObject } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerSendGlobalEventHandler(rpc: Rpc, tt: NativeTTObject): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerSendGlobalEvent.js

@@ -0,0 +1,10 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { sendGlobalEventEndpoint } from '../../../endpoints.js';
+export function registerSendGlobalEventHandler(rpc, tt) {
+    rpc.registerHandler(sendGlobalEventEndpoint, (...args) => {
+        tt.GlobalEventEmitter.emit(...args);
+    });
+}
+//# sourceMappingURL=registerSendGlobalEvent.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerUpdateDataHandler.d.ts

@@ -0,0 +1,3 @@
+import type { NativeTTObject } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerUpdateDataHandler(rpc: Rpc, tt: NativeTTObject): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerUpdateDataHandler.js

@@ -0,0 +1,5 @@
+import { updateDataEndpoint } from '../../../endpoints.js';
+export function registerUpdateDataHandler(rpc, tt) {
+    rpc.registerHandlerLazy(updateDataEndpoint, tt, 'updateCardData');
+}
+//# sourceMappingURL=registerUpdateDataHandler.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerUpdateGlobalPropsHandler.d.ts

@@ -0,0 +1,3 @@
+import type { NativeTTObject } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerUpdateGlobalPropsHandler(rpc: Rpc, tt: NativeTTObject): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerUpdateGlobalPropsHandler.js

@@ -0,0 +1,5 @@
+import { updateGlobalPropsEndpoint } from '../../../endpoints.js';
+export function registerUpdateGlobalPropsHandler(rpc, tt) {
+    rpc.registerHandlerLazy(updateGlobalPropsEndpoint, tt, 'updateGlobalProps');
+}
+//# sourceMappingURL=registerUpdateGlobalPropsHandler.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerUpdateI18nResource.d.ts

@@ -0,0 +1,3 @@
+import type { II18nResource, NativeTTObject } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerUpdateI18nResource(mainThreadRpc: Rpc, i18nResource: II18nResource, tt: NativeTTObject): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerUpdateI18nResource.js

@@ -0,0 +1,9 @@
+import { dispatchI18nResourceEndpoint } from '../../../endpoints.js';
+export function registerUpdateI18nResource(mainThreadRpc, i18nResource, tt) {
+    // dispatchI18nResource from mts
+    mainThreadRpc.registerHandler(dispatchI18nResourceEndpoint, (data) => {
+        i18nResource.setData(data);
+        tt.GlobalEventEmitter.emit('onI18nResourceReady', []);
+    });
+}
+//# sourceMappingURL=registerUpdateI18nResource.js.map

package/dist/client/background/background-apis/startBackgroundThread.d.ts

@@ -0,0 +1,2 @@
+import type { WorkerStartMessage } from '../../../types/WorkerStartMessage.js';
+export declare function startBackgroundThread(startMessage: WorkerStartMessage): void;

package/dist/client/background/background-apis/startBackgroundThread.js

@@ -0,0 +1,42 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { Rpc } from '@lynx-js/web-worker-rpc';
+import { createBackgroundLynx } from './createBackgroundLynx.js';
+import { createNativeApp } from './createNativeApp.js';
+import { registerDisposeHandler } from './crossThreadHandlers/registerDisposeHandler.js';
+import { BackgroundThreadStartEndpoint } from '../../endpoints.js';
+import { createNapiLoader } from './createNapiLoader.js';
+import { createTimingSystem } from './createTimingSystem.js';
+export function startBackgroundThread(startMessage) {
+    const { mainThreadMessagePort, napiModulesMap, nativeModulesMap, initData, globalProps, customSections, cardType, entryTemplateUrl, } = startMessage;
+    const mainThreadPort = mainThreadMessagePort;
+    const mainThreadRpc = new Rpc(mainThreadPort, 'bg-to-main');
+    const timingSystem = createTimingSystem(mainThreadRpc, mainThreadRpc);
+    timingSystem.markTimingInternal('load_core_start');
+    const nativeApp = createNativeApp(mainThreadRpc, timingSystem, nativeModulesMap, entryTemplateUrl);
+    const lynxCore = import(
+    /* webpackChunkName: "lynx-core-chunk" */
+    '@lynx-js/lynx-core/web');
+    const napiLoader = createNapiLoader(mainThreadRpc, napiModulesMap);
+    Promise.all([lynxCore, nativeApp, napiLoader]).then(([lynxCore, nativeApp, napiLoader]) => {
+        timingSystem.markTimingInternal('load_core_end');
+        globalThis['napiLoaderOnRT' + nativeApp.id] = napiLoader;
+        const nativeLynx = createBackgroundLynx(globalProps, customSections, nativeApp, mainThreadRpc);
+        const { loadCard, destroyCard, callDestroyLifetimeFun, nativeGlobal, loadDynamicComponent, } = lynxCore;
+        // @lynx-js/lynx-core >= 0.1.3 will export nativeGlobal and loadDynamicComponent
+        if (nativeGlobal && loadDynamicComponent) {
+            nativeGlobal.loadDynamicComponent = loadDynamicComponent;
+        }
+        mainThreadRpc.registerHandler(BackgroundThreadStartEndpoint, () => {
+            loadCard(nativeApp, {
+                initData,
+                cardType,
+                // @ts-ignore
+                updateData: initData,
+            }, nativeLynx);
+        });
+        registerDisposeHandler(mainThreadRpc, nativeApp, destroyCard, callDestroyLifetimeFun);
+    });
+}
+//# sourceMappingURL=startBackgroundThread.js.map

package/dist/client/background/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/background/index.js

@@ -0,0 +1,15 @@
+import { startBackgroundThread } from './background-apis/startBackgroundThread.js';
+// @ts-expect-error
+globalThis.nativeConsole = console;
+globalThis.onmessage = async (ev) => {
+    const message = ev
+        .data;
+    if (!globalThis.SystemInfo) {
+        globalThis.SystemInfo = message.systemInfo;
+    }
+    startBackgroundThread(message);
+};
+Object.assign(globalThis, {
+    module: { exports: null },
+});
+//# sourceMappingURL=index.js.map

package/dist/client/decodeWorker/cssLoader.d.ts

@@ -0,0 +1,12 @@
+interface CSSRule {
+    sel: string[][][];
+    decl: [string, string][];
+}
+interface OneInfo {
+    content: string[];
+    rules: CSSRule[];
+    imports?: string[];
+}
+type StyleInfo = Record<string, OneInfo>;
+export declare function loadStyleFromJSON(styleInfo: StyleInfo, configEnableCssSelector: boolean, entryName?: string): Uint8Array;
+export {};

package/dist/client/decodeWorker/cssLoader.js

@@ -0,0 +1,96 @@
+import { wasmInstance } from '../wasm.js';
+export function loadStyleFromJSON(styleInfo, configEnableCssSelector, entryName) {
+    const rawStyleInfo = new wasmInstance.RawStyleInfo();
+    for (const [cssIdStr, info] of Object.entries(styleInfo)) {
+        const cssId = parseInt(cssIdStr, 10);
+        // Handle imports
+        if (info.imports) {
+            // imports in StyleInfo are filenames/hrefs, but RawStyleInfo expects cssIds.
+            // Wait, genStyleInfo output imports as string hrefs?
+            // RawStyleInfo: imports: Vec<i32>
+            // It seems genStyleInfo.ts produces imports array of strings, but RawStyleInfo needs integers.
+            // If the JSON only contains strings, we might have a problem mapping them back to IDs unless we have a map.
+            // However, WebEncodePlugin usually handles mapping.
+            // Let's check genStyleInfo again.
+            // node.type === 'ImportRule' => imports.push(node.href).
+            // If imports are paths, we can't easily convert to ID without extra info.
+            // BUT, current usage of imports in RawStyleInfo is strictly ID-based.
+            // If the input JSON has hrefs, we might skip imports or error.
+            // For now, I will omit imports if they are strings, or try to parse if they look like IDs.
+            // Actually, in the ecosystem, imports might not be fully supported in JSON mode yet or resolved differently.
+            // I will log or ignore for now, focusing on Rules.
+        }
+        // Handle rules
+        for (const rule of info.rules) {
+            const wasmRule = new wasmInstance.Rule('StyleRule');
+            // Declarations
+            for (const [prop, val] of rule.decl) {
+                wasmRule.push_declaration(prop, val);
+            }
+            // Selectors
+            const prelude = new wasmInstance.RulePrelude();
+            for (const selectorChain of rule.sel) {
+                const selector = new wasmInstance.Selector();
+                // Iterate in chunks of 4
+                for (let i = 0; i < selectorChain.length; i += 4) {
+                    const plain = selectorChain[i] || [];
+                    const pseudoClass = selectorChain[i + 1] || [];
+                    const pseudoElement = selectorChain[i + 2] || [];
+                    const combinator = selectorChain[i + 3] || [];
+                    for (const s of plain) {
+                        parseAndPushSelector(selector, s);
+                    }
+                    for (const s of pseudoClass) {
+                        // Strip leading :
+                        const val = s.startsWith(':') ? s.substring(1) : s;
+                        selector.push_one_selector_section('PseudoClassSelector', val);
+                    }
+                    for (const s of pseudoElement) {
+                        // Strip leading ::
+                        const val = s.startsWith('::')
+                            ? s.substring(2)
+                            : s.startsWith(':')
+                                ? s.substring(1)
+                                : s;
+                        selector.push_one_selector_section('PseudoElementSelector', val);
+                    }
+                    if (combinator.length > 0) {
+                        selector.push_one_selector_section('Combinator', combinator[0]);
+                    }
+                }
+                prelude.push_selector(selector);
+            }
+            wasmRule.set_prelude(prelude);
+            rawStyleInfo.push_rule(cssId, wasmRule);
+        }
+    }
+    // Use the new Rust method
+    return wasmInstance.DecodedStyleData.encode_from_raw_style_info(rawStyleInfo, configEnableCssSelector, entryName);
+}
+function parseAndPushSelector(selector, s) {
+    if (s.startsWith('.')) {
+        selector.push_one_selector_section('ClassSelector', s.substring(1));
+    }
+    else if (s.startsWith('#')) {
+        selector.push_one_selector_section('IdSelector', s.substring(1));
+    }
+    else if (s.startsWith('[')) {
+        // Attribute: [attr=val]
+        // Remove enclosing []
+        const content = s.substring(1, s.length - 1);
+        selector.push_one_selector_section('AttributeSelector', content);
+    }
+    else if (s === '*') {
+        selector.push_one_selector_section('UniversalSelector', '*');
+    }
+    else {
+        // Type selector
+        // It comes as [lynx-tag="div"] usually.
+        let content = s;
+        if (s.startsWith('[') && s.endsWith(']')) {
+            content = s.substring(1, s.length - 1);
+        }
+        selector.push_one_selector_section('AttributeSelector', content);
+    }
+}
+//# sourceMappingURL=cssLoader.js.map

package/dist/client/decodeWorker/decode.worker.d.ts

@@ -0,0 +1 @@
+export {};