@directivegames/genesys.js 3.1.24

package/dist/src/utils/Utils.js

@@ -0,0 +1,296 @@
+import { customAlphabet } from 'nanoid';
+import { UNDEFINED_VALUE } from '../const.js';
+/**
+ * Utils aggregates a handful of lightweight helper functions used across Genesys modules.
+ *
+ * Detailed explanation:
+ * - Provides an `ensure` function that logs a stack trace when a condition fails to aid debugging.
+ * - Contains browser and node environment detection utilities for cross-platform checks.
+ * - Declares `OptionalSome` as a mapped type for constructing partial objects with required keys omitted.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Use `ensure` liberally in development builds to verify assumptions without stopping execution.
+ * - Prefer `isBrowser` and `isNode` when your code must branch based on runtime environment.
+ * - Keep these utilities minimal; avoid heavy dependencies or side effects in this module.
+ */
+/**
+ * Ensures a condition is true, logging a stack trace if it's not
+ * @param condition - The condition to check
+ * @param message - Optional message to log if condition is false
+ * @returns The original condition value
+ * @throws Will log a stack trace to console if condition is false
+ */
+export function ensure(condition, message) {
+    if (!Boolean(condition)) {
+        message ??= 'ensure failed';
+        console.error(new Error(message));
+    }
+    return condition;
+}
+/**
+ * Checks a condition, throwing an error if it's false
+ * @param condition - The condition to check
+ * @param message - Optional message to throw if condition is false
+ */
+export function check(condition, message) {
+    if (!Boolean(condition)) {
+        message ??= 'check failed';
+        throw new Error(message);
+    }
+}
+/**
+ * Sleeps for a given number of milliseconds
+ * @param ms - The number of milliseconds to sleep
+ * @returns A promise that resolves after the given number of milliseconds
+ */
+export async function sleep(ms) {
+    await new Promise(resolve => setTimeout(resolve, ms));
+}
+export function isBrowser() {
+    return typeof window !== 'undefined' && typeof window.document !== 'undefined';
+}
+export function isNode() {
+    return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+}
+const shortUUIDAlphabet = '1234567890abcdef';
+const shortUUIDGenerator = customAlphabet(shortUUIDAlphabet, 16);
+export function shortUUID(length) {
+    return shortUUIDGenerator(length);
+}
+export function omitIfDefault(current, defaultValue) {
+    // Check if objects have equals method and use it for comparison
+    if (current && typeof current === 'object' && 'equals' in current && typeof current.equals === 'function') {
+        return current.equals(defaultValue) ? undefined : current;
+    }
+    return current === defaultValue ? undefined : current;
+}
+export function overrideIfDefault(current, defaultValue, override) {
+    // Check if objects have equals method and use it for comparison
+    if (current && typeof current === 'object' && 'equals' in current && typeof current.equals === 'function') {
+        return current.equals(defaultValue) ? override : current;
+    }
+    return current === defaultValue ? override : current;
+}
+export function isMobileBrowser() {
+    if (!isBrowser()) {
+        return false;
+    }
+    // 1) UA sniff as a fallback
+    const uaMobile = /Mobi|Android|iPhone|iPad|iPod/i.test(navigator.userAgent);
+    if (uaMobile) {
+        console.log(`Returning true from isMobileBrowser because of user agent "${navigator.userAgent}"`);
+        return true;
+    }
+    // 2) Touch-based feature detection
+    const hasTouch = 'ontouchstart' in window;
+    if (hasTouch) {
+        console.log(`Returning true from isMobileBrowser because of touch capability, hasTouch: ${hasTouch}`);
+        return true;
+    }
+    return false;
+}
+export function getEnv(name) {
+    return import.meta.env && import.meta.env[name];
+}
+/**
+ * Deep merges two objects, recursively merging nested objects
+ * @param target - The target object to merge into
+ * @param source - The source object to merge from
+ * @returns The merged object
+ */
+export function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const sourceValue = source[key];
+            const targetValue = result[key];
+            // Skip undefined source values to preserve target values
+            if (sourceValue === undefined || sourceValue === UNDEFINED_VALUE) {
+                continue;
+            }
+            if (sourceValue &&
+                typeof sourceValue === 'object' &&
+                targetValue &&
+                typeof targetValue === 'object') {
+                if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
+                    // Both are arrays, merge elements by index
+                    const mergedArray = [...targetValue];
+                    for (let i = 0; i < sourceValue.length; i++) {
+                        if (i < targetValue.length &&
+                            sourceValue[i] &&
+                            typeof sourceValue[i] === 'object' &&
+                            targetValue[i] &&
+                            typeof targetValue[i] === 'object') {
+                            // Both elements are objects, deep merge them
+                            mergedArray[i] = deepMerge(targetValue[i], sourceValue[i]);
+                        }
+                        else {
+                            if (sourceValue[i] === undefined || sourceValue[i] === UNDEFINED_VALUE) {
+                                continue;
+                            }
+                            // Use source element (replace or extend array)
+                            mergedArray[i] = sourceValue[i];
+                        }
+                    }
+                    result[key] = mergedArray;
+                }
+                else if (!Array.isArray(sourceValue) && !Array.isArray(targetValue)) {
+                    // Both are objects, recursively merge
+                    result[key] = deepMerge(targetValue, sourceValue);
+                }
+                else {
+                    // One is array, one is object - source overwrites
+                    result[key] = sourceValue;
+                }
+            }
+            else {
+                // Source value overwrites target value
+                result[key] = sourceValue;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Creates a diff object containing only the properties that are different between source and target
+ * @param target - The target object to compare against
+ * @param source - The source object to extract differences from
+ * @returns An object containing only the properties that differ from target
+ */
+export function deepDiff(target, source) {
+    const result = {};
+    // If target is not an object, return the entire source
+    if (!target || typeof target !== 'object') {
+        return source;
+    }
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const sourceValue = source[key];
+            const targetValue = target[key];
+            // If target doesn't have this key, include it in diff
+            if (!(key in target)) {
+                result[key] = sourceValue;
+                continue;
+            }
+            // If values are strictly equal, skip
+            if (sourceValue === targetValue) {
+                continue;
+            }
+            // Handle null/undefined cases
+            if (sourceValue == null || targetValue == null) {
+                if (sourceValue !== targetValue) {
+                    result[key] = sourceValue;
+                }
+                continue;
+            }
+            // Both are objects/arrays
+            if (typeof sourceValue === 'object' && typeof targetValue === 'object') {
+                if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
+                    // Arrays - check if they're different
+                    if (sourceValue.length !== targetValue.length) {
+                        result[key] = sourceValue;
+                    }
+                    else {
+                        // Check each element
+                        let arrayDifferent = false;
+                        const arrayDiff = [];
+                        for (let i = 0; i < sourceValue.length; i++) {
+                            if (sourceValue[i] && typeof sourceValue[i] === 'object' &&
+                                targetValue[i] && typeof targetValue[i] === 'object') {
+                                const elementDiff = deepDiff(targetValue[i], sourceValue[i]);
+                                if (Object.keys(elementDiff).length > 0) {
+                                    arrayDiff[i] = elementDiff;
+                                    arrayDifferent = true;
+                                }
+                                else {
+                                    arrayDiff[i] = UNDEFINED_VALUE;
+                                }
+                            }
+                            else if (sourceValue[i] !== targetValue[i]) {
+                                arrayDiff[i] = sourceValue[i];
+                                arrayDifferent = true;
+                            }
+                            else {
+                                arrayDiff[i] = UNDEFINED_VALUE;
+                            }
+                        }
+                        if (arrayDifferent) {
+                            result[key] = arrayDiff;
+                        }
+                    }
+                }
+                else if (!Array.isArray(sourceValue) && !Array.isArray(targetValue)) {
+                    // Both are objects
+                    const objectDiff = deepDiff(targetValue, sourceValue);
+                    if (Object.keys(objectDiff).length > 0) {
+                        result[key] = objectDiff;
+                    }
+                }
+                else {
+                    // One is array, one is object - they're different
+                    result[key] = sourceValue;
+                }
+            }
+            else {
+                // Primitive values that are different
+                result[key] = sourceValue;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Deep removes empty objects ({}) from an object recursively
+ * @param obj - The object to clean
+ * @returns The object with empty objects removed
+ */
+export function deepRemoveEmptyObjects(obj) {
+    if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+        return obj;
+    }
+    const result = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const value = obj[key];
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                // Recursively clean nested objects
+                const cleaned = deepRemoveEmptyObjects(value);
+                // Only add if the cleaned object has properties
+                if (Object.keys(cleaned).length > 0) {
+                    result[key] = cleaned;
+                }
+            }
+            else {
+                // Keep non-object values and arrays
+                if (value !== undefined) {
+                    result[key] = value;
+                }
+            }
+        }
+    }
+    return result;
+}
+/** Recursively replaces all UUID values in an object with newly generated UUIDs, or removes the UUID keys entirely if deleteKey is enabled */
+export function replace_uuids(target, options = { deleteKey: false }) {
+    if (Array.isArray(target)) {
+        target.forEach(item => replace_uuids(item, options));
+        return;
+    }
+    if (typeof target === 'object' && target !== null) {
+        Object.keys(target).forEach(key => {
+            if (key === 'uuid') {
+                if (options.deleteKey) {
+                    delete target[key];
+                }
+                else {
+                    target[key] = shortUUID();
+                }
+            }
+            else {
+                replace_uuids(target[key], options);
+            }
+        });
+    }
+}
+;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Utils.js","sourceRoot":"","sources":["../../../src/utils/Utils.ts"],"names":[],"mappings":"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"}

package/dist/src/utils/VRButtonUtils.d.ts

@@ -0,0 +1,21 @@
+import type * as THREE from 'three';
+export interface VRSessionOptions {
+    /** Optional WebXR features to request */
+    optionalFeatures?: string[];
+    /** Required WebXR features */
+    requiredFeatures?: string[];
+    /** Framebuffer scale factor for VR rendering quality */
+    framebufferScaleFactor?: number;
+}
+export interface VRButtonOptions {
+    /** Custom button styles */
+    styles?: Partial<CSSStyleDeclaration>;
+    /** Custom button text */
+    enterText?: string;
+    exitText?: string;
+    notSupportedText?: string;
+}
+/**
+ * Creates a custom VR button with configurable WebXR features
+ */
+export declare function createVRButton(renderer: THREE.WebGLRenderer, container: HTMLElement, sessionOptions?: VRSessionOptions, buttonOptions?: VRButtonOptions): Promise<HTMLButtonElement>;

package/dist/src/utils/VRButtonUtils.js

@@ -0,0 +1,88 @@
+/**
+ * Creates a custom VR button with configurable WebXR features
+ */
+export async function createVRButton(renderer, container, sessionOptions = {}, buttonOptions = {}) {
+    const button = document.createElement('button');
+    // Default styles
+    const defaultStyles = {
+        position: 'absolute',
+        bottom: '20px',
+        left: 'calc(50% - 50px)',
+        width: '100px',
+        padding: '12px 6px',
+        border: '1px solid #fff',
+        borderRadius: '4px',
+        background: 'rgba(0, 0, 0, 0.1)',
+        color: '#fff',
+        font: 'normal 13px sans-serif',
+        textAlign: 'center',
+        opacity: '0.5',
+        outline: 'none',
+        zIndex: '999',
+        cursor: 'pointer'
+    };
+    // Apply styles
+    Object.assign(button.style, defaultStyles, buttonOptions.styles ?? {});
+    // Default texts
+    const enterText = buttonOptions.enterText ?? 'ENTER VR';
+    const exitText = buttonOptions.exitText ?? 'EXIT VR';
+    const notSupportedText = buttonOptions.notSupportedText ?? 'VR NOT SUPPORTED';
+    button.textContent = enterText;
+    // Default session options with hand tracking support
+    const { optionalFeatures = ['local-floor', 'hand-tracking'], requiredFeatures = [], framebufferScaleFactor } = sessionOptions;
+    button.onclick = async () => {
+        if ('xr' in navigator && navigator.xr) {
+            try {
+                console.log('Requesting VR session with features:', {
+                    optionalFeatures,
+                    requiredFeatures
+                });
+                const session = await navigator.xr.requestSession('immersive-vr', {
+                    optionalFeatures,
+                    requiredFeatures
+                });
+                console.log('VR session started with features:', session.enabledFeatures);
+                await renderer.xr.setSession(session);
+                // Set framebuffer scale factor if specified
+                if (framebufferScaleFactor !== undefined) {
+                    renderer.xr.setFramebufferScaleFactor(framebufferScaleFactor);
+                    console.log('VR framebuffer scale factor set to:', framebufferScaleFactor);
+                }
+                button.textContent = exitText;
+                session.addEventListener('end', () => {
+                    button.textContent = enterText;
+                });
+            }
+            catch (error) {
+                console.error('Failed to start VR session:', error);
+                button.textContent = notSupportedText;
+            }
+        }
+        else {
+            console.warn('WebXR not supported');
+            button.textContent = notSupportedText;
+        }
+    };
+    // Check if VR is supported
+    if ('xr' in navigator && navigator.xr) {
+        try {
+            const supported = await navigator.xr.isSessionSupported('immersive-vr');
+            if (supported) {
+                button.style.opacity = '1.0';
+            }
+            else {
+                button.textContent = notSupportedText;
+            }
+        }
+        catch (error) {
+            console.warn('Error checking VR support:', error);
+            button.textContent = notSupportedText;
+        }
+    }
+    else {
+        button.textContent = notSupportedText;
+    }
+    container.appendChild(button);
+    return button;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/utils/browser-polyfills/module.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Browser-compatible polyfill for Node.js module system
+ * Provides minimal functionality needed for Genesys.js to work in browsers
+ */
+/**
+ * Browser-compatible createRequire implementation
+ * This is a minimal implementation that should prevent errors when manifold-3d tries to use it
+ */
+declare function createRequire(filename: string): {
+    (id: string): void;
+    resolve(id: string): never;
+    cache: {};
+    extensions: {};
+    main: undefined;
+};
+declare const moduleExports: {
+    createRequire: typeof createRequire;
+};
+export default moduleExports;
+export { createRequire };

package/dist/src/utils/browser-polyfills/module.js

@@ -0,0 +1,31 @@
+/**
+ * Browser-compatible polyfill for Node.js module system
+ * Provides minimal functionality needed for Genesys.js to work in browsers
+ */
+/**
+ * Browser-compatible createRequire implementation
+ * This is a minimal implementation that should prevent errors when manifold-3d tries to use it
+ */
+function createRequire(filename) {
+    // In browser context, we return a mock require function
+    // This should prevent the manifold-3d library from failing
+    function mockRequire(id) {
+        // For now, just throw an error with helpful message
+        throw new Error(`Cannot require '${id}' in browser context. Module ID: ${id}, from: ${filename}`);
+    }
+    // Add properties that a real require function might have
+    mockRequire.resolve = (id) => {
+        throw new Error(`Cannot resolve '${id}' in browser context`);
+    };
+    mockRequire.cache = {};
+    mockRequire.extensions = {};
+    mockRequire.main = undefined;
+    return mockRequire;
+}
+// Export as both default and named exports for compatibility
+const moduleExports = {
+    createRequire
+};
+export default moduleExports;
+export { createRequire };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL2Jyb3dzZXItcG9seWZpbGxzL21vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSDs7O0dBR0c7QUFDSCxTQUFTLGFBQWEsQ0FBQyxRQUFnQjtJQUNyQyx3REFBd0Q7SUFDeEQsMkRBQTJEO0lBQzNELFNBQVMsV0FBVyxDQUFDLEVBQVU7UUFDN0Isb0RBQW9EO1FBQ3BELE1BQU0sSUFBSSxLQUFLLENBQUMsbUJBQW1CLEVBQUUsb0NBQW9DLEVBQUUsV0FBVyxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQ3BHLENBQUM7SUFFRCx5REFBeUQ7SUFDekQsV0FBVyxDQUFDLE9BQU8sR0FBRyxDQUFDLEVBQVUsRUFBRSxFQUFFO1FBQ25DLE1BQU0sSUFBSSxLQUFLLENBQUMsbUJBQW1CLEVBQUUsc0JBQXNCLENBQUMsQ0FBQztJQUMvRCxDQUFDLENBQUM7SUFFRixXQUFXLENBQUMsS0FBSyxHQUFHLEVBQUUsQ0FBQztJQUN2QixXQUFXLENBQUMsVUFBVSxHQUFHLEVBQUUsQ0FBQztJQUM1QixXQUFXLENBQUMsSUFBSSxHQUFHLFNBQVMsQ0FBQztJQUU3QixPQUFPLFdBQVcsQ0FBQztBQUNyQixDQUFDO0FBRUQsNkRBQTZEO0FBQzdELE1BQU0sYUFBYSxHQUFHO0lBQ3BCLGFBQWE7Q0FDZCxDQUFDO0FBRUYsZUFBZSxhQUFhLENBQUM7QUFDN0IsT0FBTyxFQUFFLGFBQWEsRUFBRSxDQUFDIn0=

package/dist/src/utils/browser-polyfills/path.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Browser-compatible polyfill for Node.js path module
+ * Provides minimal functionality needed for Genesys.js to work in browsers
+ */
+interface PathObject {
+    root: string;
+    dir: string;
+    base: string;
+    ext: string;
+    name: string;
+}
+/**
+ * Join path segments using forward slashes (browser-friendly)
+ */
+declare function join(...paths: string[]): string;
+/**
+ * Normalize a path (resolve . and .. segments)
+ */
+declare function normalize(path: string): string;
+/**
+ * Resolve path segments into an absolute path
+ */
+declare function resolve(...paths: string[]): string;
+/**
+ * Check if path is absolute
+ */
+declare function isAbsolute(path: string): boolean;
+/**
+ * Get the directory name of a path
+ */
+declare function dirname(path: string): string;
+/**
+ * Get the base name of a path
+ */
+declare function basename(path: string, ext?: string): string;
+/**
+ * Get the extension of a path
+ */
+declare function extname(path: string): string;
+/**
+ * Parse a path into components
+ */
+declare function parse(path: string): PathObject;
+/**
+ * Format a path object into a string
+ */
+declare function format(pathObject: PathObject): string;
+/**
+ * Get relative path from one path to another
+ */
+declare function relative(from: string, to: string): string;
+declare const sep = "/";
+declare const delimiter = ":";
+declare const pathModule: {
+    join: typeof join;
+    normalize: typeof normalize;
+    resolve: typeof resolve;
+    isAbsolute: typeof isAbsolute;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    parse: typeof parse;
+    format: typeof format;
+    relative: typeof relative;
+    sep: string;
+    delimiter: string;
+};
+export default pathModule;
+export { join, normalize, resolve, isAbsolute, dirname, basename, extname, parse, format, relative, sep, delimiter };