npm - @directivegames/genesys.sdk - Versions diffs - 3.2.2 - Mend

@directivegames/genesys.sdk 3.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (181) hide show

package/dist/src/core/common.js ADDED Viewed

@@ -0,0 +1,324 @@
+import { exec, execSync, spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { promisify } from 'util';
+import fixPath from 'fix-path';
+import * as ENGINE from 'genesys.js';
+import { JSDOM } from 'jsdom';
+import { ALL_DEPENDENCIES } from '../dependencies.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Fix PATH on macOS when running as a GUI app
+fixPath();
+export function mockBrowserEnvironment() {
+    const dom = new JSDOM('<!DOCTYPE html><p>Hello world</p>');
+    global.window = dom.window;
+    global.document = dom.window.document;
+    global.HTMLElement = dom.window.HTMLElement;
+    if (navigator) {
+        navigator.getGamepads = () => [];
+    }
+}
+export function 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;
+    }
+}
+export function checkEngineVersion(engineVersion) {
+    const localEngineVersion = getEngineVersion();
+    if (engineVersion && engineVersion !== localEngineVersion) {
+        throw new Error(`Engine version ${localEngineVersion} does not match ${engineVersion}`);
+    }
+}
+export function getEngineVersion() {
+    return ALL_DEPENDENCIES['genesys.js'];
+}
+export function getAppVersion() {
+    const pkg = JSON.parse(fs.readFileSync(path.join(getProjectRoot(), 'package.json'), 'utf8'));
+    return pkg.version;
+}
+export function writeFileSync(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+}
+export function findFilesByPredicate(folderPath, predicate, excludeFolders) {
+    const result = [];
+    const excludeSet = excludeFolders ? new Set(excludeFolders) : null;
+    function traverse(currentPath) {
+        const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                if (excludeSet && excludeSet.has(entry.name)) {
+                    continue;
+                }
+                traverse(fullPath);
+            }
+            else if (predicate(fullPath)) {
+                result.push(fullPath);
+            }
+        }
+    }
+    traverse(folderPath);
+    return result;
+}
+/** Async version of writeFileSync */
+export async function writeFileAsync(filePath, content) {
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.promises.writeFile(filePath, content);
+}
+/** Async version of fs.existsSync */
+export async function existsAsync(filePath) {
+    try {
+        await fs.promises.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Async version of fs.cpSync */
+export async function copyAsync(source, destination, options) {
+    await fs.promises.cp(source, destination, options);
+}
+/** Async version of fs.mkdirSync */
+export async function mkdirAsync(dirPath, options) {
+    await fs.promises.mkdir(dirPath, options);
+}
+/** Async version of fs.readdirSync */
+export async function readdirAsync(dirPath) {
+    return await fs.promises.readdir(dirPath);
+}
+export function getProjectFolderAndFile(projectPath, logger) {
+    const isDirectory = fs.lstatSync(projectPath).isDirectory();
+    const folder = isDirectory ? projectPath : path.dirname(projectPath);
+    if (!fs.existsSync(folder)) {
+        return { folder: '', file: '' };
+    }
+    let projectFile = '';
+    // if the path is already a valid project file, use it directly
+    if (!isDirectory) {
+        if (path.extname(projectPath) === ENGINE.GAME_PROJECT_FILE_EXT && fs.existsSync(projectPath)) {
+            projectFile = path.basename(projectPath);
+        }
+        else {
+            logger.warn(`Path ${projectPath} is not a valid project file. Ignoring it, and using the folder.`);
+        }
+    }
+    // check if a project file of the same name as the folder exists
+    if (!projectFile) {
+        const folderName = path.basename(folder);
+        const testProjectFile = `${folderName}${ENGINE.GAME_PROJECT_FILE_EXT}`;
+        if (fs.existsSync(path.join(folder, testProjectFile))) {
+            projectFile = testProjectFile;
+            logger.log(`Using existing project file: ${projectFile}`);
+        }
+        // check for any existing project files in the folder, and use the latest one
+        if (!projectFile) {
+            const existingProjectFiles = fs.readdirSync(folder)
+                .filter(file => path.extname(file) === ENGINE.GAME_PROJECT_FILE_EXT && fs.statSync(path.join(folder, file)).isFile());
+            let latestFile = '';
+            let latestTimestamp = 0;
+            for (const file of existingProjectFiles) {
+                const fullPath = path.join(folder, file);
+                const timestamp = fs.statSync(fullPath).mtime.getTime();
+                if (timestamp > latestTimestamp) {
+                    latestTimestamp = timestamp;
+                    latestFile = file;
+                }
+            }
+            if (latestFile) {
+                projectFile = latestFile;
+                logger.log(`Using latest project file: ${projectFile}`);
+            }
+            else {
+                logger.warn(`No project files found in folder: ${folder}`);
+            }
+        }
+    }
+    return {
+        folder,
+        file: projectFile,
+    };
+}
+export function runCommand(command, workingDir, logger) {
+    const originalDir = process.cwd();
+    try {
+        if (workingDir) {
+            process.chdir(workingDir);
+        }
+        logger.log(`Running command: ${command}`);
+        execSync(command, { stdio: 'inherit' });
+    }
+    finally {
+        process.chdir(originalDir);
+    }
+}
+const execAsync = promisify(exec);
+/** Strip ANSI escape codes from strings */
+function stripAnsi(str) {
+    return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '').replace(/\x1B\]/g, '');
+}
+export async function runCommandAsync(command, workingDir, logger, onProgress) {
+    const originalDir = process.cwd();
+    // If no progress callback is provided, use the old exec method for backwards compatibility
+    if (!onProgress) {
+        let error = null;
+        let stdout = '';
+        let stderr = '';
+        try {
+            if (workingDir) {
+                process.chdir(workingDir);
+            }
+            logger.log(`Running command async: ${command}`);
+            const { stdout: execStdout, stderr: execStderr } = await execAsync(command);
+            stdout = execStdout;
+            stderr = execStderr;
+        }
+        catch (err) {
+            error = err;
+            stdout = error.stdout ?? '';
+            stderr = error.stderr ?? '';
+        }
+        finally {
+            process.chdir(originalDir);
+        }
+        let output = undefined;
+        if (stdout.length > 0 || stderr.length > 0) {
+            output = `Output of command ${command}:`;
+            if (stdout.length > 0) {
+                output += `\nstdout:\n${stdout}`;
+            }
+            if (stderr.length > 0) {
+                output += `\nstderr:\n${stderr}`;
+            }
+        }
+        if (error) {
+            logger.error(`Command ${command} exited with code ${error.code}: ${error.message}`);
+            if (output) {
+                logger.error(output);
+            }
+        }
+        else {
+            if (output) {
+                logger.log(output);
+            }
+        }
+        return { error, stdout, stderr };
+    }
+    // Use spawn for real-time progress tracking
+    return new Promise((resolve) => {
+        try {
+            if (workingDir) {
+                process.chdir(workingDir);
+            }
+            logger.log(`Running command async with progress: ${command}`);
+            // Parse command for spawn (handles complex commands with arguments)
+            const isWindows = process.platform === 'win32';
+            const shell = isWindows ? 'cmd.exe' : '/bin/sh';
+            const shellArg = isWindows ? '/c' : '-c';
+            const child = spawn(shell, [shellArg, command], {
+                cwd: workingDir ?? undefined,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: process.env
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout?.on('data', (data) => {
+                const text = data.toString();
+                stdout += text;
+                // Extract progress info from pnpm/command output
+                const lines = text.split('\n').filter((line) => line.trim());
+                for (const line of lines) {
+                    const cleanedLine = stripAnsi(line.trim());
+                    // Pass through pnpm progress indicators (verbose output, stages, completion)
+                    if (cleanedLine.includes('http fetch') || cleanedLine.includes('http 200') ||
+                        cleanedLine.includes('idealTree') || cleanedLine.includes('reify') ||
+                        cleanedLine.includes('extract') || cleanedLine.includes('build') ||
+                        cleanedLine.includes('postinstall') || cleanedLine.includes('timing') ||
+                        cleanedLine.match(/added \d+|removed \d+|changed \d+|audited \d+/)) {
+                        onProgress(cleanedLine);
+                    }
+                }
+            });
+            child.stderr?.on('data', (data) => {
+                const text = data.toString();
+                stderr += text;
+                // pnpm outputs progress info to stderr as well
+                const lines = text.split('\n').filter((line) => line.trim());
+                for (const line of lines) {
+                    const cleanedLine = stripAnsi(line.trim());
+                    // Pass through pnpm progress indicators (filter out deprecated warnings)
+                    if (cleanedLine && !cleanedLine.startsWith('WARN deprecated')) {
+                        if (cleanedLine.includes('http fetch') || cleanedLine.includes('http 200') ||
+                            cleanedLine.includes('idealTree') || cleanedLine.includes('reify') ||
+                            cleanedLine.includes('extract') || cleanedLine.includes('build') ||
+                            cleanedLine.includes('timing') || cleanedLine.match(/added \d+/)) {
+                            onProgress(cleanedLine);
+                        }
+                    }
+                }
+            });
+            child.on('close', (code) => {
+                process.chdir(originalDir);
+                let output = undefined;
+                if (stdout.length > 0 || stderr.length > 0) {
+                    output = `Output of command ${command}:`;
+                    if (stdout.length > 0) {
+                        output += `\nstdout:\n${stdout}`;
+                    }
+                    if (stderr.length > 0) {
+                        output += `\nstderr:\n${stderr}`;
+                    }
+                }
+                const error = code !== 0 ? Object.assign(new Error(`Command failed with exit code ${code}`), {
+                    code,
+                    stdout,
+                    stderr,
+                    killed: false,
+                    signal: undefined,
+                    cmd: command
+                }) : null;
+                if (error) {
+                    logger.error(`Command ${command} exited with code ${code}`);
+                    if (output) {
+                        logger.error(output);
+                    }
+                }
+                else {
+                    if (output) {
+                        logger.log(output);
+                    }
+                }
+                resolve({ error, stdout, stderr });
+            });
+            child.on('error', (err) => {
+                process.chdir(originalDir);
+                const execError = err;
+                logger.error(`Failed to execute command ${command}: ${execError.message}`);
+                resolve({
+                    error: execError,
+                    stdout: '',
+                    stderr: execError.message
+                });
+            });
+        }
+        catch (err) {
+            process.chdir(originalDir);
+            const error = err;
+            resolve({
+                error,
+                stdout: error.stdout ?? '',
+                stderr: error.stderr ?? ''
+            });
+        }
+    });
+}

package/dist/src/core/index.js ADDED Viewed

@@ -0,0 +1,6 @@
+export * from './common.js';
+export * from './types.js';
+export * from './tools/index.js';
+export const IgnoredFiles = [
+    '.DS_Store',
+];