@directivegames/genesys.js 3.1.24

package/dist/test/asset-path.test.d.ts

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

package/dist/test/asset-path.test.js

@@ -0,0 +1,339 @@
+import * as ENGINE from 'genesys.js';
+import QUnit from 'qunit';
+QUnit.module('AssetPath', hooks => {
+    hooks.before(() => {
+    });
+    QUnit.test('constructor and basic properties', assert => {
+        const assetPath = new ENGINE.AssetPath('test/path.txt');
+        assert.equal(assetPath.initialPath, 'test/path.txt', 'Initial path is stored correctly');
+        assert.equal(assetPath.isResolved(), false, 'Path is not resolved initially');
+    });
+    QUnit.test('fromString static method', assert => {
+        const assetPath = ENGINE.AssetPath.fromString('another/path.json');
+        assert.equal(assetPath.initialPath, 'another/path.json', 'fromString creates AssetPath with correct initial path');
+        assert.equal(assetPath.isResolved(), false, 'Path created via fromString is not resolved initially');
+    });
+    QUnit.test('toString method', assert => {
+        const assetPath = new ENGINE.AssetPath('debug/path.glb');
+        const stringRepresentation = assetPath.toString();
+        assert.ok(stringRepresentation.includes('AssetPath'), 'toString includes class name');
+        assert.ok(stringRepresentation.includes('debug/path.glb'), 'toString includes initial path');
+        assert.ok(stringRepresentation.includes('resolved=null'), 'toString shows unresolved state');
+    });
+    QUnit.module('Path Joining', () => {
+        QUnit.test('join two simple paths', assert => {
+            const result = ENGINE.AssetPath.join('folder', 'file.txt');
+            assert.equal(result, 'folder/file.txt', 'Simple path joining works');
+        });
+        QUnit.test('join paths with leading/trailing slashes', assert => {
+            const result1 = ENGINE.AssetPath.join('/folder/', '/file.txt');
+            assert.equal(result1, '/folder/file.txt', 'Handles leading and trailing slashes correctly');
+            const result2 = ENGINE.AssetPath.join('folder/', 'subfolder/', 'file.txt');
+            assert.equal(result2, 'folder/subfolder/file.txt', 'Handles multiple trailing slashes');
+        });
+        QUnit.test('join paths with backslashes', assert => {
+            const result = ENGINE.AssetPath.join('folder\\subfolder', 'file.txt');
+            assert.equal(result, 'folder/subfolder/file.txt', 'Converts backslashes to forward slashes');
+        });
+        QUnit.test('join multiple paths', assert => {
+            const result = ENGINE.AssetPath.join('root', 'folder', 'subfolder', 'file.txt');
+            assert.equal(result, 'root/folder/subfolder/file.txt', 'Joins multiple paths correctly');
+        });
+        QUnit.test('join preserves root slash', assert => {
+            const result = ENGINE.AssetPath.join('/root', 'folder', 'file.txt');
+            assert.equal(result, '/root/folder/file.txt', 'Preserves leading slash for absolute paths');
+        });
+        QUnit.test('join preserves trailing slash', assert => {
+            const result = ENGINE.AssetPath.join('root', 'folder/');
+            assert.equal(result, 'root/folder/', 'Preserves trailing slash when specified');
+        });
+        QUnit.test('join single path', assert => {
+            const result = ENGINE.AssetPath.join('single\\path');
+            assert.equal(result, 'single/path', 'Handles single path with normalization');
+        });
+    });
+    QUnit.module('URL Normalization', () => {
+        QUnit.test('normalizeUrl with simple path', assert => {
+            const result = ENGINE.AssetPath.normalizeUrl('folder/file.txt');
+            assert.equal(result.decoded, 'folder/file.txt', 'Simple path remains unchanged');
+            assert.equal(result.encoded, 'folder/file.txt', 'Simple path encoding remains unchanged');
+        });
+        QUnit.test('normalizeUrl with spaces', assert => {
+            const result = ENGINE.AssetPath.normalizeUrl('folder/file name.txt');
+            assert.equal(result.decoded, 'folder/file name.txt', 'Decoded preserves spaces');
+            assert.equal(result.encoded, 'folder/file%20name.txt', 'Encoded converts spaces to %20');
+        });
+        QUnit.test('normalizeUrl with encoded input', assert => {
+            const result = ENGINE.AssetPath.normalizeUrl('folder/file%20name.txt');
+            assert.equal(result.decoded, 'folder/file name.txt', 'Decodes %20 to spaces');
+            assert.equal(result.encoded, 'folder/file%20name.txt', 'Re-encodes to %20');
+        });
+        QUnit.test('normalizeUrl with unicode characters', assert => {
+            const result = ENGINE.AssetPath.normalizeUrl('folder/файл.txt');
+            assert.equal(result.decoded, 'folder/файл.txt', 'Unicode characters preserved in decoded');
+            assert.ok(result.encoded.includes('%'), 'Unicode characters encoded in encoded version');
+        });
+        QUnit.test('normalizeUrl with invalid encoding', assert => {
+            const result = ENGINE.AssetPath.normalizeUrl('folder/file%ZZ.txt');
+            assert.equal(result.decoded, 'folder/file%ZZ.txt', 'Invalid encoding kept as-is in decoded');
+            assert.equal(result.encoded, 'folder/file%25ZZ.txt', 'Invalid % gets encoded as %25');
+        });
+    });
+    QUnit.module('Path Resolution', () => {
+        QUnit.test('resolve local file path with all encode states', assert => {
+            // Test AssetPathEncodeState.Decoded
+            const assetPath1 = new ENGINE.AssetPath('assets/models/cube.glb');
+            const resolvedPath1 = 'http://localhost:3000/assets/models/cube.glb';
+            assetPath1.resolvePath(resolvedPath1, ENGINE.AssetPathEncodeState.Decoded);
+            assert.equal(assetPath1.isResolved(), true, 'Path is resolved after resolvePath call (Decoded)');
+            assert.equal(assetPath1.getResolvedPath(true), 'http://localhost:3000/assets/models/cube.glb', 'Resolved encoded path is correct (Decoded)');
+            assert.equal(assetPath1.getResolvedPath(false), resolvedPath1, 'Resolved decoded path is correct (Decoded)');
+            // Test AssetPathEncodeState.Encoded
+            const assetPath2 = new ENGINE.AssetPath('assets/models/cube with spaces.glb');
+            const resolvedPath2 = 'http://localhost:3000/assets/models/cube%20with%20spaces.glb';
+            assetPath2.resolvePath(resolvedPath2, ENGINE.AssetPathEncodeState.Encoded);
+            assert.equal(assetPath2.isResolved(), true, 'Path is resolved after resolvePath call (Encoded)');
+            assert.equal(assetPath2.getResolvedPath(true), resolvedPath2, 'Resolved encoded path uses provided encoded string (Encoded)');
+            assert.equal(assetPath2.getResolvedPath(false), 'http://localhost:3000/assets/models/cube with spaces.glb', 'Resolved decoded path decodes correctly (Encoded)');
+            // Test AssetPathEncodeState.Unknown
+            const assetPath3 = new ENGINE.AssetPath('assets/textures/background.jpg');
+            const resolvedPath3 = 'http://localhost:3000/assets/textures/background.jpg';
+            assetPath3.resolvePath(resolvedPath3, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath3.isResolved(), true, 'Path is resolved after resolvePath call (Unknown)');
+            assert.equal(assetPath3.getResolvedPath(true), resolvedPath3, 'Resolved encoded path is correct (Unknown)');
+            assert.equal(assetPath3.getResolvedPath(false), resolvedPath3, 'Resolved decoded path is correct (Unknown)');
+            // Test AssetPathEncodeState.Unknown with special characters
+            const assetPath4 = new ENGINE.AssetPath('assets/sounds/effect sound.mp3');
+            const resolvedPath4 = 'http://localhost:3000/assets/sounds/effect sound.mp3';
+            assetPath4.resolvePath(resolvedPath4, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath4.isResolved(), true, 'Path is resolved after resolvePath call (Unknown with spaces)');
+            assert.equal(assetPath4.getResolvedPath(true), 'http://localhost:3000/assets/sounds/effect%20sound.mp3', 'Resolved encoded path encodes spaces (Unknown)');
+            assert.equal(assetPath4.getResolvedPath(false), resolvedPath4, 'Resolved decoded path preserves spaces (Unknown)');
+        });
+        QUnit.test('resolve local file system path', assert => {
+            // Test Windows-style file path
+            const assetPath1 = new ENGINE.AssetPath('assets/models/character.glb');
+            const resolvedPath1 = 'file:///D:/work/genesys.js/assets/models/character.glb';
+            assetPath1.resolvePath(resolvedPath1, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath1.isResolved(), true, 'Windows file path is resolved');
+            assert.equal(assetPath1.getResolvedPath(true), resolvedPath1, 'Windows file path encoded version');
+            assert.equal(assetPath1.getResolvedPath(false), resolvedPath1, 'Windows file path decoded version');
+            // Test Unix-style file path
+            const assetPath2 = new ENGINE.AssetPath('assets/textures/ground.jpg');
+            const resolvedPath2 = 'file:///home/user/project/assets/textures/ground.jpg';
+            assetPath2.resolvePath(resolvedPath2, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath2.isResolved(), true, 'Unix file path is resolved');
+            assert.equal(assetPath2.getResolvedPath(true), resolvedPath2, 'Unix file path encoded version');
+            assert.equal(assetPath2.getResolvedPath(false), resolvedPath2, 'Unix file path decoded version');
+            // Test file path with spaces
+            const assetPath3 = new ENGINE.AssetPath('assets/sounds/background music.mp3');
+            const resolvedPath3 = 'file:///C:/My Project/assets/sounds/background music.mp3';
+            assetPath3.resolvePath(resolvedPath3, ENGINE.AssetPathEncodeState.Decoded);
+            assert.equal(assetPath3.isResolved(), true, 'File path with spaces is resolved');
+            assert.equal(assetPath3.getResolvedPath(false), resolvedPath3, 'Decoded file path preserves spaces');
+            assert.equal(assetPath3.getResolvedPath(true), 'file:///C:/My%20Project/assets/sounds/background%20music.mp3', 'Encoded file path escapes spaces');
+            // Test relative local path (common in development)
+            const assetPath4 = new ENGINE.AssetPath('./assets/config/settings.json');
+            const resolvedPath4 = 'file://./assets/config/settings.json';
+            assetPath4.resolvePath(resolvedPath4, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath4.isResolved(), true, 'Relative file path is resolved');
+            assert.equal(assetPath4.getResolvedPath(true), resolvedPath4, 'Relative file path encoded version');
+            assert.equal(assetPath4.getResolvedPath(false), resolvedPath4, 'Relative file path decoded version');
+            // Test file path with encoded input
+            const assetPath5 = new ENGINE.AssetPath('assets/models/my character.fbx');
+            const resolvedPath5 = 'file:///D:/projects/game/assets/models/my%20character.fbx';
+            assetPath5.resolvePath(resolvedPath5, ENGINE.AssetPathEncodeState.Encoded);
+            assert.equal(assetPath5.isResolved(), true, 'Pre-encoded file path is resolved');
+            assert.equal(assetPath5.getResolvedPath(true), resolvedPath5, 'Pre-encoded file path uses provided encoding');
+            assert.equal(assetPath5.getResolvedPath(false), 'file:///D:/projects/game/assets/models/my character.fbx', 'Pre-encoded file path decodes correctly');
+            // Test file path with special characters
+            const assetPath6 = new ENGINE.AssetPath('assets/models/robot (v2).glb');
+            const resolvedPath6 = 'file:///C:/game-assets/models/robot (v2).glb';
+            assetPath6.resolvePath(resolvedPath6, ENGINE.AssetPathEncodeState.Decoded);
+            assert.equal(assetPath6.isResolved(), true, 'File path with special characters is resolved');
+            assert.equal(assetPath6.getResolvedPath(false), resolvedPath6, 'Decoded file path preserves parentheses');
+            assert.equal(assetPath6.getResolvedPath(true), 'file:///C:/game-assets/models/robot%20(v2).glb', 'Encoded file path escapes spaces and parentheses');
+            // Test file path with mixed encoding state (Unknown)
+            const assetPath7 = new ENGINE.AssetPath('assets/fonts/Arial Bold.ttf');
+            const resolvedPath7 = 'file:///usr/share/fonts/Arial Bold.ttf';
+            assetPath7.resolvePath(resolvedPath7, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath7.isResolved(), true, 'File path with spaces (Unknown state) is resolved');
+            assert.equal(assetPath7.getResolvedPath(false), resolvedPath7, 'Unknown state decoded preserves spaces');
+            assert.equal(assetPath7.getResolvedPath(true), 'file:///usr/share/fonts/Arial%20Bold.ttf', 'Unknown state encoded escapes spaces');
+        });
+        QUnit.test('resolve site-relative path with all encode states', assert => {
+            // Test AssetPathEncodeState.Unknown (simple path)
+            const assetPath1 = new ENGINE.AssetPath('/static/textures/grass.jpg');
+            const resolvedPath1 = 'https://example.com/static/textures/grass.jpg';
+            assetPath1.resolvePath(resolvedPath1, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath1.isResolved(), true, 'Site-relative path is resolved (Unknown)');
+            assert.equal(assetPath1.getResolvedPath(true), resolvedPath1, 'Resolved encoded path matches expected URL (Unknown)');
+            assert.equal(assetPath1.getResolvedPath(false), resolvedPath1, 'Resolved decoded path matches expected URL (Unknown)');
+            // Test AssetPathEncodeState.Decoded (path with spaces)
+            const assetPath2 = new ENGINE.AssetPath('@engine/assets/images/hero banner.png');
+            const resolvedPath2 = 'https://cdn.example.com/assets/images/hero banner.png';
+            assetPath2.resolvePath(resolvedPath2, ENGINE.AssetPathEncodeState.Decoded);
+            assert.equal(assetPath2.isResolved(), true, 'Site-relative path with spaces is resolved (Decoded)');
+            assert.equal(assetPath2.getResolvedPath(false), resolvedPath2, 'Decoded path preserves spaces (Decoded)');
+            assert.equal(assetPath2.getResolvedPath(true), 'https://cdn.example.com/assets/images/hero%20banner.png', 'Encoded path escapes spaces (Decoded)');
+            // Test AssetPathEncodeState.Encoded (pre-encoded path)
+            const assetPath3 = new ENGINE.AssetPath('/api/files/user data.json');
+            const resolvedPath3 = 'https://api.example.com/api/files/user%20data.json';
+            assetPath3.resolvePath(resolvedPath3, ENGINE.AssetPathEncodeState.Encoded);
+            assert.equal(assetPath3.isResolved(), true, 'Site-relative pre-encoded path is resolved (Encoded)');
+            assert.equal(assetPath3.getResolvedPath(true), resolvedPath3, 'Encoded path uses provided encoded string (Encoded)');
+            assert.equal(assetPath3.getResolvedPath(false), 'https://api.example.com/api/files/user data.json', 'Decoded path decodes correctly (Encoded)');
+            // Test AssetPathEncodeState.Unknown (path with special characters)
+            const assetPath4 = new ENGINE.AssetPath('/docs/guide (v2).pdf');
+            const resolvedPath4 = 'https://docs.example.com/docs/guide (v2).pdf';
+            assetPath4.resolvePath(resolvedPath4, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath4.isResolved(), true, 'Site-relative path with special chars is resolved (Unknown)');
+            assert.equal(assetPath4.getResolvedPath(false), resolvedPath4, 'Decoded path preserves special characters (Unknown)');
+            assert.equal(assetPath4.getResolvedPath(true), 'https://docs.example.com/docs/guide%20(v2).pdf', 'Encoded path escapes special characters (Unknown)');
+        });
+        QUnit.test('resolve fully qualified URL with all encode states', assert => {
+            // Test AssetPathEncodeState.Encoded (simple URL)
+            const assetPath1 = new ENGINE.AssetPath('https://cdn.example.com/assets/sound.mp3');
+            const resolvedPath1 = 'https://cdn.example.com/assets/sound.mp3';
+            assetPath1.resolvePath(resolvedPath1, ENGINE.AssetPathEncodeState.Encoded);
+            assert.equal(assetPath1.isResolved(), true, 'Fully qualified URL is resolved (Encoded)');
+            assert.equal(assetPath1.getResolvedPath(true), resolvedPath1, 'Encoded path matches original URL (Encoded)');
+            assert.equal(assetPath1.getResolvedPath(false), resolvedPath1, 'Decoded path matches original URL (Encoded)');
+            // Test AssetPathEncodeState.Decoded (URL with spaces)
+            const assetPath2 = new ENGINE.AssetPath('https://storage.example.com/videos/intro video.mp4');
+            const resolvedPath2 = 'https://storage.example.com/videos/intro video.mp4';
+            assetPath2.resolvePath(resolvedPath2, ENGINE.AssetPathEncodeState.Decoded);
+            assert.equal(assetPath2.isResolved(), true, 'Fully qualified URL with spaces is resolved (Decoded)');
+            assert.equal(assetPath2.getResolvedPath(false), resolvedPath2, 'Decoded path preserves spaces (Decoded)');
+            assert.equal(assetPath2.getResolvedPath(true), 'https://storage.example.com/videos/intro%20video.mp4', 'Encoded path escapes spaces (Decoded)');
+            // Test AssetPathEncodeState.Encoded (pre-encoded URL)
+            const assetPath3 = new ENGINE.AssetPath('https://api.example.com/files/report final.xlsx');
+            const resolvedPath3 = 'https://api.example.com/files/report%20final.xlsx';
+            assetPath3.resolvePath(resolvedPath3, ENGINE.AssetPathEncodeState.Encoded);
+            assert.equal(assetPath3.isResolved(), true, 'Pre-encoded fully qualified URL is resolved (Encoded)');
+            assert.equal(assetPath3.getResolvedPath(true), resolvedPath3, 'Encoded path uses provided encoded string (Encoded)');
+            assert.equal(assetPath3.getResolvedPath(false), 'https://api.example.com/files/report final.xlsx', 'Decoded path decodes correctly (Encoded)');
+            // Test AssetPathEncodeState.Unknown (URL with query parameters and spaces)
+            const assetPath4 = new ENGINE.AssetPath('https://media.example.com/images/profile pic.jpg');
+            const resolvedPath4 = 'https://media.example.com/images/profile pic.jpg?size=large&quality=high';
+            assetPath4.resolvePath(resolvedPath4, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath4.isResolved(), true, 'Fully qualified URL with query params is resolved (Unknown)');
+            assert.equal(assetPath4.getResolvedPath(false), resolvedPath4, 'Decoded path preserves spaces and query params (Unknown)');
+            assert.equal(assetPath4.getResolvedPath(true), 'https://media.example.com/images/profile%20pic.jpg?size=large&quality=high', 'Encoded path escapes spaces but preserves query params (Unknown)');
+            // Test AssetPathEncodeState.Unknown (URL with special characters)
+            const assetPath5 = new ENGINE.AssetPath('https://files.example.com/docs/manual (en).pdf');
+            const resolvedPath5 = 'https://files.example.com/docs/manual (en).pdf';
+            assetPath5.resolvePath(resolvedPath5, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath5.isResolved(), true, 'Fully qualified URL with special chars is resolved (Unknown)');
+            assert.equal(assetPath5.getResolvedPath(false), resolvedPath5, 'Decoded path preserves special characters (Unknown)');
+            assert.equal(assetPath5.getResolvedPath(true), 'https://files.example.com/docs/manual%20(en).pdf', 'Encoded path escapes special characters (Unknown)');
+        });
+        QUnit.test('resolve path with spaces and special characters', assert => {
+            const assetPath = new ENGINE.AssetPath('assets/My File (1).txt');
+            const resolvedPath = 'http://localhost/assets/My File (1).txt';
+            assetPath.resolvePath(resolvedPath, ENGINE.AssetPathEncodeState.Decoded);
+            assert.equal(assetPath.isResolved(), true, 'Path with spaces is resolved');
+            assert.equal(assetPath.getResolvedPath(false), resolvedPath, 'Decoded path preserves spaces and special chars');
+            assert.equal(assetPath.getResolvedPath(true), 'http://localhost/assets/My%20File%20(1).txt', 'Encoded path properly encodes spaces and special chars');
+        });
+        QUnit.test('resolve with pre-encoded path', assert => {
+            const assetPath = new ENGINE.AssetPath('assets/file%20name.txt');
+            const resolvedPath = 'http://localhost/assets/file%20name.txt';
+            assetPath.resolvePath(resolvedPath, ENGINE.AssetPathEncodeState.Encoded);
+            assert.equal(assetPath.isResolved(), true, 'Pre-encoded path is resolved');
+            assert.equal(assetPath.getResolvedPath(true), resolvedPath, 'Encoded path uses provided encoded string');
+            assert.equal(assetPath.getResolvedPath(false), 'http://localhost/assets/file name.txt', 'Decoded path decodes the %20 to space');
+        });
+        QUnit.test('double resolution throws error', assert => {
+            const assetPath = new ENGINE.AssetPath('test.txt');
+            assetPath.resolvePath('http://localhost/test.txt', ENGINE.AssetPathEncodeState.Unknown);
+            assert.throws(() => {
+                assetPath.resolvePath('http://other.com/test.txt', ENGINE.AssetPathEncodeState.Unknown);
+            }, /Path already resolved/, 'Second resolution attempt throws error');
+        });
+        QUnit.test('empty resolution behavior', assert => {
+            const assetPath = new ENGINE.AssetPath('test.txt');
+            // Empty path doesn't throw an error during resolution and is handled gracefully
+            assetPath.resolvePath('', ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath.isResolved(), true, 'Empty path is marked as resolved by isResolved()');
+            // getResolvedPath now works with empty strings (fixed to check === null instead of falsy)
+            assert.equal(assetPath.getResolvedPath(true), '', 'Empty path resolves to empty encoded string');
+            assert.equal(assetPath.getResolvedPath(false), '', 'Empty path resolves to empty decoded string');
+        });
+    });
+    QUnit.module('Path Access', () => {
+        QUnit.test('getResolvedPath before resolution throws error', assert => {
+            const assetPath = new ENGINE.AssetPath('unresolved.txt');
+            assert.throws(() => {
+                assetPath.getResolvedPath();
+            }, /not resolved/, 'Getting unresolved path throws error');
+        });
+        QUnit.test('getResolvedPath with encoding options', assert => {
+            const assetPath = new ENGINE.AssetPath('test file.txt');
+            assetPath.resolvePath('http://localhost/test file.txt', ENGINE.AssetPathEncodeState.Decoded);
+            const encoded = assetPath.getResolvedPath(true);
+            const decoded = assetPath.getResolvedPath(false);
+            assert.equal(encoded, 'http://localhost/test%20file.txt', 'Encoded version has %20 for spaces');
+            assert.equal(decoded, 'http://localhost/test file.txt', 'Decoded version has actual spaces');
+        });
+    });
+    QUnit.module('Utility Methods', () => {
+        QUnit.test('useForwardSlashes', assert => {
+            assert.equal(ENGINE.AssetPath.useForwardSlashes('path\\to\\file.txt'), 'path/to/file.txt', 'Converts backslashes to forward slashes');
+            assert.equal(ENGINE.AssetPath.useForwardSlashes('path/to/file.txt'), 'path/to/file.txt', 'Leaves forward slashes unchanged');
+            assert.equal(ENGINE.AssetPath.useForwardSlashes('mixed\\path/to\\file.txt'), 'mixed/path/to/file.txt', 'Handles mixed slash types');
+        });
+        QUnit.test('removeLeadingSlash', assert => {
+            assert.equal(ENGINE.AssetPath.removeLeadingSlash('/path/file.txt'), 'path/file.txt', 'Removes single leading slash');
+            assert.equal(ENGINE.AssetPath.removeLeadingSlash('///path/file.txt'), 'path/file.txt', 'Removes multiple leading slashes');
+            assert.equal(ENGINE.AssetPath.removeLeadingSlash('path/file.txt'), 'path/file.txt', 'Leaves path without leading slash unchanged');
+        });
+        QUnit.test('removeTrailingSlash', assert => {
+            assert.equal(ENGINE.AssetPath.removeTrailingSlash('path/folder/'), 'path/folder', 'Removes single trailing slash');
+            assert.equal(ENGINE.AssetPath.removeTrailingSlash('path/folder///'), 'path/folder', 'Removes multiple trailing slashes');
+            assert.equal(ENGINE.AssetPath.removeTrailingSlash('path/folder'), 'path/folder', 'Leaves path without trailing slash unchanged');
+        });
+    });
+    QUnit.module('Real-world Scenarios', () => {
+        QUnit.test('project-relative path (@project prefix)', assert => {
+            const assetPath = new ENGINE.AssetPath('@project/assets/models/player.glb');
+            const resolvedPath = 'https://gameserver.com/projects/123/assets/models/player.glb';
+            assetPath.resolvePath(resolvedPath, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath.initialPath, '@project/assets/models/player.glb', 'Initial path preserves @project prefix');
+            assert.equal(assetPath.getResolvedPath(), resolvedPath, 'Resolved to full game server URL');
+        });
+        QUnit.test('engine-relative path (@engine prefix)', assert => {
+            const assetPath = new ENGINE.AssetPath('@engine/shaders/default.glsl');
+            const resolvedPath = 'http://localhost:3000/node_modules/genesys-engine/shaders/default.glsl';
+            assetPath.resolvePath(resolvedPath, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath.initialPath, '@engine/shaders/default.glsl', 'Initial path preserves @engine prefix');
+            assert.equal(assetPath.getResolvedPath(), resolvedPath, 'Resolved to engine assets location');
+        });
+        QUnit.test('CDN asset with complex URL', assert => {
+            const assetPath = new ENGINE.AssetPath('cdn/textures/environment_map.hdr');
+            const resolvedPath = 'https://cdn.gamecompany.com/assets/v2/textures/environment_map.hdr?token=abc123&expires=1234567890';
+            assetPath.resolvePath(resolvedPath, ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(assetPath.getResolvedPath(), resolvedPath, 'Handles CDN URLs with query parameters');
+        });
+        QUnit.test('local development vs production paths', assert => {
+            // Local development scenario
+            const localAssetPath = new ENGINE.AssetPath('assets/sounds/footstep.mp3');
+            localAssetPath.resolvePath('http://localhost:8080/assets/sounds/footstep.mp3', ENGINE.AssetPathEncodeState.Unknown);
+            // Production scenario
+            const prodAssetPath = new ENGINE.AssetPath('assets/sounds/footstep.mp3');
+            prodAssetPath.resolvePath('https://game-assets.s3.amazonaws.com/prod/sounds/footstep.mp3', ENGINE.AssetPathEncodeState.Unknown);
+            assert.equal(localAssetPath.initialPath, prodAssetPath.initialPath, 'Same initial path for both environments');
+            assert.notEqual(localAssetPath.getResolvedPath(), prodAssetPath.getResolvedPath(), 'Different resolved paths for different environments');
+            assert.ok(localAssetPath.getResolvedPath().includes('localhost'), 'Local path resolves to localhost');
+            assert.ok(prodAssetPath.getResolvedPath().includes('s3.amazonaws.com'), 'Production path resolves to S3');
+        });
+        QUnit.test('path with international characters', assert => {
+            const assetPath = new ENGINE.AssetPath('assets/音乐/背景音乐.mp3');
+            const resolvedPath = 'http://localhost/assets/音乐/背景音乐.mp3';
+            assetPath.resolvePath(resolvedPath, ENGINE.AssetPathEncodeState.Decoded);
+            assert.equal(assetPath.getResolvedPath(false), resolvedPath, 'International characters preserved in decoded path');
+            assert.ok(assetPath.getResolvedPath(true).includes('%'), 'International characters encoded in URL-safe format');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asset-path.test.js","sourceRoot":"","sources":["../../test/asset-path.test.ts"],"names":[],"mappings":"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"}

package/dist/test/component.test.d.ts

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

package/dist/test/component.test.js

@@ -0,0 +1,24 @@
+import * as ENGINE from 'genesys.js';
+import QUnit from 'qunit';
+class TestComponent extends ENGINE.SceneComponent {
+}
+QUnit.module('Component', hooks => {
+    hooks.before(() => {
+    });
+    QUnit.skip('component test', assert => {
+        {
+            // TODO: this test is broken because removal of the root component is not properly implemented
+            const component = new TestComponent();
+            const actor = new ENGINE.Actor({
+                rootComponent: component
+            });
+            assert.equal(actor.getComponents(TestComponent).length, 1, 'Actor has the component added');
+            assert.equal(actor.getComponents(TestComponent)[0], component, 'Actor has the component added');
+            assert.equal(component.getActor(), actor, 'Component has the actor as its actor');
+            component.removeFromParent();
+            assert.equal(component.getActor(), null, 'Component has no actor after removeFromParent');
+            assert.ok(!actor.getComponents(TestComponent).includes(component), 'Actor does not have the component after removeFromParent');
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LnRlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90ZXN0L2NvbXBvbmVudC50ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxNQUFNLE1BQU0sWUFBWSxDQUFDO0FBQ3JDLE9BQU8sS0FBSyxNQUFNLE9BQU8sQ0FBQztBQUcxQixNQUFNLGFBQWMsU0FBUSxNQUFNLENBQUMsY0FBNEM7Q0FDOUU7QUFFRCxLQUFLLENBQUMsTUFBTSxDQUFDLFdBQVcsRUFBRSxLQUFLLENBQUMsRUFBRTtJQUNoQyxLQUFLLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRTtJQUNsQixDQUFDLENBQUMsQ0FBQztJQUVILEtBQUssQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsTUFBTSxDQUFDLEVBQUU7UUFDcEMsQ0FBQztZQUNDLDhGQUE4RjtZQUM5RixNQUFNLFNBQVMsR0FBRyxJQUFJLGFBQWEsRUFBRSxDQUFDO1lBQ3RDLE1BQU0sS0FBSyxHQUFHLElBQUksTUFBTSxDQUFDLEtBQUssQ0FBQztnQkFDN0IsYUFBYSxFQUFFLFNBQVM7YUFDekIsQ0FBQyxDQUFDO1lBQ0gsTUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUFDLGFBQWEsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLEVBQUUsK0JBQStCLENBQUMsQ0FBQztZQUM1RixNQUFNLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsU0FBUyxFQUFFLCtCQUErQixDQUFDLENBQUM7WUFDaEcsTUFBTSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsUUFBUSxFQUFFLEVBQUUsS0FBSyxFQUFFLHNDQUFzQyxDQUFDLENBQUM7WUFFbEYsU0FBUyxDQUFDLGdCQUFnQixFQUFFLENBQUM7WUFDN0IsTUFBTSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsUUFBUSxFQUFFLEVBQUUsSUFBSSxFQUFFLCtDQUErQyxDQUFDLENBQUM7WUFDMUYsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDLEtBQUssQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxFQUFFLDBEQUEwRCxDQUFDLENBQUM7UUFDakksQ0FBQztJQUNILENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDLENBQUMifQ==

package/dist/test/construction.test.d.ts

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

package/dist/test/construction.test.js

@@ -0,0 +1,26 @@
+import * as ENGINE from 'genesys.js';
+import QUnit from 'qunit';
+import * as THREE from 'three';
+QUnit.module('Construction', hooks => {
+    hooks.before(() => {
+    });
+    QUnit.test('constructor options mutation', assert => {
+        {
+            const defaultOptionsCopy = structuredClone(ENGINE.PrimitiveComponent.DEFAULT_OPTIONS);
+            // create a component and modify its options
+            const component1 = new ENGINE.PrimitiveComponent({});
+            const mutableOptions = component1.options;
+            mutableOptions.position = new THREE.Vector3(1, 2, 3);
+            mutableOptions.scale = new THREE.Vector3(4, 5, 6);
+            mutableOptions.physicsOptions.collisionMeshType = ENGINE.CollisionMeshType.Trimesh;
+            mutableOptions.physicsOptions.density = 11;
+            // create a second component and check that its state is not modified
+            const component2 = new ENGINE.PrimitiveComponent({});
+            assert.ok(component2.position.almostEquals(new THREE.Vector3(0, 0, 0)));
+            assert.ok(component2.scale.almostEquals(new THREE.Vector3(1, 1, 1)));
+            assert.equal(component2.options.physicsOptions?.collisionMeshType, defaultOptionsCopy.physicsOptions?.collisionMeshType);
+            assert.equal(component2.options.physicsOptions?.density, defaultOptionsCopy.physicsOptions?.density);
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RydWN0aW9uLnRlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90ZXN0L2NvbnN0cnVjdGlvbi50ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxNQUFNLE1BQU0sWUFBWSxDQUFDO0FBQ3JDLE9BQU8sS0FBSyxNQUFNLE9BQU8sQ0FBQztBQUMxQixPQUFPLEtBQUssS0FBSyxNQUFNLE9BQU8sQ0FBQztBQUcvQixLQUFLLENBQUMsTUFBTSxDQUFDLGNBQWMsRUFBRSxLQUFLLENBQUMsRUFBRTtJQUNuQyxLQUFLLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRTtJQUNsQixDQUFDLENBQUMsQ0FBQztJQUVILEtBQUssQ0FBQyxJQUFJLENBQUMsOEJBQThCLEVBQUUsTUFBTSxDQUFDLEVBQUU7UUFDbEQsQ0FBQztZQUNDLE1BQU0sa0JBQWtCLEdBQUcsZUFBZSxDQUFDLE1BQU0sQ0FBQyxrQkFBa0IsQ0FBQyxlQUFlLENBQUMsQ0FBQztZQUV0Riw0Q0FBNEM7WUFDNUMsTUFBTSxVQUFVLEdBQUcsSUFBSSxNQUFNLENBQUMsa0JBQWtCLENBQW1DLEVBQUUsQ0FBQyxDQUFDO1lBQ3ZGLE1BQU0sY0FBYyxHQUFHLFVBQVUsQ0FBQyxPQUFjLENBQUM7WUFDakQsY0FBYyxDQUFDLFFBQVEsR0FBRyxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztZQUNyRCxjQUFjLENBQUMsS0FBSyxHQUFHLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBQ2xELGNBQWMsQ0FBQyxjQUFjLENBQUMsaUJBQWlCLEdBQUcsTUFBTSxDQUFDLGlCQUFpQixDQUFDLE9BQU8sQ0FBQztZQUNuRixjQUFjLENBQUMsY0FBYyxDQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFFM0MscUVBQXFFO1lBQ3JFLE1BQU0sVUFBVSxHQUFHLElBQUksTUFBTSxDQUFDLGtCQUFrQixDQUFtQyxFQUFFLENBQUMsQ0FBQztZQUN2RixNQUFNLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUMsWUFBWSxDQUFDLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUN4RSxNQUFNLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsWUFBWSxDQUFDLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUNyRSxNQUFNLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsY0FBYyxFQUFFLGlCQUFpQixFQUFFLGtCQUFrQixDQUFDLGNBQWMsRUFBRSxpQkFBaUIsQ0FBQyxDQUFDO1lBQ3pILE1BQU0sQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxjQUFjLEVBQUUsT0FBTyxFQUFFLGtCQUFrQixDQUFDLGNBQWMsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUN2RyxDQUFDO0lBQ0gsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDLENBQUMsQ0FBQyJ9

package/dist/test/default-options-validation.test.d.ts

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