@codexo/exojs 0.6.3 → 0.6.4

package/dist/exo.esm.js

@@ -372,6 +372,202 @@ const canvasSourceToDataUrl = (source) => {
     return canvasElement.toDataURL();
 };
 
+/// <reference types="@webgpu/types" />
+// Browser-environment feature detection. Construction is private; the
+// only public entry is `Capabilities.ready`, a lazy-cached `Promise<Capabilities>`
+// that fires the (mostly) async probes on first access and returns the
+// same Promise for every subsequent call. Once it resolves, the returned
+// instance is frozen — every property is read once and never mutates.
+//
+// Synchronous callsites should keep the resolved instance in scope (e.g.,
+// `app.capabilities` after `await app.start(...)`); there is no global
+// sync mirror, by design.
+const hasWindow = typeof window !== 'undefined';
+const hasDocument = typeof document !== 'undefined';
+const hasNavigator = typeof navigator !== 'undefined';
+class Capabilities {
+    static _readyPromise = null;
+    /**
+     * Lazy-cached Promise that resolves to a frozen Capabilities instance.
+     *
+     * The first read kicks off the async probes (currently just the WebGPU
+     * adapter request); every subsequent read returns the same Promise.
+     * Concurrent callers share the in-flight detection — no double work.
+     *
+     * Early-warmup pattern for callers who want to overlap detection with
+     * other startup work:
+     *
+     * ```ts
+     * void Capabilities.ready;          // fire-and-forget; starts probes now
+     * // ... unrelated bootstrap ...
+     * const caps = await Capabilities.ready;  // typically already resolved
+     * ```
+     */
+    static get ready() {
+        if (Capabilities._readyPromise === null) {
+            Capabilities._readyPromise = Capabilities._detect();
+        }
+        return Capabilities._readyPromise;
+    }
+    webgl2;
+    webgpu;
+    webgpuAdapter;
+    webgpuVendor;
+    webgpuArchitecture;
+    pointer;
+    keyboard;
+    gamepad;
+    touch;
+    maxTouchPoints;
+    audio;
+    fullscreen;
+    vibration;
+    offscreenCanvas;
+    webWorkers;
+    devicePixelRatio;
+    constructor(values) {
+        this.webgl2 = values.webgl2;
+        this.webgpu = values.webgpu;
+        this.webgpuAdapter = values.webgpuAdapter;
+        this.webgpuVendor = values.webgpuVendor;
+        this.webgpuArchitecture = values.webgpuArchitecture;
+        this.pointer = values.pointer;
+        this.keyboard = values.keyboard;
+        this.gamepad = values.gamepad;
+        this.touch = values.touch;
+        this.maxTouchPoints = values.maxTouchPoints;
+        this.audio = values.audio;
+        this.fullscreen = values.fullscreen;
+        this.vibration = values.vibration;
+        this.offscreenCanvas = values.offscreenCanvas;
+        this.webWorkers = values.webWorkers;
+        this.devicePixelRatio = values.devicePixelRatio;
+        Object.freeze(this);
+    }
+    static async _detect() {
+        const [webgpuAdapter, webgpuInfo] = await probeWebGpu();
+        return new Capabilities({
+            webgl2: probeWebGl2(),
+            webgpu: probeWebGpuApiSurface(),
+            webgpuAdapter,
+            webgpuVendor: webgpuInfo?.vendor ?? null,
+            webgpuArchitecture: webgpuInfo?.architecture ?? null,
+            pointer: probePointer(),
+            keyboard: probeKeyboard(),
+            gamepad: probeGamepad(),
+            touch: probeTouchSupported(),
+            maxTouchPoints: probeMaxTouchPoints(),
+            audio: probeAudio(),
+            fullscreen: probeFullscreen(),
+            vibration: probeVibration(),
+            offscreenCanvas: probeOffscreenCanvas(),
+            webWorkers: probeWebWorkers(),
+            devicePixelRatio: hasWindow ? window.devicePixelRatio : 1,
+        });
+    }
+}
+// --- probes ---------------------------------------------------------------
+function probeWebGl2() {
+    if (!hasDocument)
+        return false;
+    try {
+        const canvas = document.createElement('canvas');
+        const gl = canvas.getContext('webgl2');
+        return gl !== null;
+    }
+    catch {
+        return false;
+    }
+}
+function probeWebGpuApiSurface() {
+    return hasNavigator && 'gpu' in navigator;
+}
+async function probeWebGpu() {
+    if (!probeWebGpuApiSurface())
+        return [null, null];
+    const gpu = navigator.gpu;
+    if (!gpu || typeof gpu.requestAdapter !== 'function')
+        return [null, null];
+    try {
+        const adapter = await gpu.requestAdapter();
+        if (!adapter)
+            return [null, null];
+        // Modern path: GPUAdapter.info is a sync property (Chrome 116+,
+        // Safari 18+). Older browsers exposed a deprecated async
+        // requestAdapterInfo() instead. Try the modern path first, fall
+        // back if needed.
+        const adapterAny = adapter;
+        if (adapterAny.info) {
+            return [adapter, adapterAny.info];
+        }
+        if (typeof adapterAny.requestAdapterInfo === 'function') {
+            try {
+                return [adapter, await adapterAny.requestAdapterInfo()];
+            }
+            catch {
+                return [adapter, null];
+            }
+        }
+        return [adapter, null];
+    }
+    catch {
+        return [null, null];
+    }
+}
+function probePointer() {
+    return hasWindow && 'PointerEvent' in window;
+}
+function probeKeyboard() {
+    return hasWindow && 'KeyboardEvent' in window;
+}
+function probeGamepad() {
+    return hasNavigator && typeof navigator.getGamepads === 'function';
+}
+function probeTouchSupported() {
+    if (!hasWindow)
+        return false;
+    if ('ontouchstart' in window)
+        return true;
+    if (probeMaxTouchPoints() > 0)
+        return true;
+    return false;
+}
+function probeMaxTouchPoints() {
+    if (!hasNavigator)
+        return 0;
+    const points = navigator.maxTouchPoints;
+    return typeof points === 'number' ? points : 0;
+}
+function probeAudio() {
+    if (!hasWindow)
+        return false;
+    const w = window;
+    return typeof w.AudioContext !== 'undefined' || typeof w.webkitAudioContext !== 'undefined';
+}
+function probeFullscreen() {
+    if (!hasDocument)
+        return false;
+    const el = document.documentElement;
+    return typeof el.requestFullscreen === 'function' || typeof el.webkitRequestFullscreen === 'function';
+}
+function probeVibration() {
+    return hasNavigator && typeof navigator.vibrate === 'function';
+}
+function probeOffscreenCanvas() {
+    // The browser global is verbatim `OffscreenCanvas`; eslint's
+    // strict-camelCase rule rejects the property name even though we
+    // can't rename a web standard.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    return hasWindow && typeof window.OffscreenCanvas !== 'undefined';
+}
+function probeWebWorkers() {
+    // The browser global is verbatim `Worker`; eslint's strict-camelCase
+    // rule rejects the property name even though we can't rename a web
+    // standard.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    return hasWindow && typeof window.Worker === 'function';
+}
+
 class Clock {
     _startTime;
     _elapsedTime = new Time(0);
@@ -14655,6 +14851,7 @@ class Application {
     _frameRequest = 0;
     _backendType;
     _backend;
+    _capabilities = null;
     constructor(appSettings) {
         this.options = {
             canvas: appSettings?.canvas ?? createDefaultCanvas(),
@@ -14696,11 +14893,26 @@ class Application {
     get backend() {
         return this._backend;
     }
+    /**
+     * Resolved capabilities for the host browser. Available after
+     * {@link Application.start} resolves; reading before that throws.
+     * For pre-start access use {@link Capabilities.ready} directly.
+     */
+    get capabilities() {
+        if (this._capabilities === null) {
+            throw new Error('Application.capabilities is unavailable before start() resolves. Use `await Capabilities.ready` for pre-start checks.');
+        }
+        return this._capabilities;
+    }
     async start(scene) {
         if (this._status === ApplicationStatus.Stopped) {
             this._status = ApplicationStatus.Loading;
+            // Kick off capability detection in parallel with renderer init —
+            // both are mostly-async startup work, no point serializing them.
+            const capabilitiesPromise = Capabilities.ready;
             try {
                 await this.initializeRenderManager();
+                this._capabilities = await capabilitiesPromise;
                 await this.sceneManager.setScene(scene);
                 this._frameRequest = requestAnimationFrame(this._updateHandler);
                 this._frameClock.restart();
@@ -14798,100 +15010,6 @@ class Application {
     }
 }
 
-// Browser feature-detection probes evaluated once at module load. The
-// resulting `capabilities` object is a `Readonly<Record<CapabilityName,
-// boolean>>` and can be inspected directly or queried via `isSupported`.
-//
-// All probes are synchronous. Async questions ("can I actually acquire a
-// WebGPU adapter?", "can the audio decoder play this OGG file?") are
-// outside this module's scope — they're owned by the Application's
-// backend selection and the Loader respectively. `capabilities.webgpu`
-// returning `true` only guarantees that the browser advertises WebGPU,
-// not that an adapter request will succeed.
-const hasWindow = typeof window !== 'undefined';
-const hasDocument = typeof document !== 'undefined';
-const hasNavigator = typeof navigator !== 'undefined';
-const probeWebGl2 = () => {
-    if (!hasDocument)
-        return false;
-    try {
-        const canvas = document.createElement('canvas');
-        const gl = canvas.getContext('webgl2');
-        return gl !== null;
-    }
-    catch {
-        return false;
-    }
-};
-const probeWebGpu = () => {
-    return hasNavigator && 'gpu' in navigator;
-};
-const probeAudio = () => {
-    if (!hasWindow)
-        return false;
-    const w = window;
-    return typeof w.AudioContext !== 'undefined' || typeof w.webkitAudioContext !== 'undefined';
-};
-const probePointer = () => {
-    return hasWindow && 'PointerEvent' in window;
-};
-const probeTouch = () => {
-    if (!hasWindow)
-        return false;
-    if ('ontouchstart' in window)
-        return true;
-    if (hasNavigator && typeof navigator.maxTouchPoints === 'number' && navigator.maxTouchPoints > 0)
-        return true;
-    return false;
-};
-const probeGamepad = () => {
-    return hasNavigator && typeof navigator.getGamepads === 'function';
-};
-const probeKeyboard = () => {
-    return hasWindow && 'KeyboardEvent' in window;
-};
-const probeFullscreen = () => {
-    if (!hasDocument)
-        return false;
-    const el = document.documentElement;
-    return typeof el.requestFullscreen === 'function' || typeof el.webkitRequestFullscreen === 'function';
-};
-const probeVibration = () => {
-    return hasNavigator && typeof navigator.vibrate === 'function';
-};
-const probeOffscreenCanvas = () => {
-    // The browser global is verbatim `OffscreenCanvas`; eslint's
-    // strict-camelCase rule rejects the property name even though we
-    // can't rename a web standard.
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    return hasWindow && typeof window.OffscreenCanvas !== 'undefined';
-};
-/**
- * Synchronous, one-shot feature-detection results. Computed once at
- * module load and frozen. Use either as a property bag (`capabilities.touch`)
- * or via {@link isSupported} for typed lookup.
- */
-const capabilities = Object.freeze({
-    webgl2: probeWebGl2(),
-    webgpu: probeWebGpu(),
-    audio: probeAudio(),
-    pointer: probePointer(),
-    touch: probeTouch(),
-    gamepad: probeGamepad(),
-    keyboard: probeKeyboard(),
-    fullscreen: probeFullscreen(),
-    vibration: probeVibration(),
-    offscreenCanvas: probeOffscreenCanvas(),
-});
-/**
- * Typed lookup over {@link capabilities}. Identical to
- * `capabilities[name]` but the function form gives clearer call-sites
- * when the name is computed.
- */
-function isSupported(name) {
-    return capabilities[name];
-}
-
 class Quadtree {
     static maxSceneNodes = 50;
     static maxLevel = 5;
@@ -19079,5 +19197,5 @@ const createRapierPhysicsWorld = async (options = {}) => {
     return await RapierPhysicsWorld.create(options);
 };
 
-export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, ChannelOffset, ChannelSize, Circle, CircleGeometry, Clock, CollisionType, Color, ColorAffector, ColorFilter, Container, Drawable, DrawableShape, Ellipse, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Geometry, Graphics, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, Particle, ParticleOptions, ParticleSystem, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, RapierPhysicsBinding, RapierPhysicsWorld, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2PrimitiveRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuPrimitiveRenderer, WebGpuSpriteRenderer, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, capabilities, clamp, createRapierPhysicsWorld, createRenderStats, createWebGl2ShaderProgram, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, isSupported, lerp, matchesIds, milliseconds, minutes, noop$1 as noop, normalizeIds, onAudioContextReady, parseGamepadDescriptor, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign$1 as sign, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
+export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, Circle, CircleGeometry, Clock, CollisionType, Color, ColorAffector, ColorFilter, Container, Drawable, DrawableShape, Ellipse, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Geometry, Graphics, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, Particle, ParticleOptions, ParticleSystem, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, RapierPhysicsBinding, RapierPhysicsWorld, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2PrimitiveRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuPrimitiveRenderer, WebGpuSpriteRenderer, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRapierPhysicsWorld, createRenderStats, createWebGl2ShaderProgram, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, lerp, matchesIds, milliseconds, minutes, noop$1 as noop, normalizeIds, onAudioContextReady, parseGamepadDescriptor, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign$1 as sign, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
 //# sourceMappingURL=exo.esm.js.map