@symbiote-native/gl 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,39 @@
-# Temporary Holding Version
+# @symbiote-native/gl
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[`expo-gl`](https://docs.expo.dev/versions/latest/sdk/gl-view/) for **every**
+[SymbioteNative](../../README.md) adapter: React, Vue, Svelte, Solid and Angular. A `GLView` that
+gives a WebGL2 context to draw into, headless contexts and snapshots.
+
+## Install
+
+```bash
+npx @symbiote-native/cli new my-app --gl   # new app
+npx @symbiote-native/cli add --gl          # existing app
+```
+
+Manual: `npm install @symbiote-native/gl`, then wire `expo-modules-autolinking` once per app.
+Never install `expo-gl` or the `expo` meta-package yourself.
+
+## Usage
+
+```tsx
+import { GLView, type IExpoWebGLRenderingContext } from '@symbiote-native/gl/react';
+
+function onContextCreate(gl: IExpoWebGLRenderingContext) {
+  gl.clearColor(0, 1, 1, 1);
+  gl.clear(gl.COLOR_BUFFER_BIT);
+  gl.endFrameEXP();
+}
+
+<GLView style={{ flex: 1 }} onContextCreate={onContextCreate} />;
+```
+
+The statics of upstream's `GLView` class are plain functions: `createContextAsync`,
+`destroyContextAsync`, `takeSnapshotAsync`, `getWorkletContext`. The handle of a view has
+`exglCtxId`, `createCameraTextureAsync`, `destroyObjectAsync` and `takeSnapshotAsync`, reached by a
+`ref` in React and Solid (`ref={fn}`), a template ref in Vue, `bind:this` in Svelte and a
+`@ViewChild` in Angular. `gl.__expoSetLogging` prints with `console.warn`.
+
+## Not ported
+
+The web build, the hidden `nativeRef_EXPERIMENTAL` prop and upstream's one test (skipped there).

package/build/angular/gl-view/index.d.ts

@@ -0,0 +1,18 @@
+import { NativeViewBase } from '@symbiote-native/angular';
+import type { IDescriptor } from '@symbiote-native/components';
+import type { IGLViewProps } from '../../core';
+declare const GL_VIEW_INPUTS: readonly ["onContextCreate", "msaaSamples", "enableExperimentalWorkletSupport"];
+export interface GLView extends Partial<Pick<IGLViewProps, (typeof GL_VIEW_INPUTS)[number]>> {
+}
+/** Angular twin of `expo-gl`'s `GLView` */
+export declare class GLView extends NativeViewBase {
+    private readonly view;
+    readonly createCameraTextureAsync: (camera: import("..").IGLNodeOrTag) => Promise<WebGLTexture>;
+    readonly destroyObjectAsync: (glObject: import("..").IGLObject) => Promise<boolean>;
+    readonly takeSnapshotAsync: (options?: import("..").IGLSnapshotOptions) => Promise<import("..").IGLSnapshot>;
+    get exglCtxId(): number | undefined;
+    protected readonly propNames: readonly ["onContextCreate", "msaaSamples", "enableExperimentalWorkletSupport"];
+    protected renderView(props: object): IDescriptor | null;
+    protected disposeView(): void;
+}
+export {};

package/build/angular/gl-view/index.js

@@ -0,0 +1,87 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { DescriptorOutlet, NativeViewBase } from '@symbiote-native/angular';
+import { createGLView } from '../../core/index.js';
+// One list is the inputs of the component and the props it hands to the native view
+const GL_VIEW_INPUTS = [
+    'onContextCreate',
+    'msaaSamples',
+    'enableExperimentalWorkletSupport',
+];
+/** Angular twin of `expo-gl`'s `GLView` */
+let GLView = (() => {
+    let _classDecorators = [Component({
+            selector: 'GLView',
+            standalone: true,
+            imports: [DescriptorOutlet],
+            inputs: [...GL_VIEW_INPUTS],
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            template: `@if (descriptor; as node) {
+    <symbiote-descriptor-outlet [node]="node" />
+  }`,
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = NativeViewBase;
+    var GLView = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            GLView = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        view = createGLView(() => this.hostNode());
+        // The functions of the view are members of the component, a `@ViewChild` reaches them
+        createCameraTextureAsync = this.view.handle.createCameraTextureAsync;
+        destroyObjectAsync = this.view.handle.destroyObjectAsync;
+        takeSnapshotAsync = this.view.handle.takeSnapshotAsync;
+        get exglCtxId() {
+            return this.view.handle.exglCtxId;
+        }
+        propNames = GL_VIEW_INPUTS;
+        renderView(props) {
+            return this.view.render(props);
+        }
+        disposeView() {
+            this.view.dispose();
+        }
+    };
+    return GLView = _classThis;
+})();
+export { GLView };

package/build/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { GLView } from './gl-view';
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/gl/angular: a GLView that gives a WebGL context to draw into, on a shared core
+export { GLView } from './gl-view/index.js';
+export * from '../core/index.js';

package/build/core/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const GL_MODULE_NAME = "ExpoGL";
+export declare const GL_PACKAGE_NAME = "expo-gl";
+/** Where the native module keeps the contexts it installs on the runtime, by id */
+export declare const GL_CONTEXTS_GLOBAL = "__EXGLContexts";

package/build/core/constants.js

@@ -0,0 +1,4 @@
+export const GL_MODULE_NAME = 'ExpoGL';
+export const GL_PACKAGE_NAME = 'expo-gl';
+/** Where the native module keeps the contexts it installs on the runtime, by id */
+export const GL_CONTEXTS_GLOBAL = '__EXGLContexts';

package/build/core/gl-context.d.ts

@@ -0,0 +1,13 @@
+import type { IExpoWebGLRenderingContext, IGLSnapshot, IGLSnapshotOptions } from './types';
+/** The context of a worklet, `exgl` has to be created with worklet support */
+export declare function getWorkletContext(contextId: number): IExpoWebGLRenderingContext | undefined;
+export declare function unregisterGLContext(exglCtxId: number): void;
+/** The GL interface of a context id the native side created */
+export declare function getGl(exglCtxId: number): IExpoWebGLRenderingContext;
+export declare function getContextId(exgl?: IExpoWebGLRenderingContext | number): number;
+/** A context with no view, which does not present its framebuffer, take a snapshot to see it */
+export declare function createContextAsync(): Promise<IExpoWebGLRenderingContext>;
+/** For a headless context made by `createContextAsync` */
+export declare function destroyContextAsync(exgl?: IExpoWebGLRenderingContext | number): Promise<boolean>;
+/** Saves the framebuffer as a file in the cache directory of the app */
+export declare function takeSnapshotAsync(exgl?: IExpoWebGLRenderingContext | number, options?: IGLSnapshotOptions): Promise<IGLSnapshot>;

package/build/core/gl-context.js

@@ -0,0 +1,54 @@
+import { CodedError } from 'expo-modules-core';
+import { GL_CONTEXTS_GLOBAL } from './constants.js';
+import { configureLogging } from './gl-utils.js';
+import { glNativeModule } from './native-module.js';
+import { createWorkletContextManager } from './worklet-context-manager.js';
+const workletContextManager = createWorkletContextManager();
+function isContext(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** The context of a worklet, `exgl` has to be created with worklet support */
+export function getWorkletContext(contextId) {
+    'worklet';
+    return workletContextManager.getContext(contextId);
+}
+export function unregisterGLContext(exglCtxId) {
+    const contexts = Reflect.get(globalThis, GL_CONTEXTS_GLOBAL);
+    if (contexts)
+        Reflect.deleteProperty(Object(contexts), String(exglCtxId));
+    workletContextManager.unregister?.(exglCtxId);
+}
+/** The GL interface of a context id the native side created */
+export function getGl(exglCtxId) {
+    const contexts = Reflect.get(globalThis, GL_CONTEXTS_GLOBAL);
+    if (!contexts) {
+        throw new CodedError('ERR_GL_NOT_AVAILABLE', 'GL is currently not available. (Have you enabled remote debugging? GL is not available while debugging remotely.)');
+    }
+    const gl = Reflect.get(Object(contexts), String(exglCtxId));
+    if (!isContext(gl))
+        throw new Error(`There is no EXGLContext with id ${exglCtxId}`);
+    configureLogging(gl);
+    return gl;
+}
+export function getContextId(exgl) {
+    const exglCtxId = exgl && typeof exgl === 'object' ? exgl.contextId : exgl;
+    if (!exglCtxId || typeof exglCtxId !== 'number') {
+        throw new Error(`Invalid EXGLContext id: ${String(exglCtxId)}`);
+    }
+    return exglCtxId;
+}
+/** A context with no view, which does not present its framebuffer, take a snapshot to see it */
+export async function createContextAsync() {
+    const { exglCtxId } = await glNativeModule.createContextAsync();
+    return getGl(exglCtxId);
+}
+/** For a headless context made by `createContextAsync` */
+export async function destroyContextAsync(exgl) {
+    const exglCtxId = getContextId(exgl);
+    unregisterGLContext(exglCtxId);
+    return glNativeModule.destroyContextAsync(exglCtxId);
+}
+/** Saves the framebuffer as a file in the cache directory of the app */
+export async function takeSnapshotAsync(exgl, options = {}) {
+    return glNativeModule.takeSnapshotAsync(getContextId(exgl), options);
+}

package/build/core/gl-errors.d.ts

@@ -0,0 +1 @@
+export declare const GL_ERRORS: Readonly<Record<number, string>>;

package/build/core/gl-errors.js

@@ -0,0 +1,8 @@
+export const GL_ERRORS = {
+    1280: 'INVALID ENUM: An unacceptable value has been specified for an enumerated argument.',
+    1281: 'INVALID_VALUE: A numeric argument is out of range.',
+    1282: 'INVALID_OPERATION: The specified command is not allowed for the current state.',
+    1285: 'OUT_OF_MEMORY: Not enough memory is left to execute the command.',
+    1286: 'INVALID_FRAMEBUFFER_OPERATION: The currently bound framebuffer is not complete when trying to render to or to read from it.',
+    37442: 'CONTEXT_LOST_WEBGL: The WebGL context is lost.',
+};

package/build/core/gl-utils.d.ts

@@ -0,0 +1,5 @@
+import type { IExpoWebGLRenderingContext } from './types';
+type ILoggableGL = Pick<IExpoWebGLRenderingContext, '__expoSetLogging'>;
+/** Adds `__expoSetLogging` to the context, for the logging options useful in debugging GL calls */
+export declare function configureLogging(gl: ILoggableGL): void;
+export {};

package/build/core/gl-utils.js

@@ -0,0 +1,84 @@
+import { GL_ERRORS } from './gl-errors.js';
+import { GLLoggingOption } from './types.js';
+const MAX_STRING_LENGTH = 20;
+const SET_LOGGING_KEY = '__expoSetLogging';
+const wrappers = new WeakSet();
+function isGLFunction(value) {
+    return typeof value === 'function';
+}
+function constantNameOf(gl, value) {
+    for (const name in gl) {
+        if (Reflect.get(gl, name) === value)
+            return name;
+    }
+    return undefined;
+}
+// Numbers get the name of a constant that holds them, which can mislead for a size, so the
+// number stays. Strings are cut because a shader is long and logging it blocks the bridge
+function describeArg(gl, option, arg) {
+    if (option & GLLoggingOption.RESOLVE_CONSTANTS && typeof arg === 'number') {
+        const name = constantNameOf(gl, arg);
+        if (name)
+            return `${arg} (${name})`;
+    }
+    const isLong = typeof arg === 'string' && arg.length > MAX_STRING_LENGTH;
+    if (option & GLLoggingOption.TRUNCATE_STRINGS && isLong) {
+        const lastSpace = arg.lastIndexOf(' ', MAX_STRING_LENGTH);
+        return `${arg.slice(0, lastSpace >= 0 ? lastSpace : MAX_STRING_LENGTH)}...`;
+    }
+    return String(arg);
+}
+// The original `getError`, a wrapped one would log itself
+function reportError(gl) {
+    const getError = Reflect.get(Reflect.getPrototypeOf(gl) ?? {}, 'getError');
+    if (!isGLFunction(getError))
+        return;
+    const error = getError.call(gl);
+    if (typeof error !== 'number' || error === Reflect.get(gl, 'NO_ERROR'))
+        return;
+    console.warn(`\x1b[31mExpoGL: Error ${GL_ERRORS[error]}\x1b[0m`);
+}
+function wrapMethod(gl, key, original, getOption) {
+    const wrapper = (...args) => {
+        const option = getOption();
+        if (option & GLLoggingOption.METHOD_CALLS) {
+            const params = args.map(arg => describeArg(gl, option, arg));
+            console.warn(`ExpoGL: ${key}(${params.join(', ')})`);
+        }
+        const result = original.apply(gl, args);
+        if (option & GLLoggingOption.METHOD_CALLS)
+            console.warn(`ExpoGL:   = ${String(result)}`);
+        if (option & GLLoggingOption.GET_ERRORS && key !== 'getError')
+            reportError(gl);
+        return result;
+    };
+    wrappers.add(wrapper);
+    Reflect.set(gl, key, wrapper);
+}
+function wrapMethods(gl, getOption) {
+    for (const [key, original] of Object.entries(Reflect.getPrototypeOf(gl) ?? {})) {
+        if (isGLFunction(original) && key !== SET_LOGGING_KEY) {
+            wrapMethod(gl, key, original, getOption);
+        }
+    }
+}
+function unwrapMethods(gl) {
+    for (const [key, value] of Object.entries(gl)) {
+        if (isGLFunction(value) && wrappers.has(value))
+            Reflect.deleteProperty(gl, key);
+    }
+}
+/** Adds `__expoSetLogging` to the context, for the logging options useful in debugging GL calls */
+export function configureLogging(gl) {
+    let loggingOption = GLLoggingOption.DISABLED;
+    gl.__expoSetLogging = (option) => {
+        // Both on or both off needs no wrapping or unwrapping, only the new option
+        if (!loggingOption !== !option) {
+            if (option)
+                wrapMethods(gl, () => loggingOption);
+            else
+                unwrapMethods(gl);
+        }
+        loggingOption = option;
+    };
+}

package/build/core/gl-view.d.ts

@@ -0,0 +1,16 @@
+import type { IDescriptor } from '@symbiote-native/components';
+import type { ISymbioteNode } from '@symbiote-native/engine';
+import type { IGLViewHandle } from './types';
+export declare const glViewName: () => string;
+export declare const ensureGLViewRegistered: () => boolean;
+export type IGLView = {
+    handle: IGLViewHandle;
+    /** `null` means the view cannot register and the caller renders nothing */
+    render(props: object): IDescriptor | null;
+    /** Forgets the context of the surface, called when the view unmounts */
+    dispose(): void;
+};
+type IGetNode = () => ISymbioteNode | null | undefined;
+/** One per mounted view, `getNode` is kept for the shape the adapters share */
+export declare function createGLView(_getNode: IGetNode): IGLView;
+export {};

package/build/core/gl-view.js

@@ -0,0 +1,99 @@
+import { Platform, UnavailabilityError, requireNativeViewManager, } from 'expo-modules-core';
+import { el } from '@symbiote-native/components';
+import { defineExpoNativeView, getNativeTag, isDevBuild, isSymbioteNode, } from '@symbiote-native/engine';
+import { GL_MODULE_NAME, GL_PACKAGE_NAME } from './constants.js';
+import { getGl, takeSnapshotAsync, unregisterGLContext } from './gl-context.js';
+import { glNativeModule } from './native-module.js';
+// Registered on render: a barrel side effect is lost in a release build
+const glView = defineExpoNativeView(requireNativeViewManager, GL_MODULE_NAME);
+export const glViewName = glView.name;
+export const ensureGLViewRegistered = glView.ensureRegistered;
+const DEFAULT_MSAA_SAMPLES = 4;
+function isSurfaceCreated(value) {
+    return typeof Reflect.get(Object(value), 'exglCtxId') === 'number';
+}
+function isContextCallback(value) {
+    return typeof value === 'function';
+}
+// Adapters hand over the props they hold, a missing callback is a view nobody listens to
+function toViewProps(props) {
+    const onContextCreate = Reflect.get(props, 'onContextCreate');
+    return {
+        ...props,
+        onContextCreate: isContextCallback(onContextCreate) ? onContextCreate : () => undefined,
+    };
+}
+function nativeTagOf(camera) {
+    const tag = isSymbioteNode(camera) ? getNativeTag(camera) : camera;
+    if (typeof tag !== 'number')
+        throw new Error('The camera view has no native tag yet');
+    return tag;
+}
+/** One per mounted view, `getNode` is kept for the shape the adapters share */
+export function createGLView(_getNode) {
+    let exglCtxId;
+    let latestProps;
+    let hasWorkletSupport;
+    const onSurfaceCreate = (event) => {
+        if (!isSurfaceCreated(event.nativeEvent))
+            return;
+        exglCtxId = event.nativeEvent.exglCtxId;
+        latestProps?.onContextCreate(getGl(exglCtxId));
+    };
+    function warnOnWorkletChange(enabled) {
+        if (hasWorkletSupport !== undefined && hasWorkletSupport !== enabled) {
+            console.warn('Updating prop enableExperimentalWorkletSupport is not supported');
+        }
+        hasWorkletSupport = enabled;
+    }
+    const handle = {
+        get exglCtxId() {
+            return exglCtxId;
+        },
+        async createCameraTextureAsync(camera) {
+            if (!glNativeModule.createCameraTextureAsync) {
+                throw new UnavailabilityError(GL_PACKAGE_NAME, 'createCameraTextureAsync');
+            }
+            if (!exglCtxId)
+                throw new Error("GLView's surface is not created yet!");
+            const { exglObjId } = await glNativeModule.createCameraTextureAsync(exglCtxId, nativeTagOf(camera));
+            const texture = { id: exglObjId };
+            return texture;
+        },
+        async destroyObjectAsync(glObject) {
+            if (!glNativeModule.destroyObjectAsync) {
+                throw new UnavailabilityError(GL_PACKAGE_NAME, 'destroyObjectAsync');
+            }
+            return glNativeModule.destroyObjectAsync(glObject.id);
+        },
+        takeSnapshotAsync: (options) => takeSnapshotAsync(exglCtxId, options),
+    };
+    return {
+        handle,
+        dispose: () => {
+            if (exglCtxId)
+                unregisterGLContext(exglCtxId);
+        },
+        render: props => {
+            if (!ensureGLViewRegistered()) {
+                if (isDevBuild())
+                    console.warn("'GLView' is not available.");
+                return null;
+            }
+            latestProps = toViewProps(props);
+            const { onContextCreate, msaaSamples = DEFAULT_MSAA_SAMPLES, enableExperimentalWorkletSupport = false, ...viewProps } = latestProps;
+            warnOnWorkletChange(enableExperimentalWorkletSupport);
+            return el('view', viewProps, [
+                el(glViewName(), {
+                    style: {
+                        flex: 1,
+                        ...Platform.select({ ios: { backgroundColor: 'transparent' }, default: {} }),
+                    },
+                    onSurfaceCreate,
+                    enableExperimentalWorkletSupport,
+                    msaaSamples: Platform.select({ ios: msaaSamples, default: undefined }),
+                }),
+            ]);
+        },
+    };
+}

package/build/core/index.d.ts

@@ -0,0 +1,6 @@
+export { GL_MODULE_NAME } from './constants';
+export { createContextAsync, destroyContextAsync, getGl, getWorkletContext, takeSnapshotAsync, } from './gl-context';
+export { configureLogging } from './gl-utils';
+export { createGLView, ensureGLViewRegistered, glViewName, type IGLView } from './gl-view';
+export { GLLoggingOption } from './types';
+export type { IExpoWebGLRenderingContext, IGLNodeOrTag, IGLObject, IGLSnapshot, IGLSnapshotOptions, IGLSurfaceCreateEvent, IGLViewHandle, IGLViewProps, } from './types';

package/build/core/index.js

@@ -0,0 +1,5 @@
+export { GL_MODULE_NAME } from './constants.js';
+export { createContextAsync, destroyContextAsync, getGl, getWorkletContext, takeSnapshotAsync, } from './gl-context.js';
+export { configureLogging } from './gl-utils.js';
+export { createGLView, ensureGLViewRegistered, glViewName } from './gl-view.js';
+export { GLLoggingOption } from './types.js';

package/build/core/native-module.d.ts

@@ -0,0 +1,15 @@
+import type { IGLSnapshot, IGLSnapshotOptions } from './types';
+export type INativeGLModule = {
+    createContextAsync(): Promise<{
+        exglCtxId: number;
+    }>;
+    destroyContextAsync(exglCtxId: number): Promise<boolean>;
+    takeSnapshotAsync(exglCtxId: number, options: IGLSnapshotOptions): Promise<IGLSnapshot>;
+    /** Absent where there is no camera texture support */
+    createCameraTextureAsync?(exglCtxId: number, cameraTag: number): Promise<{
+        exglObjId: number;
+    }>;
+    /** Absent where objects cannot be destroyed one by one */
+    destroyObjectAsync?(exglObjId: number): Promise<boolean>;
+};
+export declare const glNativeModule: INativeGLModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+import { GL_MODULE_NAME } from './constants.js';
+export const glNativeModule = requireNativeModule(GL_MODULE_NAME);

package/build/core/types.d.ts

@@ -0,0 +1,75 @@
+import type { IAccessibilityProps, IAriaProps, IResponderProps } from '@symbiote-native/components';
+import type { IStyleProp, ISymbioteEvent, ISymbioteNode, IViewStyle } from '@symbiote-native/engine';
+export type IGLObject = {
+    id: number;
+};
+export type IGLSurfaceCreateEvent = {
+    nativeEvent: {
+        exglCtxId: number;
+    };
+};
+export type IGLSnapshotOptions = {
+    /** @default false */
+    flip?: boolean;
+    /** Defaults to the framebuffer shown in the view, or the current one of a headless context */
+    framebuffer?: WebGLFramebuffer;
+    /** Passed to `glReadPixels` */
+    rect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** PNG is lossless but slower, iOS writes a PNG instead of WebP. @default 'jpeg' */
+    format?: 'jpeg' | 'png' | 'webp';
+    /** From `0` (most compressed) to `1.0` (none). @default 1.0 */
+    compress?: number;
+};
+export type IGLSnapshot = {
+    uri: string | Blob | null;
+    /** Same as `uri`, which makes a snapshot usable in `texImage2D` */
+    localUri: string;
+    width: number;
+    height: number;
+};
+export type IExpoWebGLRenderingContext = WebGL2RenderingContext & {
+    contextId: number;
+    endFrameEXP(): void;
+    flushEXP(): void;
+    __expoSetLogging(option: GLLoggingOption): void;
+};
+/** A native tag, or the host node of a view such as a camera */
+export type IGLNodeOrTag = number | ISymbioteNode | null;
+export type IGLViewProps = IAccessibilityProps & IAriaProps & IResponderProps & {
+    style?: IStyleProp<IViewStyle>;
+    testID?: string;
+    nativeID?: string;
+    onLayout?: (event: ISymbioteEvent) => void;
+    /** Called with the context once the surface exists */
+    onContextCreate(gl: IExpoWebGLRenderingContext): void;
+    /** Multisampling, `0` turns it off. @default 4 @platform ios */
+    msaaSamples?: number;
+    /** Lets the Reanimated worklet thread use the `gl` object. @default false */
+    enableExperimentalWorkletSupport?: boolean;
+};
+export declare enum GLLoggingOption {
+    DISABLED = 0,
+    /** Logs calls, their parameters and results */
+    METHOD_CALLS = 1,
+    /** Calls `getError` after each call, which blocks and slows drawing down */
+    GET_ERRORS = 2,
+    /** Prints the name of the constant a numeric parameter holds */
+    RESOLVE_CONSTANTS = 4,
+    /** Cuts long strings such as shaders */
+    TRUNCATE_STRINGS = 8,
+    ALL = 15
+}
+/** What a ref to the view hands out */
+export type IGLViewHandle = {
+    /** The id of the context of the view, `undefined` until the surface exists */
+    readonly exglCtxId: number | undefined;
+    createCameraTextureAsync(camera: IGLNodeOrTag): Promise<WebGLTexture>;
+    destroyObjectAsync(glObject: IGLObject): Promise<boolean>;
+    /** A snapshot of the context of this view */
+    takeSnapshotAsync(options?: IGLSnapshotOptions): Promise<IGLSnapshot>;
+};

package/build/core/types.js

@@ -0,0 +1,13 @@
+export var GLLoggingOption;
+(function (GLLoggingOption) {
+    GLLoggingOption[GLLoggingOption["DISABLED"] = 0] = "DISABLED";
+    /** Logs calls, their parameters and results */
+    GLLoggingOption[GLLoggingOption["METHOD_CALLS"] = 1] = "METHOD_CALLS";
+    /** Calls `getError` after each call, which blocks and slows drawing down */
+    GLLoggingOption[GLLoggingOption["GET_ERRORS"] = 2] = "GET_ERRORS";
+    /** Prints the name of the constant a numeric parameter holds */
+    GLLoggingOption[GLLoggingOption["RESOLVE_CONSTANTS"] = 4] = "RESOLVE_CONSTANTS";
+    /** Cuts long strings such as shaders */
+    GLLoggingOption[GLLoggingOption["TRUNCATE_STRINGS"] = 8] = "TRUNCATE_STRINGS";
+    GLLoggingOption[GLLoggingOption["ALL"] = 15] = "ALL";
+})(GLLoggingOption || (GLLoggingOption = {}));

package/build/core/worklet-context-manager.d.ts

@@ -0,0 +1,6 @@
+import type { IExpoWebGLRenderingContext } from './types';
+export type IWorkletContextManager = {
+    getContext(contextId: number): IExpoWebGLRenderingContext | undefined;
+    unregister?(contextId: number): void;
+};
+export declare function createWorkletContextManager(): IWorkletContextManager;

package/build/core/worklet-context-manager.js

@@ -0,0 +1,34 @@
+import { GL_CONTEXTS_GLOBAL } from './constants.js';
+function isRunOnUI(value) {
+    return typeof value === 'function';
+}
+// Reanimated stays optional, and an import of it in a try block in the module that also holds the
+// view breaks with `inlineRequires`, so the manager lives in its own file
+export function createWorkletContextManager() {
+    try {
+        // Reanimated has to load before any workletized code is created
+        const reanimated = require('react-native-reanimated');
+        const runOnUI = Reflect.get(Object(reanimated), 'runOnUI');
+        if (!isRunOnUI(runOnUI))
+            throw new Error('react-native-reanimated has no runOnUI');
+        return {
+            getContext: contextId => {
+                'worklet';
+                return Reflect.get(Object(Reflect.get(globalThis, GL_CONTEXTS_GLOBAL)), String(contextId));
+            },
+            unregister: contextId => {
+                runOnUI(id => {
+                    'worklet';
+                    Reflect.deleteProperty(Object(Reflect.get(globalThis, GL_CONTEXTS_GLOBAL)), String(id));
+                })(contextId);
+            },
+        };
+    }
+    catch {
+        return {
+            getContext: () => {
+                throw new Error('Worklet runtime is not available');
+            },
+        };
+    }
+}