signalforge/dist/native/jsiBridge.js

Fine-grained reactive state management with automatic dependency tracking - Ultra-optimized, zero dependencies

const isNativeAvailable = () => {
    return (typeof global !== 'undefined' &&
        typeof global.__signalForgeCreateSignal === 'function' &&
        typeof global.__signalForgeGetSignal === 'function' &&
        typeof global.__signalForgeSetSignal === 'function' &&
        typeof global.__signalForgeHasSignal === 'function' &&
        typeof global.__signalForgeDeleteSignal === 'function' &&
        typeof global.__signalForgeGetVersion === 'function' &&
        typeof global.__signalForgeBatchUpdate === 'function');
};
const NATIVE_PRESENT_AT_LOAD = isNativeAvailable();
try {
    if (!NATIVE_PRESENT_AT_LOAD) {
        const { installJSIBindings } = require('./setup');
        installJSIBindings();
    }
}
catch (error) {
}
const NATIVE_READY = isNativeAvailable();
let jsStore = null;
const getJsStore = () => {
    if (!jsStore) {
        throw new Error('JavaScript fallback store not initialized. Native JSI bindings required.');
    }
    return jsStore;
};
export const createSignal = (initialValue) => {
    if (NATIVE_READY) {
        const id = global.__signalForgeCreateSignal(initialValue);
        return { id };
    }
    const store = getJsStore();
    const signal = store.createSignal(initialValue);
    return { id: signal.__id || String(Math.random()) };
};
export const getSignal = (signalRef) => {
    if (NATIVE_READY) {
        return global.__signalForgeGetSignal(signalRef.id);
    }
    const store = getJsStore();
    throw new Error('JavaScript fallback for getSignal not fully implemented');
};
export const setSignal = (signalRef, value) => {
    if (NATIVE_READY) {
        global.__signalForgeSetSignal(signalRef.id, value);
        return;
    }
    const store = getJsStore();
    throw new Error('JavaScript fallback for setSignal not fully implemented');
};
export const hasSignal = (signalRef) => {
    if (NATIVE_READY) {
        return global.__signalForgeHasSignal(signalRef.id);
    }
    return false;
};
export const deleteSignal = (signalRef) => {
    if (NATIVE_READY) {
        global.__signalForgeDeleteSignal(signalRef.id);
        return;
    }
};
export const getSignalVersion = (signalRef) => {
    if (NATIVE_READY) {
        return global.__signalForgeGetVersion(signalRef.id);
    }
    return 0;
};
export const batchUpdate = (updates) => {
    if (NATIVE_READY) {
        const nativeUpdates = updates.map(([ref, value]) => [
            ref.id,
            value,
        ]);
        global.__signalForgeBatchUpdate(nativeUpdates);
        return;
    }
    for (const [ref, value] of updates) {
        setSignal(ref, value);
    }
};
export const isUsingNative = () => {
    return NATIVE_READY;
};
export const getImplementationInfo = () => {
    return {
        native: NATIVE_READY,
        engine: NATIVE_READY
            ? (typeof HermesInternal !== 'undefined' ? 'Hermes' : 'JSC')
            : 'JavaScript',
        features: {
            directMemoryAccess: NATIVE_READY,
            atomicOperations: NATIVE_READY,
            threadSafe: NATIVE_READY,
            sharedPtrManagement: NATIVE_READY,
        },
    };
};
export default {
    createSignal,
    getSignal,
    setSignal,
    hasSignal,
    deleteSignal,
    getSignalVersion,
    batchUpdate,
    isUsingNative,
    getImplementationInfo,
};