@directivegames/genesys.js 3.1.24

package/dist/test/default-options-validation.test.js

@@ -0,0 +1,186 @@
+import * as ENGINE from 'genesys.js';
+import QUnit from 'qunit';
+/**
+ * Utility function to check if a property descriptor represents a static getter or static function
+ */
+function isStaticGetterOrFunction(constructor, propertyName) {
+    const descriptor = Object.getOwnPropertyDescriptor(constructor, propertyName);
+    if (!descriptor) {
+        return false;
+    }
+    // Check if it's a getter (has a get function)
+    if (descriptor.get && typeof descriptor.get === 'function') {
+        return true;
+    }
+    // Check if it's a function
+    if (typeof descriptor.value === 'function') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Utility function to get all DEFAULT_* property names from a class
+ */
+function getDefaultProperties(constructor) {
+    const defaultProps = [];
+    // Check own properties
+    const ownProps = Object.getOwnPropertyNames(constructor);
+    for (const prop of ownProps) {
+        if (prop.startsWith('DEFAULT_')) {
+            defaultProps.push(prop);
+        }
+    }
+    return defaultProps;
+}
+/**
+ * Utility function to check if a class extends another class
+ */
+function isSubclassOf(childClass, parentClass) {
+    if (!childClass || !parentClass) {
+        return false;
+    }
+    let current = childClass;
+    while (current && current !== parentClass) {
+        current = Object.getPrototypeOf(current);
+        if (current === parentClass) {
+            return true;
+        }
+    }
+    return false;
+}
+QUnit.module('DEFAULT_* Field Validation', hooks => {
+    hooks.before(() => {
+        // Ensure all classes are registered
+        ENGINE.ClassRegistry.registerBuiltInClasses();
+    });
+    QUnit.test('All Component subclasses have DEFAULT_* fields as static getters or functions', assert => {
+        const registry = ENGINE.ClassRegistry.getRegistry();
+        const failures = [];
+        const componentSubclasses = [];
+        // Find all Component subclasses
+        for (const [className, constructor] of registry.entries()) {
+            if (className.startsWith('ENGINE.') && isSubclassOf(constructor, ENGINE.SceneComponent)) {
+                componentSubclasses.push(className);
+                const defaultProps = getDefaultProperties(constructor);
+                for (const prop of defaultProps) {
+                    if (!isStaticGetterOrFunction(constructor, prop)) {
+                        failures.push(`${className}.${prop} is not a static getter or static function`);
+                    }
+                }
+            }
+        }
+        assert.ok(componentSubclasses.length > 0, `Found ${componentSubclasses.length} Component subclasses`);
+        console.log(`Checked ${componentSubclasses.length} Component subclasses`);
+        if (failures.length > 0) {
+            assert.ok(false, `DEFAULT_* field validation failures:\n${failures.join('\n')}`);
+        }
+        else {
+            assert.ok(true, 'All Component subclasses have properly defined DEFAULT_* fields');
+        }
+    });
+    QUnit.test('All SceneComponent subclasses have DEFAULT_* fields as static getters or functions', assert => {
+        const registry = ENGINE.ClassRegistry.getRegistry();
+        const failures = [];
+        const sceneComponentSubclasses = [];
+        // Find all SceneComponent subclasses
+        for (const [className, constructor] of registry.entries()) {
+            if (className.startsWith('ENGINE.') && isSubclassOf(constructor, ENGINE.SceneComponent)) {
+                sceneComponentSubclasses.push(className);
+                const defaultProps = getDefaultProperties(constructor);
+                for (const prop of defaultProps) {
+                    if (!isStaticGetterOrFunction(constructor, prop)) {
+                        failures.push(`${className}.${prop} is not a static getter or static function`);
+                    }
+                }
+            }
+        }
+        assert.ok(sceneComponentSubclasses.length > 0, `Found ${sceneComponentSubclasses.length} SceneComponent subclasses`);
+        console.log(`Checked ${sceneComponentSubclasses.length} SceneComponent subclasses`);
+        if (failures.length > 0) {
+            assert.ok(false, `DEFAULT_* field validation failures:\n${failures.join('\n')}`);
+        }
+        else {
+            assert.ok(true, 'All SceneComponent subclasses have properly defined DEFAULT_* fields');
+        }
+    });
+    QUnit.test('All Actor subclasses have DEFAULT_* fields as static getters or functions', assert => {
+        const registry = ENGINE.ClassRegistry.getRegistry();
+        const failures = [];
+        const actorSubclasses = [];
+        // Find all Actor subclasses
+        for (const [className, constructor] of registry.entries()) {
+            if (className.startsWith('ENGINE.') && isSubclassOf(constructor, ENGINE.Actor)) {
+                actorSubclasses.push(className);
+                const defaultProps = getDefaultProperties(constructor);
+                for (const prop of defaultProps) {
+                    if (!isStaticGetterOrFunction(constructor, prop)) {
+                        failures.push(`${className}.${prop} is not a static getter or static function`);
+                    }
+                }
+            }
+        }
+        assert.ok(actorSubclasses.length > 0, `Found ${actorSubclasses.length} Actor subclasses`);
+        console.log(`Checked ${actorSubclasses.length} Actor subclasses`);
+        if (failures.length > 0) {
+            assert.ok(false, `DEFAULT_* field validation failures:\n${failures.join('\n')}`);
+        }
+        else {
+            assert.ok(true, 'All Actor subclasses have properly defined DEFAULT_* fields');
+        }
+    });
+    QUnit.test('Base classes have DEFAULT_* fields as static getters or functions', assert => {
+        const baseClasses = [
+            { name: 'SceneComponent', constructor: ENGINE.SceneComponent },
+            { name: 'Actor', constructor: ENGINE.Actor }
+        ];
+        const failures = [];
+        for (const { name, constructor } of baseClasses) {
+            const defaultProps = getDefaultProperties(constructor);
+            for (const prop of defaultProps) {
+                if (!isStaticGetterOrFunction(constructor, prop)) {
+                    failures.push(`${name}.${prop} is not a static getter or static function`);
+                }
+            }
+        }
+        if (failures.length > 0) {
+            assert.ok(false, `Base class DEFAULT_* field validation failures:\n${failures.join('\n')}`);
+        }
+        else {
+            assert.ok(true, 'All base classes have properly defined DEFAULT_* fields');
+        }
+    });
+    QUnit.test('Verify DEFAULT_OPTIONS specifically exists and is properly defined', assert => {
+        const registry = ENGINE.ClassRegistry.getRegistry();
+        const failures = [];
+        const classesWithoutDefaultOptions = [];
+        const totalChecked = [];
+        // Check all Component, SceneComponent, and Actor subclasses specifically for DEFAULT_OPTIONS
+        for (const [className, constructor] of registry.entries()) {
+            if (className.startsWith('ENGINE.') && (isSubclassOf(constructor, ENGINE.SceneComponent) ||
+                isSubclassOf(constructor, ENGINE.Actor))) {
+                totalChecked.push(className);
+                // Check if DEFAULT_OPTIONS exists
+                const hasDefaultOptions = getDefaultProperties(constructor).includes('DEFAULT_OPTIONS');
+                if (hasDefaultOptions) {
+                    // If it exists, verify it's properly defined
+                    if (!isStaticGetterOrFunction(constructor, 'DEFAULT_OPTIONS')) {
+                        failures.push(`${className}.DEFAULT_OPTIONS exists but is not a static getter or static function`);
+                    }
+                }
+                else {
+                    // Track classes without DEFAULT_OPTIONS (might be base classes or special cases)
+                    classesWithoutDefaultOptions.push(className);
+                }
+            }
+        }
+        console.log(`Total classes checked: ${totalChecked.length}`);
+        console.log(`Classes without DEFAULT_OPTIONS: ${classesWithoutDefaultOptions.join(', ')}`);
+        if (failures.length > 0) {
+            assert.ok(false, `DEFAULT_OPTIONS validation failures:\n${failures.join('\n')}`);
+        }
+        else {
+            assert.ok(true, `All classes with DEFAULT_OPTIONS have them properly defined. ${classesWithoutDefaultOptions.length} classes don't have DEFAULT_OPTIONS (which may be acceptable).`);
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default-options-validation.test.js","sourceRoot":"","sources":["../../test/default-options-validation.test.ts"],"names":[],"mappings":"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"}

package/dist/test/metadata.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/metadata.test.js

@@ -0,0 +1,82 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import * as ENGINE from 'genesys.js';
+import QUnit from 'qunit';
+import * as THREE from 'three';
+import { getPropertyMetadata, property } from '../src/utils/serialization/decorator.js';
+QUnit.module('Property Metadata', hooks => {
+    hooks.before(() => {
+    });
+    QUnit.test('getPropertyMetadata', (assert) => {
+        // Test class without metadata
+        class TestClassWithoutMetadata {
+            constructor() {
+                Object.defineProperty(this, "foo", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: 'bar'
+                });
+            }
+        }
+        const metadataEmpty = getPropertyMetadata(TestClassWithoutMetadata.prototype);
+        assert.deepEqual(metadataEmpty, {}, 'Should return empty object for class without metadata');
+        // Test class with metadata
+        class TestClassWithMetadata {
+            constructor() {
+                Object.defineProperty(this, "stringProp", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: 'parent'
+                });
+            }
+        }
+        __decorate([
+            property({ type: 'string', default: 'parent' }),
+            __metadata("design:type", Object)
+        ], TestClassWithMetadata.prototype, "stringProp", void 0);
+        class TestClassWithMetadataChild extends TestClassWithMetadata {
+            constructor() {
+                super(...arguments);
+                Object.defineProperty(this, "childStringProp", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: 'child'
+                });
+            }
+        }
+        __decorate([
+            property({ type: 'string', default: 'child' }),
+            __metadata("design:type", Object)
+        ], TestClassWithMetadataChild.prototype, "childStringProp", void 0);
+        const metadata = getPropertyMetadata(TestClassWithMetadata.prototype);
+        assert.equal(metadata.stringProp?.default, 'parent', 'Should have correct default for stringProp');
+        const metadataChild = getPropertyMetadata(TestClassWithMetadataChild.prototype);
+        assert.equal(metadataChild.stringProp?.default, 'parent', 'Should have correct default for parent stringProp');
+        assert.equal(metadataChild.childStringProp?.default, 'child', 'Should have correct default for child stringProp');
+    });
+    QUnit.test('getPropertyMetadata for Object3D', (assert) => {
+        // Test Object3D metadata registered via registerPropertyMetadata
+        const metadata = getPropertyMetadata(THREE.Object3D.prototype);
+        console.log(metadata);
+        assert.ok(metadata.uuid, 'Should have metadata for uuid');
+        assert.equal(metadata.uuid.readonly, true, 'uuid should be readonly');
+    });
+    QUnit.test('getPropertyMetadata inheritance from Object3D', (assert) => {
+        // Test that classes extending Object3D inherit metadata
+        const sceneComponentMetadata = getPropertyMetadata(ENGINE.SceneComponent.prototype);
+        console.log(sceneComponentMetadata);
+        assert.ok(sceneComponentMetadata.uuid, 'SceneComponent should inherit uuid metadata from Object3D');
+        assert.equal(sceneComponentMetadata.uuid.readonly, true, 'Inherited uuid should be readonly');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/nodeStorage.d.ts

@@ -0,0 +1,19 @@
+import * as ENGINE from 'genesys.js';
+import { AssetPath } from 'genesys.js';
+export declare class NodeStorageProvider implements ENGINE.IStorageProvider {
+    private getProjectRoot;
+    resolvePath(assetPath: AssetPath, expiry?: number): Promise<AssetPath>;
+    getFullPath(filePath: string): string;
+    downloadFileAsBuffer(assetPath: AssetPath): Promise<ArrayBuffer>;
+    downloadFileAsJson<T>(assetPath: AssetPath): Promise<T>;
+    downloadFileAsText(assetPath: AssetPath): Promise<string>;
+    exists(assetPath: AssetPath): Promise<boolean>;
+    buildCurrentProject(runTsc: boolean): Promise<boolean>;
+    uploadFile(assetPath: AssetPath, content: Blob | File | string | ArrayBuffer, options?: ENGINE.FileUploadOptions): Promise<{
+        path: string;
+        name: string;
+    }>;
+    deleteFile(assetPath: AssetPath): Promise<void>;
+    listFiles(assetPath: AssetPath, recursive?: boolean, includeHiddenFiles?: boolean): Promise<ENGINE.FileListResult>;
+}
+export declare function getResolvedPath(assetPath: ENGINE.AssetPath): string;

package/dist/test/nodeStorage.js

@@ -0,0 +1,85 @@
+import fs from 'fs';
+import path from 'path';
+import * as ENGINE from 'genesys.js';
+import { AssetPath, AssetPathEncodeState } from 'genesys.js';
+export class NodeStorageProvider {
+    getProjectRoot() {
+        let currentDir = __dirname;
+        while (true) {
+            if (fs.existsSync(path.join(currentDir, 'package.json'))) {
+                return currentDir;
+            }
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                throw new Error('Project root not found');
+            }
+            currentDir = parentDir;
+        }
+    }
+    async resolvePath(assetPath, expiry) {
+        if (assetPath.isResolved()) {
+            return assetPath;
+        }
+        assetPath.resolvePath(this.getFullPath(assetPath.initialPath), AssetPathEncodeState.Decoded);
+        return assetPath;
+    }
+    getFullPath(filePath) {
+        let fullPath = filePath;
+        let rootPath = undefined;
+        if (filePath.startsWith(ENGINE.PROJECT_PATH_PREFIX)) {
+            throw new Error(`Cannot use resolvePath with ${ENGINE.PROJECT_PATH_PREFIX} using the NodeStorageProvider.`);
+        }
+        else if (filePath.startsWith(ENGINE.ENGINE_PATH_PREFIX)) {
+            filePath = filePath.slice(ENGINE.ENGINE_PATH_PREFIX.length);
+            rootPath = this.getProjectRoot();
+        }
+        if (rootPath !== undefined) {
+            fullPath = AssetPath.join(rootPath, filePath);
+        }
+        return fullPath;
+    }
+    async downloadFileAsBuffer(assetPath) {
+        throw new Error('Not implemented');
+    }
+    async downloadFileAsJson(assetPath) {
+        assetPath = await this.resolvePath(assetPath);
+        const fullPath = getResolvedPath(assetPath);
+        if (!fs.existsSync(fullPath)) {
+            return {};
+        }
+        return JSON.parse(fs.readFileSync(fullPath, 'utf8'));
+    }
+    async downloadFileAsText(assetPath) {
+        assetPath = await this.resolvePath(assetPath);
+        const fullPath = getResolvedPath(assetPath);
+        if (!fs.existsSync(fullPath)) {
+            return '';
+        }
+        return fs.readFileSync(fullPath, 'utf8');
+    }
+    async exists(assetPath) {
+        assetPath = await this.resolvePath(assetPath);
+        const fullPath = getResolvedPath(assetPath);
+        return fs.existsSync(fullPath);
+    }
+    async buildCurrentProject(runTsc) {
+        throw new Error('Not implemented');
+    }
+    async uploadFile(assetPath, content, options) {
+        assetPath = await this.resolvePath(assetPath);
+        const fullPath = getResolvedPath(assetPath);
+        return {
+            path: fullPath,
+            name: path.basename(fullPath)
+        };
+    }
+    async deleteFile(assetPath) {
+    }
+    async listFiles(assetPath, recursive, includeHiddenFiles) {
+        return { files: [], directories: [] };
+    }
+}
+export function getResolvedPath(assetPath) {
+    return assetPath.getResolvedPath(false);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/postprocess-manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/postprocess-manager.test.js

@@ -0,0 +1,77 @@
+import QUnit from 'qunit';
+import { PostProcessManager, PostProcessPass } from '../src/render/PostProcessManager.js';
+QUnit.module('PostProcessManager', function () {
+    let postProcessManager;
+    QUnit.module('Post-processing enabled/disabled functionality', function (hooks) {
+        hooks.beforeEach(function () {
+            postProcessManager = new PostProcessManager();
+        });
+        QUnit.test('should be enabled by default', function (assert) {
+            assert.true(postProcessManager.getPostProcessingEnabled());
+        });
+        QUnit.test('should allow disabling post-processing', function (assert) {
+            postProcessManager.setPostProcessingEnabled(false);
+            assert.false(postProcessManager.getPostProcessingEnabled());
+        });
+        QUnit.test('should allow re-enabling post-processing', function (assert) {
+            postProcessManager.setPostProcessingEnabled(false);
+            postProcessManager.setPostProcessingEnabled(true);
+            assert.true(postProcessManager.getPostProcessingEnabled());
+        });
+        QUnit.test('should maintain individual pass configurations when globally disabled', function (assert) {
+            // Enable a specific pass
+            postProcessManager.configureEffect(PostProcessPass.Bloom, { enabled: true });
+            // Disable post-processing globally
+            postProcessManager.setPostProcessingEnabled(false);
+            // The individual pass should still be configured as enabled
+            const bloomConfig = postProcessManager.getEffectConfig(PostProcessPass.Bloom);
+            assert.true(bloomConfig?.enabled);
+            // But post-processing globally should be disabled
+            assert.false(postProcessManager.getPostProcessingEnabled());
+        });
+        QUnit.test('should respect global disable even when individual passes are enabled', function (assert) {
+            // Enable multiple passes
+            postProcessManager.enablePasses(PostProcessPass.Bloom, PostProcessPass.SMAA);
+            // Disable globally
+            postProcessManager.setPostProcessingEnabled(false);
+            // Individual passes should still report as enabled
+            assert.true(postProcessManager.isPassEnabled(PostProcessPass.Bloom));
+            assert.true(postProcessManager.isPassEnabled(PostProcessPass.SMAA));
+            // But global flag should be disabled
+            assert.false(postProcessManager.getPostProcessingEnabled());
+        });
+    });
+    QUnit.module('Configuration management with global toggle', function (hooks) {
+        hooks.beforeEach(function () {
+            postProcessManager = new PostProcessManager();
+        });
+        QUnit.test('should preserve configuration when toggling global enable/disable', function (assert) {
+            const originalConfig = {
+                effects: [
+                    {
+                        type: PostProcessPass.Bloom,
+                        enabled: true,
+                        intensity: 2.5,
+                        luminanceThreshold: 0.8
+                    }
+                ]
+            };
+            postProcessManager.setConfiguration(originalConfig);
+            // Disable globally
+            postProcessManager.setPostProcessingEnabled(false);
+            // Configuration should be preserved
+            const bloomConfig = postProcessManager.getEffectConfig(PostProcessPass.Bloom);
+            assert.true(bloomConfig?.enabled);
+            assert.equal(bloomConfig?.intensity, 2.5);
+            assert.equal(bloomConfig?.luminanceThreshold, 0.8);
+            // Re-enable globally
+            postProcessManager.setPostProcessingEnabled(true);
+            // Configuration should still be preserved
+            const bloomConfigAfter = postProcessManager.getEffectConfig(PostProcessPass.Bloom);
+            assert.true(bloomConfigAfter?.enabled);
+            assert.equal(bloomConfigAfter?.intensity, 2.5);
+            assert.equal(bloomConfigAfter?.luminanceThreshold, 0.8);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/prefab.test.d.ts

@@ -0,0 +1 @@
+export {};