@symbiote-native/engine 1.4.0 → 1.5.0

package/build/event-value-source.d.ts

@@ -0,0 +1,4 @@
+import type { IEventSubscription } from './native-events';
+export type IEventValueSource<TValue, TEvent extends string = string> = {
+    addListener: (event: TEvent, listener: (value: TValue) => void) => IEventSubscription;
+};

package/build/event-value-source.js

@@ -0,0 +1,3 @@
+// A source that emits a named event carrying its own next value (`useAudioPlayerStatus`, ...)
+// `TEvent` generic so a `SharedObject`'s own literal-keyed `addListener` structurally matches
+export {};

package/build/expo-native-view.d.ts

@@ -0,0 +1,2 @@
+export declare function expoViewManagerName(moduleName: string): string;
+export declare function tryRegisterNativeView(register: () => unknown): boolean;

package/build/expo-native-view.js

@@ -0,0 +1,19 @@
+// The Fabric name `requireNativeViewManager` registers: the adapter prefix plus the module name,
+// and the app identifier when the host sets one
+export function expoViewManagerName(moduleName) {
+    const appIdentifier = Reflect.get(Reflect.get(globalThis, 'expo') ?? {}, '__expo_app_identifier__');
+    const suffix = typeof appIdentifier === 'string' && appIdentifier !== ''
+        ? `_${appIdentifier}`
+        : '';
+    return `ViewManagerAdapter_${moduleName}${suffix}`;
+}
+// A missing view config must not crash the render, the view just renders nothing
+export function tryRegisterNativeView(register) {
+    try {
+        register();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/build/index.d.ts

@@ -52,6 +52,7 @@ export { reportUncaughtError } from './report-error';
 export type { IUncaughtErrorInfo } from './report-error';
 export { getNativeModule, getEnforcingNativeModule } from './native-modules';
 export { installDeviceEventHub, NativeEventEmitter, setDeviceEventSource, } from './native-events';
+export type { IEventValueSource } from './event-value-source';
 export type { IEventSubscription, IEventEmitterModule, INativeEventListener, IDeviceEventSource, } from './native-events';
 export { AnimatedNode, AnimatedWithChildren, AnimatedValue, AnimatedValueXY, AnimatedColor, AnimatedInterpolation, AnimatedAddition, AnimatedSubtraction, AnimatedMultiplication, AnimatedDivision, AnimatedModulo, AnimatedDiffClamp, AnimatedEvent, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent, attachNativeEvent, attachNativeEventHandler, flushValue, Easing, createNumericInterpolation, checkValidRanges, TimingAnimation, SpringAnimation, DecayAnimation, AnimatedTracking, timing, spring, decay, parallel, sequence, stagger, loop, delay, nativeAnimated, isNativeAnimatedAvailable, AnimatedProps, createAnimatedLeafLifecycle, AnimatedStyle, AnimatedTransform, AnimatedMock, reduceProps, isAnimatedNode, readPassthroughStyle, resolveHostNode, } from './animated';
 export type { IAnimatedLeafLifecycle, IValueXY, IRgbaValue, IColorInput, IEventConfig, IEventListener, IAnimatedEventHandler, INativeEventAttachment, IValueListener, IEasing, IEasingFunction, IInterpolationConfig, IExtrapolateType, IAnimation, IEndCallback, IEndResult, ICompositeAnimation, ITimingConfig, ISpringConfig, IDecayConfig, IParallelConfig, ILoopAnimationConfig, INativeNodeConfig, INativeAnimationConfig, INativeEventMapping, IPlatformConfig, } from './animated';
@@ -106,3 +107,9 @@ export type { IClaimMode, IHostBehavior, IPayloadFold } from './host-behavior';
 export { setBehaviorListener, markPropsDirty, setNodeDispatch } from './node';
 export { hasListenerFor, listenerFor } from './node';
 export type { IEventDispatch } from './node';
+export { createPermissionApi, resolveInitialPermission, fetchInitialPermission, splitWriteOnlyPermissionOptions, } from './permission-hook-runtime';
+export type { IWriteOnlyPermissionOptions } from './permission-hook-runtime';
+export { expoViewManagerName, tryRegisterNativeView } from './expo-native-view';
+export { createResourceController } from './resource-controller';
+export type { IResourceController } from './resource-controller';
+export type { IPermissionHookBehavior, IPermissionHookMethods, IPermissionHookOptions, IPermissionApi, IPermissionHookResult, } from './permission-hook-runtime';

package/build/index.js

@@ -139,3 +139,6 @@ export { setBehaviorListener, markPropsDirty, setNodeDispatch } from './node.js'
 // The only correct way to ask what would receive an event: a behavior may answer a name through
 // one shared `IEventDispatch` rather than a closure in `node.listeners`
 export { hasListenerFor, listenerFor } from './node.js';
+export { createPermissionApi, resolveInitialPermission, fetchInitialPermission, splitWriteOnlyPermissionOptions, } from './permission-hook-runtime.js';
+export { expoViewManagerName, tryRegisterNativeView } from './expo-native-view.js';
+export { createResourceController } from './resource-controller.js';

package/build/permission-hook-runtime.d.ts

@@ -0,0 +1,27 @@
+export type IPermissionHookBehavior = {
+    /** Auto-fetch the current status on mount without asking the user. @default true */
+    get?: boolean;
+    /** Auto-request the user to grant permission on mount. @default false */
+    request?: boolean;
+};
+export type IPermissionHookMethods<TPermission, TOptions extends object> = {
+    getMethod: (options?: TOptions) => Promise<TPermission>;
+    requestMethod: (options?: TOptions) => Promise<TPermission>;
+};
+export type IPermissionHookOptions<TOptions extends object> = IPermissionHookBehavior & TOptions;
+export type IPermissionApi<TPermission, TOptions extends object> = {
+    get: (methodOptions?: TOptions) => Promise<TPermission>;
+    request: (methodOptions?: TOptions) => Promise<TPermission>;
+};
+export declare function createPermissionApi<TPermission, TOptions extends object>(methods: IPermissionHookMethods<TPermission, TOptions>, setStatus: (value: TPermission) => void): IPermissionApi<TPermission, TOptions>;
+export declare function resolveInitialPermission<TPermission, TOptions extends object>(methods: IPermissionHookMethods<TPermission, TOptions>, behavior: IPermissionHookBehavior, methodOptions: TOptions | undefined): Promise<TPermission | null>;
+export type IPermissionHookResult<TPermission> = [
+    TPermission | null,
+    () => Promise<TPermission>,
+    () => Promise<TPermission>
+];
+export type IWriteOnlyPermissionOptions = {
+    writeOnly?: boolean;
+};
+export declare function splitWriteOnlyPermissionOptions(options?: IPermissionHookOptions<IWriteOnlyPermissionOptions>): [IPermissionHookBehavior, IWriteOnlyPermissionOptions | undefined];
+export declare function fetchInitialPermission<TPermission, TOptions extends object>(methods: IPermissionHookMethods<TPermission, TOptions>, behavior: IPermissionHookBehavior | undefined, methodOptions: TOptions | undefined, commit: (value: TPermission) => void): void;

package/build/permission-hook-runtime.js

@@ -0,0 +1,37 @@
+// Framework-agnostic twin of expo-modules-core's `usePermission` method-dispatch. Every Expo
+// wrapper package's hook/composable/primitive/service imports this, no per-package copy left
+// The one piece every adapter's hook/composable/primitive would otherwise re-wrap by hand:
+// call the method, commit its response to whichever state primitive `setStatus` closes over
+export function createPermissionApi(methods, setStatus) {
+    async function run(method, methodOptions) {
+        const response = await method(methodOptions);
+        setStatus(response);
+        return response;
+    }
+    return {
+        get: methodOptions => run(methods.getMethod, methodOptions),
+        request: methodOptions => run(methods.requestMethod, methodOptions),
+    };
+}
+export async function resolveInitialPermission(methods, behavior, methodOptions) {
+    const { get = true, request = false } = behavior;
+    if (!request && !get)
+        return null;
+    const method = request ? methods.requestMethod : methods.getMethod;
+    return methodOptions !== undefined && Object.keys(methodOptions).length > 0
+        ? method(methodOptions)
+        : method();
+}
+export function splitWriteOnlyPermissionOptions(options) {
+    const { get, request, writeOnly } = options ?? {};
+    return [
+        { get, request },
+        writeOnly === undefined ? undefined : { writeOnly },
+    ];
+}
+export function fetchInitialPermission(methods, behavior, methodOptions, commit) {
+    resolveInitialPermission(methods, { get: behavior?.get ?? true, request: behavior?.request ?? false }, methodOptions).then(response => {
+        if (response)
+            commit(response);
+    });
+}

package/build/resource-controller.d.ts

@@ -0,0 +1,6 @@
+export type IResourceController<TKey, TResource> = {
+    resolve: (key: TKey) => TResource;
+    flushDispose: () => void;
+    dispose: () => void;
+};
+export declare function createResourceController<TKey, TResource>(create: (key: TKey) => TResource, dispose: (resource: TResource) => void, isSameKey?: (a: TKey, b: TKey) => boolean): IResourceController<TKey, TResource>;

package/build/resource-controller.js

@@ -0,0 +1,30 @@
+// Generic twin of expo-modules-core's `useReleasingSharedObject`. `resolve()` never disposes
+// inline - the stale resource waits in `flushDispose()`, called from each adapter's own
+// commit/effect phase, matching upstream's own "release outside of render" invariant
+export function createResourceController(create, dispose, isSameKey = Object.is) {
+    let current = null;
+    let pendingDispose = null;
+    function resolve(key) {
+        if (current && isSameKey(current.key, key))
+            return current.resource;
+        if (current)
+            pendingDispose = current.resource;
+        const resource = create(key);
+        current = { key, resource };
+        return resource;
+    }
+    function flushDispose() {
+        if (pendingDispose) {
+            dispose(pendingDispose);
+            pendingDispose = null;
+        }
+    }
+    function disposeAll() {
+        flushDispose();
+        if (current) {
+            dispose(current.resource);
+            current = null;
+        }
+    }
+    return { resolve, flushDispose, dispose: disposeAll };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/engine",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "SymbioteNative's retained shadow-tree engine — clone-on-write commit path + event normalization over React Native Fabric, shared by every framework adapter.",
   "license": "MIT",
   "repository": {
@@ -71,7 +71,7 @@
   },
   "peerDependenciesMeta": {},
   "devDependencies": {
-    "@symbiote-native/test-utils": "0.4.5"
+    "@symbiote-native/test-utils": "0.4.6"
   },
   "scripts": {
     "typecheck": "tsc --build",