@directivegames/genesys.js 3.1.24

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

@@ -0,0 +1,188 @@
+/**
+ * Browser-compatible polyfill for Node.js path module
+ * Provides minimal functionality needed for Genesys.js to work in browsers
+ */
+/**
+ * Join path segments using forward slashes (browser-friendly)
+ */
+function join(...paths) {
+    if (paths.length === 0)
+        return '.';
+    let joined = '';
+    for (let i = 0; i < paths.length; i++) {
+        const path = paths[i];
+        if (path && path.length > 0) {
+            if (joined.length === 0) {
+                joined += path;
+            }
+            else {
+                joined += '/' + path;
+            }
+        }
+    }
+    return normalize(joined);
+}
+/**
+ * Normalize a path (resolve . and .. segments)
+ */
+function normalize(path) {
+    if (!path)
+        return '.';
+    const isAbsolute = path[0] === '/';
+    const segments = path.split('/').filter(segment => segment !== '');
+    const normalizedSegments = [];
+    for (const segment of segments) {
+        if (segment === '..') {
+            if (normalizedSegments.length > 0 && normalizedSegments[normalizedSegments.length - 1] !== '..') {
+                normalizedSegments.pop();
+            }
+            else if (!isAbsolute) {
+                normalizedSegments.push('..');
+            }
+        }
+        else if (segment !== '.') {
+            normalizedSegments.push(segment);
+        }
+    }
+    let result = normalizedSegments.join('/');
+    if (isAbsolute) {
+        result = '/' + result;
+    }
+    else if (!result) {
+        result = '.';
+    }
+    return result;
+}
+/**
+ * Resolve path segments into an absolute path
+ */
+function resolve(...paths) {
+    let resolvedPath = '';
+    let resolvedAbsolute = false;
+    for (let i = paths.length - 1; i >= 0 && !resolvedAbsolute; i--) {
+        const path = paths[i];
+        if (path) {
+            resolvedPath = path + '/' + resolvedPath;
+            resolvedAbsolute = path[0] === '/';
+        }
+    }
+    if (!resolvedAbsolute) {
+        // In browser, we treat relative to current location
+        resolvedPath = window.location.pathname + '/' + resolvedPath;
+    }
+    return normalize(resolvedPath);
+}
+/**
+ * Check if path is absolute
+ */
+function isAbsolute(path) {
+    return path.length > 0 && (path[0] === '/' || path.includes('://'));
+}
+/**
+ * Get the directory name of a path
+ */
+function dirname(path) {
+    if (!path)
+        return '.';
+    const lastSlash = path.lastIndexOf('/');
+    if (lastSlash === -1)
+        return '.';
+    if (lastSlash === 0)
+        return '/';
+    return path.slice(0, lastSlash);
+}
+/**
+ * Get the base name of a path
+ */
+function basename(path, ext) {
+    if (!path)
+        return '';
+    const lastSlash = path.lastIndexOf('/');
+    let base = lastSlash === -1 ? path : path.slice(lastSlash + 1);
+    if (ext && base.endsWith(ext)) {
+        base = base.slice(0, -ext.length);
+    }
+    return base;
+}
+/**
+ * Get the extension of a path
+ */
+function extname(path) {
+    if (!path)
+        return '';
+    const base = basename(path);
+    const lastDot = base.lastIndexOf('.');
+    return lastDot === -1 ? '' : base.slice(lastDot);
+}
+/**
+ * Parse a path into components
+ */
+function parse(path) {
+    const dir = dirname(path);
+    const base = basename(path);
+    const ext = extname(path);
+    const name = basename(path, ext);
+    return {
+        root: isAbsolute(path) ? '/' : '',
+        dir,
+        base,
+        ext,
+        name
+    };
+}
+/**
+ * Format a path object into a string
+ */
+function format(pathObject) {
+    const dir = pathObject.dir || pathObject.root;
+    const base = pathObject.base || pathObject.name + pathObject.ext;
+    if (!dir)
+        return base;
+    return dir === pathObject.root ? dir + base : dir + '/' + base;
+}
+/**
+ * Get relative path from one path to another
+ */
+function relative(from, to) {
+    from = resolve(from);
+    to = resolve(to);
+    if (from === to)
+        return '';
+    const fromParts = from.split('/').filter(p => p);
+    const toParts = to.split('/').filter(p => p);
+    let commonLength = 0;
+    const length = Math.min(fromParts.length, toParts.length);
+    for (let i = 0; i < length; i++) {
+        if (fromParts[i] === toParts[i]) {
+            commonLength++;
+        }
+        else {
+            break;
+        }
+    }
+    const upCount = fromParts.length - commonLength;
+    const downPath = toParts.slice(commonLength);
+    const relativeParts = Array(upCount).fill('..').concat(downPath);
+    return relativeParts.join('/') || '.';
+}
+// Browser-friendly path separator (always forward slash)
+const sep = '/';
+const delimiter = ':';
+// Export as both default and named exports for compatibility
+const pathModule = {
+    join,
+    normalize,
+    resolve,
+    isAbsolute,
+    dirname,
+    basename,
+    extname,
+    parse,
+    format,
+    relative,
+    sep,
+    delimiter
+};
+export default pathModule;
+export { join, normalize, resolve, isAbsolute, dirname, basename, extname, parse, format, relative, sep, delimiter };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,29 @@
+/**
+ * Utility index consolidates several helper modules into a single entry point.
+ *
+ * Detailed explanation:
+ * - Re-exports color constants, math helpers, delegate classes and three.js extensions.
+ * - Simplifies import paths for callers needing multiple utilities from this folder.
+ * - Serves as a stable API surface so directory structure changes don't break consumers.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Import from `src/utils` when referencing common helpers instead of targeting subfiles.
+ * - Review individual module docs for detailed behavior as this file is only an aggregator.
+ * - Keep export ordering logical to aid discoverability when using auto-complete.
+ */
+export * from './Color.js';
+export * from './MathHelpers.js';
+export * from './Delegate.js';
+export * from './Utils.js';
+export * from './MaterialHelpers.js';
+export * from './SceneGraphUtils.js';
+export * from './UserCodeEngine.js';
+export * from './ThreeJsExtensions.js';
+export * from './ResourceManager.js';
+export * from './NodeJs.js';
+export * from './DescriptionHelpers.js';
+export * from './GlobalAudioManager.js';
+export * from './VRButtonUtils.js';
+export * from './TweenExtensions.js';
+export * from './serialization/index.js';
+export * from './Spawn.js';

package/dist/src/utils/index.js

@@ -0,0 +1,30 @@
+/**
+ * Utility index consolidates several helper modules into a single entry point.
+ *
+ * Detailed explanation:
+ * - Re-exports color constants, math helpers, delegate classes and three.js extensions.
+ * - Simplifies import paths for callers needing multiple utilities from this folder.
+ * - Serves as a stable API surface so directory structure changes don't break consumers.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Import from `src/utils` when referencing common helpers instead of targeting subfiles.
+ * - Review individual module docs for detailed behavior as this file is only an aggregator.
+ * - Keep export ordering logical to aid discoverability when using auto-complete.
+ */
+export * from './Color.js';
+export * from './MathHelpers.js';
+export * from './Delegate.js';
+export * from './Utils.js';
+export * from './MaterialHelpers.js';
+export * from './SceneGraphUtils.js';
+export * from './UserCodeEngine.js';
+export * from './ThreeJsExtensions.js';
+export * from './ResourceManager.js';
+export * from './NodeJs.js';
+export * from './DescriptionHelpers.js';
+export * from './GlobalAudioManager.js';
+export * from './VRButtonUtils.js';
+export * from './TweenExtensions.js';
+export * from './serialization/index.js';
+export * from './Spawn.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsWUFBWSxDQUFDIn0=

package/dist/src/utils/serialization/cdo.d.ts

@@ -0,0 +1,6 @@
+import type { PropertyMetadata } from './decorator.js';
+export declare function clearCdoCache(): void;
+export declare function getClassDefaultObject<T>(cls: new (...args: any[]) => T): T | Record<string, any> | null;
+export declare function getAllPropertiesFromProto(proto: any): Map<string, PropertyMetadata>;
+export declare function getDefaultObjectFromName(clsNameOrPrefabPath: string): any | null;
+export declare function getDefaultObject(instance: any): any | null;

package/dist/src/utils/serialization/cdo.js

@@ -0,0 +1,74 @@
+import { getClassForDeserialization } from './clsAlias.js';
+import { PROPERTY_METADATA_KEY } from './decorator.js';
+import { loadPrefabTemplateInstance } from './prefab.js';
+import { PrefabManager } from './prefabManager.js';
+const cdoCache = new Map();
+const prefabTemplateCache = new Map();
+// for unit test purposes
+export function clearCdoCache() {
+    cdoCache.clear();
+    prefabTemplateCache.clear();
+}
+export function getClassDefaultObject(cls) {
+    if (!cls)
+        return null;
+    if (cdoCache.has(cls)) {
+        return cdoCache.get(cls);
+    }
+    const cdo = cls.length === 0 ? new cls() : getNonDefaultConstructableClassDefaults(cls.prototype);
+    cdoCache.set(cls, cdo);
+    return cdo;
+}
+// get a dictionary of fields marked with `default` in @property fields for those class that can't be default constructed, as in `new cls()`
+function getNonDefaultConstructableClassDefaults(prototype) {
+    const properties = getAllPropertiesFromProto(prototype);
+    const defaults = {};
+    properties.forEach((meta, key) => {
+        if (meta.default !== undefined) {
+            defaults[key] = meta.default;
+        }
+    });
+    return defaults;
+}
+export function getAllPropertiesFromProto(proto) {
+    const keys = new Map();
+    while (proto && proto !== Object.prototype) {
+        const meta = Reflect.getOwnMetadata(PROPERTY_METADATA_KEY, proto) ?? {};
+        Object.keys(meta).forEach((key) => {
+            if (!keys.has(key))
+                keys.set(key, meta[key]);
+        });
+        proto = Object.getPrototypeOf(proto);
+    }
+    return keys;
+}
+function _getPrefabTemplate(prefabPath) {
+    if (prefabTemplateCache.has(prefabPath)) {
+        return prefabTemplateCache.get(prefabPath);
+    }
+    const template = loadPrefabTemplateInstance(prefabPath);
+    if (template) {
+        prefabTemplateCache.set(prefabPath, template);
+    }
+    return template;
+}
+export function getDefaultObjectFromName(clsNameOrPrefabPath) {
+    if (PrefabManager.getPrefabData(clsNameOrPrefabPath)) {
+        return _getPrefabTemplate(clsNameOrPrefabPath);
+    }
+    const cls = getClassForDeserialization(clsNameOrPrefabPath);
+    if (cls) {
+        return getClassDefaultObject(cls);
+    }
+    return null;
+}
+export function getDefaultObject(instance) {
+    if (!instance)
+        return null;
+    const prefabPath = instance.$prefab?.$path;
+    if (prefabPath) {
+        return _getPrefabTemplate(prefabPath);
+    }
+    return getClassDefaultObject(instance.constructor);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/utils/serialization/clsAlias.d.ts

@@ -0,0 +1,15 @@
+import type { Constructor } from '../../systems/ClassRegistry.js';
+export declare class GlobalObjectRegistry {
+    private static objects;
+    private static factories;
+    static NAME: string;
+    constructor();
+    static registerObject(name: string, obj: object): void;
+    static registerFactory(name: string, factory: () => object): void;
+    private static ensureInstantiated;
+    static isGlobalObject(obj: object): boolean;
+    static getObjectByName(name: string): any;
+}
+export declare function getClassSerializeName(obj: object | undefined): string | null;
+export declare function getClassForDeserialization(cls: string | undefined): Constructor | null;
+export declare function registerClassAlias(cls: Constructor, alias: string): void;

package/dist/src/utils/serialization/clsAlias.js

@@ -0,0 +1,96 @@
+import { ClassRegistry } from '../../systems/ClassRegistry.js';
+export class GlobalObjectRegistry {
+    constructor() { }
+    static registerObject(name, obj) {
+        this.objects.set(name, obj);
+    }
+    static registerFactory(name, factory) {
+        this.factories.set(name, factory);
+    }
+    static ensureInstantiated(name) {
+        if (this.objects.has(name)) {
+            return this.objects.get(name);
+        }
+        const factory = this.factories.get(name);
+        if (factory) {
+            const obj = factory();
+            this.objects.set(name, obj);
+            return obj;
+        }
+        return undefined;
+    }
+    static isGlobalObject(obj) {
+        // First check already instantiated objects
+        for (const registeredObj of this.objects.values()) {
+            if (registeredObj === obj) {
+                return true;
+            }
+        }
+        // Check factories and instantiate if the object matches
+        for (const name of this.factories.keys()) {
+            if (!this.objects.has(name)) {
+                const instantiated = this.ensureInstantiated(name);
+                if (instantiated === obj) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    static getObjectByName(name) {
+        return this.ensureInstantiated(name);
+    }
+}
+Object.defineProperty(GlobalObjectRegistry, "objects", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new Map()
+});
+Object.defineProperty(GlobalObjectRegistry, "factories", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new Map()
+});
+Object.defineProperty(GlobalObjectRegistry, "NAME", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: '$global'
+});
+const classAliases = new Map();
+const reverseClassAliases = new Map();
+export function getClassSerializeName(obj) {
+    if (!obj || typeof obj !== 'object')
+        return null;
+    if (GlobalObjectRegistry.isGlobalObject(obj)) {
+        return GlobalObjectRegistry.NAME;
+    }
+    return classAliases.get(obj.constructor) ?? ClassRegistry.getClassName(obj) ?? null;
+}
+export function getClassForDeserialization(cls) {
+    if (!cls)
+        return null;
+    // try catch to avoid errors from ClassRegistry, as we can't tell if `cls` is always valid - class name can change, storage data can be manually edited, etc.
+    try {
+        return reverseClassAliases.get(cls) ?? ClassRegistry.getClass(cls);
+    }
+    catch {
+        return null;
+    }
+}
+export function registerClassAlias(cls, alias) {
+    if (classAliases.has(cls)) {
+        throw new Error(`Class alias conflict: ${cls.name} is already aliased to ${classAliases.get(cls)}`);
+    }
+    if (typeof cls.constructor !== 'function') {
+        throw new Error('Cannot register serialization for non-class type');
+    }
+    if (reverseClassAliases.has(alias)) {
+        throw new Error(`Class alias conflict: ${alias} is already aliased to ${reverseClassAliases.get(alias)?.name}`);
+    }
+    classAliases.set(cls, alias);
+    reverseClassAliases.set(alias, cls);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/utils/serialization/decorator.d.ts

@@ -0,0 +1,132 @@
+import 'reflect-metadata';
+import type { Dumper, Loader } from './serializer';
+export interface PropertyMetadataBase {
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
+    category?: string;
+    order?: number;
+    /**
+     * the default value of this property, it is used to skip serialization if the value is the same as the default
+     * Since the serializer uses strict equality (===) to compare values, only primitive types are supported here.
+     */
+    default?: string | number | boolean | null | undefined;
+    /**
+     * whether this field is a constructor argument, or if it's both a constructor argument and a serialized property
+     * if multiple constructor arguments exist, use ctorArgIndex to specify the index
+     * specifying `ctorArgIndex` automatically implies `ctorArg: 'ctorArgOnly'`
+    */
+    ctorArg?: 'ctorArgOnly' | 'ctorArgAndProperty';
+    /**
+     * the index of the constructor argument if this field is a constructor argument
+     * only needed if there are multiple constructor arguments
+     * automatically implies `ctorArg: 'ctorArgOnly'` if `ctorArg` is not specified
+     */
+    ctorArgIndex?: number;
+    /**
+     * whether this property should be skipped during serialization.
+     * If true, the property will not be serialized whatsoever, even marked with ctorArg or ctorArgIndex
+     */
+    transient?: boolean;
+    /**
+     * whether this property should be skipped when dumped as a prefab.
+     * If true, the property will not be dumped when part of a prefab, but it will be dumped normally otherwise.
+     * This is useful for properties that should not be shared across prefab instances, e.g. uuid, name
+     */
+    transientOnPrefab?: boolean;
+    /**
+     * whether this property should be skipped when loaded if it's not in editor environment
+     * Useful for properties that are only relevant in editor, e.g. editor-only metadata
+     */
+    editorOnly?: boolean;
+    /**
+     * Custom serialization function for this property.
+     * @param value: the property value
+     * @param dumper: the dumper instance
+     */
+    serialize?: (value: any, dumper: Dumper) => void;
+    /**
+     * Custom deserialization function for this property.
+     * @param data: the serialized data
+     * @returns the deserialized property value
+     */
+    deserialize?: (data: any, loader: Loader) => any;
+}
+export declare const PROPERTY_METADATA_KEY: unique symbol;
+export declare function getPropertyMetadata(target: any): Record<string, PropertyMetadata>;
+export declare function shouldShowProperty(metadata: PropertyMetadata): boolean;
+export declare const PROPERTY_TYPES: readonly ["array", "audioPath", "boolean", "class", "color", "enum", "hdriPath", "jsclassPath", "jsonPath", "materialPath", "modelPath", "number", "object", "prefabPath", "resource", "scenePath", "sourcecodePath", "string", "tag", "texturePath", "videoPath", "vector2", "vector3", "vector4", "euler"];
+export type PropertyType = typeof PROPERTY_TYPES[number];
+export declare function isValidPropertyType(type: string): type is PropertyType;
+export type PropertyMetadata = PropertyMetadataBase & ({
+    type?: 'array';
+    minLength?: number;
+    maxLength?: number;
+    child: PropertyMetadata;
+} | {
+    type?: 'audioPath';
+} | {
+    type?: 'boolean';
+} | {
+    type?: 'class';
+    classType: new (...args: any[]) => any;
+} | {
+    type?: 'color';
+} | {
+    type?: 'enum';
+    options: string[] | Record<string, string>;
+} | {
+    type?: 'hdriPath';
+} | {
+    type?: 'jsclassPath';
+} | {
+    type?: 'jsonPath';
+} | {
+    type?: 'materialPath';
+} | {
+    type?: 'modelPath';
+} | {
+    type?: 'number';
+    min?: number;
+    max?: number;
+    step?: number;
+    decimals?: number;
+    unit?: string;
+} | {
+    type?: 'object';
+    fields: Record<string, PropertyMetadata>;
+} | {
+    type?: 'prefabPath';
+} | {
+    type?: 'resource';
+    resourceType: string;
+} | {
+    type?: 'scenePath';
+} | {
+    type?: 'sourcecodePath';
+} | {
+    type?: 'string';
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+} | {
+    type?: 'tag';
+} | {
+    type?: 'texturePath';
+} | {
+    type?: 'videoPath';
+} | {
+    type?: 'vector2';
+} | {
+    type?: 'vector3';
+} | {
+    type?: 'vector4';
+} | {
+    type?: 'euler';
+});
+/**
+ * Type for class-level property metadata mapping
+ * Maps property names to their metadata definitions
+ */
+export type ClassPropertyMetadata = Record<string, PropertyMetadata>;
+export declare function property(meta?: PropertyMetadata): PropertyDecorator;

package/dist/src/utils/serialization/decorator.js

@@ -0,0 +1,66 @@
+import 'reflect-metadata';
+export const PROPERTY_METADATA_KEY = Symbol('propertyMetadata');
+export function getPropertyMetadata(target) {
+    const metadata = {};
+    // Walk the prototype chain to collect all inherited metadata
+    let current = target;
+    while (current && current !== Object.prototype) {
+        // Check for decorator-based metadata
+        const ownMetadata = Reflect.getOwnMetadata(PROPERTY_METADATA_KEY, current);
+        if (ownMetadata) {
+            // Merge with lower priority - parent metadata comes first, child can override
+            Object.assign(metadata, ownMetadata, metadata);
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    return metadata;
+}
+export function shouldShowProperty(metadata) {
+    if (metadata.hidden) {
+        return false;
+    }
+    if (metadata.ctorArg) {
+        return false;
+    }
+    return true;
+}
+export const PROPERTY_TYPES = [
+    'array',
+    'audioPath',
+    'boolean',
+    'class',
+    'color',
+    'enum',
+    'hdriPath',
+    'jsclassPath',
+    'jsonPath',
+    'materialPath',
+    'modelPath',
+    'number',
+    'object',
+    'prefabPath',
+    'resource',
+    'scenePath',
+    'sourcecodePath',
+    'string',
+    'tag',
+    'texturePath',
+    'videoPath',
+    'vector2',
+    'vector3',
+    'vector4',
+    'euler',
+];
+export function isValidPropertyType(type) {
+    return PROPERTY_TYPES.includes(type);
+}
+export function property(meta) {
+    return (target, key) => {
+        const parent = Object.getPrototypeOf(target);
+        const parentMeta = Reflect.getMetadata(PROPERTY_METADATA_KEY, parent) ?? {};
+        const existing = { ...parentMeta, ...Reflect.getOwnMetadata(PROPERTY_METADATA_KEY, target) };
+        existing[key] = meta ?? {};
+        Reflect.defineMetadata(PROPERTY_METADATA_KEY, existing, target);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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