@directivegames/genesys.sdk 3.2.2

package/dist/src/electron/backend/tools/open-project.js

@@ -0,0 +1,261 @@
+import fs from 'fs';
+import path from 'path';
+import { app, dialog } from 'electron';
+import * as ENGINE from 'genesys.js';
+import { copySharedTemplateToProject, createGenesysProjectFile, getEngineVersion, getProjectFolderAndFile, getProjectNameFromPath, getProjectRoot, IgnoredFiles, projectFiles, runCommandAsync } from '../../../core/index.js';
+import { getTemplatePath as getTemplatePathImpl } from '../../../core/tools/new-project.js';
+import { deletedTemplateItems, sharedTemplateItems } from '../../../templates/src/index.js';
+import { logger } from '../logging.js';
+import { mainWindow } from '../main.js';
+import { DefaultGameFilePath, } from './const.js';
+function getTemplatePath() {
+    return getTemplatePathImpl(app.isPackaged, process.resourcesPath, getProjectRoot());
+}
+async function updateProject(projectPath, onBeginVerifyProject, onEndVerifyProject, onBeginUpdateProject, onEndUpdateProject) {
+    try {
+        onBeginVerifyProject();
+        const projectName = getProjectNameFromPath(projectPath);
+        const expectedPackageJson = projectFiles.packageJson;
+        const projectPackageJsonPath = path.join(projectPath, 'package.json');
+        if (!fs.existsSync(projectPackageJsonPath)) {
+            onEndVerifyProject();
+            throw new Error(`Missing ${projectPackageJsonPath}`);
+        }
+        const updateItems = [];
+        let projectPackageJson;
+        try {
+            projectPackageJson = JSON.parse(fs.readFileSync(projectPackageJsonPath, 'utf8'));
+        }
+        catch (error) {
+            throw new Error(`Failed to parse package.json: ${error.message}`);
+        }
+        function updateSettings(key) {
+            const expectedSettings = expectedPackageJson[key];
+            const currentSettings = projectPackageJson[key] ?? {};
+            for (const [name, expectedValue] of Object.entries(expectedSettings)) {
+                const currentValue = currentSettings[name];
+                if (currentValue !== expectedValue) {
+                    updateItems.push(`Update ${name} from ${currentValue} to ${expectedValue}`);
+                }
+            }
+        }
+        if (!projectPackageJson.name) {
+            updateItems.push(`Set project name to ${projectName}`);
+            projectPackageJson.name = projectName;
+        }
+        if (!projectPackageJson.version) {
+            updateItems.push(`Set project version to ${expectedPackageJson.version}`);
+            projectPackageJson.version = expectedPackageJson.version;
+        }
+        updateSettings('dependencies');
+        updateSettings('devDependencies');
+        updateSettings('scripts');
+        for (const deletedItem of deletedTemplateItems) {
+            const filePath = path.join(projectPath, deletedItem);
+            if (fs.existsSync(filePath)) {
+                updateItems.push(`Delete ${deletedItem}`);
+            }
+        }
+        // gather all the files that are not in the project source
+        const templatePackagePath = getTemplatePath();
+        for (const sharedItem of sharedTemplateItems) {
+            const sourcePath = path.join(templatePackagePath, sharedItem);
+            // _gitignore is renamed to .gitignore when copied to the project
+            const destinationName = sharedItem === '_gitignore' ? '.gitignore' : sharedItem;
+            const destinatePath = path.join(projectPath, destinationName);
+            if (!fs.existsSync(sourcePath)) {
+                continue;
+            }
+            try {
+                if (fs.statSync(sourcePath).isDirectory()) {
+                    const projectSourceFiles = fs.readdirSync(sourcePath, { recursive: true });
+                    for (const file of projectSourceFiles) {
+                        const sourceFilePath = path.join(sourcePath, file);
+                        if (fs.statSync(sourceFilePath).isDirectory()) {
+                            continue;
+                        }
+                        const destinationFilePath = path.join(destinatePath, file);
+                        if (!fs.existsSync(destinationFilePath)) {
+                            updateItems.push(`Add ${file}`);
+                            continue;
+                        }
+                        try {
+                            const sourceContent = fs.readFileSync(sourceFilePath, 'utf8');
+                            const destContent = fs.readFileSync(destinationFilePath, 'utf8');
+                            if (sourceContent !== destContent) {
+                                updateItems.push(`Update ${file}`);
+                            }
+                        }
+                        catch (error) {
+                            logger.log(`Warning: Failed to compare file ${file}: ${error.message}`);
+                        }
+                    }
+                }
+                else {
+                    if (!fs.existsSync(destinatePath)) {
+                        updateItems.push(`Add ${destinationName}`);
+                    }
+                    else {
+                        try {
+                            const sourceContent = fs.readFileSync(sourcePath, 'utf8');
+                            const destContent = fs.readFileSync(destinatePath, 'utf8');
+                            if (sourceContent !== destContent) {
+                                updateItems.push(`Update ${destinationName}`);
+                            }
+                        }
+                        catch (error) {
+                            logger.log(`Warning: Failed to compare file ${destinationName}: ${error.message}`);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                logger.log(`Warning: Failed to process ${destinationName}: ${error.message}`);
+            }
+        }
+        onEndVerifyProject();
+        if (updateItems.length > 0) {
+            // Make dialog non-blocking by not awaiting it
+            dialog.showMessageBox(mainWindow, {
+                type: 'info',
+                buttons: ['Update', 'Ignore'],
+                title: 'Project Update Required',
+                message: 'The project requires the following updates: ',
+                detail: updateItems.join('\n'),
+            }).then(async ({ response }) => {
+                if (response === 0) {
+                    onBeginUpdateProject();
+                    try {
+                        await performProjectUpdate(projectPath, projectPackageJson, expectedPackageJson, projectPackageJsonPath);
+                    }
+                    catch (error) {
+                        logger.log(`Error updating project: ${error.message}`);
+                        // dialog.showMessageBox(mainWindow!, {
+                        //   type: 'error',
+                        //   buttons: ['OK'],
+                        //   title: 'Project Update Failed',
+                        //   message: 'Failed to update the project',
+                        //   detail: (error as Error).message,
+                        // }).catch((dialogError) => {
+                        //   logger.log(`Error showing update dialog: ${(dialogError as Error).message}`);
+                        // });
+                    }
+                    finally {
+                        onEndUpdateProject();
+                    }
+                }
+            }).catch((error) => {
+                logger.log(`Error showing update dialog: ${error.message}`);
+            });
+        }
+    }
+    catch (error) {
+        onEndVerifyProject();
+        logger.log(`Error in updateProject: ${error.message}`);
+        throw error;
+    }
+}
+/** Performs the actual project update operations */
+async function performProjectUpdate(projectPath, projectPackageJson, expectedPackageJson, projectPackageJsonPath) {
+    try {
+        // Copy shared template files first
+        const templatePackagePath = getTemplatePath();
+        await copySharedTemplateToProject(projectPath, templatePackagePath, logger);
+        // Update package.json with proper merging
+        projectPackageJson.dependencies = {
+            ...projectPackageJson.dependencies,
+            ...expectedPackageJson.dependencies
+        };
+        projectPackageJson.devDependencies = {
+            ...projectPackageJson.devDependencies,
+            ...expectedPackageJson.devDependencies
+        };
+        projectPackageJson.scripts = {
+            ...projectPackageJson.scripts,
+            ...expectedPackageJson.scripts
+        };
+        // Write package.json with error handling
+        try {
+            fs.writeFileSync(projectPackageJsonPath, JSON.stringify(projectPackageJson, null, 2));
+            logger.log(`${projectPackageJsonPath} updated`);
+        }
+        catch (error) {
+            throw new Error(`Failed to write package.json: ${error.message}`);
+        }
+        logger.log('Running pnpm install and pnpm build...');
+        // Run commands asynchronously for better performance
+        await runCommandAsync('pnpm install', projectPath, logger);
+        await runCommandAsync('pnpm build', projectPath, logger);
+        logger.log('Project updated successfully');
+        // Show success dialog
+        dialog.showMessageBox(mainWindow, {
+            type: 'info',
+            buttons: ['OK'],
+            title: 'Project Updated',
+            message: 'The project has been updated successfully',
+        }).catch((error) => {
+            logger.log(`Error showing success dialog: ${error.message}`);
+        });
+    }
+    catch (error) {
+        logger.log(`Error in performProjectUpdate: ${error.message}`);
+        throw error;
+    }
+}
+export async function openProject(projectFileOrFolderPath, onBeginOpenProject, onEndOpenProject, onBeginVerifyProject, onEndVerifyProject, onBeginUpdateProject, onEndUpdateProject) {
+    const { folder: folderPath, file: projectFileName } = getProjectFolderAndFile(projectFileOrFolderPath, logger);
+    return await openProjectImpl(folderPath, projectFileName, onBeginOpenProject, onEndOpenProject, onBeginVerifyProject, onEndVerifyProject, onBeginUpdateProject, onEndUpdateProject);
+}
+async function openProjectImpl(projectFolderPath, projectFileName, onBeginOpenProject, onEndOpenProject, onBeginVerifyProject, onEndVerifyProject, onBeginUpdateProject, onEndUpdateProject) {
+    logger.log(`Opening project at ${projectFolderPath}` + (projectFileName ? ` with file ${projectFileName}` : ''));
+    if (!fs.existsSync(path.join(projectFolderPath, 'node_modules'))) {
+        logger.log('Project node_modules not found, running pnpm install...');
+        await runCommandAsync('pnpm install', projectFolderPath, logger);
+    }
+    let projectPath = path.join(projectFolderPath, projectFileName);
+    const existingFiles = fs.readdirSync(projectFolderPath).filter(file => !IgnoredFiles.includes(file));
+    if (existingFiles.length) {
+        // only check the files if the project is not empty
+        const gameFilePath = path.join(projectFolderPath, DefaultGameFilePath);
+        if (!fs.existsSync(gameFilePath)) {
+            return {
+                success: false,
+                message: `Project ${projectFolderPath} is not a valid Genesys project, missing ${gameFilePath}`,
+                path: projectFolderPath
+            };
+        }
+        onBeginOpenProject();
+        try {
+            if (!projectFileName) {
+                projectPath = await createGenesysProjectFile(projectFolderPath);
+            }
+            await updateProject(projectFolderPath, onBeginVerifyProject, onEndVerifyProject, onBeginUpdateProject, onEndUpdateProject);
+            {
+                // update the engine version in the project file
+                const projectSettings = JSON.parse(fs.readFileSync(projectPath, 'utf8'));
+                projectSettings[ENGINE.ENGINE_VERSION_KEY] = getEngineVersion();
+                fs.writeFileSync(projectPath, JSON.stringify(projectSettings, null, 2));
+            }
+            if (!fs.existsSync(path.join(projectFolderPath, 'node_modules'))) {
+                await runCommandAsync('pnpm install', projectFolderPath, logger);
+            }
+        }
+        catch (error) {
+            console.error(error);
+            return {
+                success: false,
+                message: `Failed to open project ${projectFolderPath}`,
+                path: projectPath,
+                error: error,
+            };
+        }
+        finally {
+            onEndOpenProject();
+        }
+    }
+    return {
+        success: true,
+        message: `Project ${projectPath} opened`,
+        path: projectPath
+    };
+}

package/dist/src/electron/backend/window.js

@@ -0,0 +1,161 @@
+import { BrowserWindow, screen } from 'electron';
+import { AppStateKey } from '../api.js';
+import { appState } from './state.js';
+/** Helper function to get the display that contains the window */
+const getDisplayForWindow = (window) => {
+    const windowBounds = window.getBounds();
+    const displays = screen.getAllDisplays();
+    return displays.find(display => {
+        const { x, y, width, height } = display.bounds;
+        const windowCenterX = windowBounds.x + windowBounds.width / 2;
+        const windowCenterY = windowBounds.y + windowBounds.height / 2;
+        return windowCenterX >= x && windowCenterX < x + width &&
+            windowCenterY >= y && windowCenterY < y + height;
+    });
+};
+/** Debounce helper function */
+const debounce = (func, delay) => {
+    let timeoutId;
+    return (...args) => {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => func(...args), delay);
+    };
+};
+/**
+ * Creates a new window with the given options.
+ * @param name - The name of the window.
+ * @param options - The options for the window.
+ * @returns The created window.
+ */
+export function createWindow(name, options) {
+    const defaultSize = {
+        width: options.width ?? 1920,
+        height: options.height ?? 900
+    };
+    let window;
+    const getState = () => {
+        return appState.getState(AppStateKey.WindowState) ?? { ...defaultSize, maximized: true };
+    };
+    const getCurrentPosition = () => {
+        const position = window.getPosition();
+        const size = window.getSize();
+        return {
+            x: position[0],
+            y: position[1],
+            width: size[0],
+            height: size[1],
+            maximized: window.isMaximized()
+        };
+    };
+    const windowWithinBounds = (windowState, bounds) => {
+        if (windowState.x != null && windowState.y != null) {
+            return (windowState.x >= bounds.x &&
+                windowState.y >= bounds.y &&
+                windowState.x + windowState.width <= bounds.x + bounds.width &&
+                windowState.y + windowState.height <= bounds.y + bounds.height);
+        }
+        if (windowState.x === undefined && windowState.y === undefined) {
+            return true;
+        }
+        return false;
+    };
+    const resetToDefaults = () => {
+        return {
+            ...defaultSize,
+            maximized: true
+        };
+    };
+    const ensureVisibleOnSomeDisplay = (windowState) => {
+        const displays = screen.getAllDisplays();
+        // If we have a saved display ID, try to find that display
+        if (windowState.displayId) {
+            const savedDisplay = displays.find(d => d.id === windowState.displayId);
+            if (savedDisplay) {
+                // Check if the window would be visible on the saved display
+                if (windowWithinBounds(windowState, savedDisplay.bounds)) {
+                    return windowState;
+                }
+                // If not visible, center it on the saved display
+                return {
+                    ...windowState,
+                    x: savedDisplay.bounds.x + (savedDisplay.bounds.width - windowState.width) / 2,
+                    y: savedDisplay.bounds.y + (savedDisplay.bounds.height - windowState.height) / 2
+                };
+            }
+        }
+        // Fallback to existing logic
+        const visible = !!windowState.maximized || displays.some(display => {
+            return windowWithinBounds(windowState, display.bounds);
+        });
+        if (!visible) {
+            return resetToDefaults();
+        }
+        return windowState;
+    };
+    const saveState = () => {
+        const maximized = window.isMaximized();
+        const currentDisplay = getDisplayForWindow(window);
+        if (maximized) {
+            appState.setState(AppStateKey.WindowState, {
+                ...getState(),
+                maximized: true,
+                displayId: currentDisplay?.id
+            });
+        }
+        else if (!window.isMinimized()) {
+            const state = getCurrentPosition();
+            appState.setState(AppStateKey.WindowState, {
+                ...state,
+                displayId: currentDisplay?.id
+            });
+        }
+    };
+    const debouncedSaveState = debounce(saveState, 1000);
+    const { maximized, ...windowState } = ensureVisibleOnSomeDisplay(getState());
+    window = new BrowserWindow({ ...options, ...windowState });
+    if (maximized) {
+        window.maximize();
+    }
+    // Save state on window changes with debounce
+    window.on('resize', debouncedSaveState);
+    window.on('move', debouncedSaveState);
+    window.on('maximize', debouncedSaveState);
+    window.on('unmaximize', debouncedSaveState);
+    // Save immediately on close (no debounce needed)
+    window.on('close', saveState);
+    return window;
+}
+/**
+ * Parses the features string into a set of options.
+ * @param features - The features string to parse.
+ * @returns The parsed options.
+ */
+export function parseFeatures(features) {
+    const options = {};
+    if (!features)
+        return options; // Return empty object if no features provided
+    // Split features string and process each key-value pair
+    features.split(',').forEach(feature => {
+        const [key, ...valueParts] = feature.trim().split('=');
+        const value = valueParts.join('='); // Rejoin in case value contains '='
+        if (!key)
+            return; // Skip invalid pairs
+        switch (key.toLowerCase()) {
+            case 'width':
+                options.width = parseInt(value, 10) || 1920;
+                break;
+            case 'height':
+                options.height = parseInt(value, 10) || 1080;
+                break;
+            case 'fullscreen':
+                options.fullscreen = value === '1' || value === 'true';
+                break;
+            case 'title':
+                options.title = value;
+                break;
+            default:
+                console.log(`Unsupported feature: ${key}`);
+        }
+    });
+    return options;
+}

package/dist/src/templates/eslint.config.js

@@ -0,0 +1,43 @@
+import tsParser from '@typescript-eslint/parser';
+import noDefaultClassFields from './node_modules/genesys.js/eslint-rules/no-default-class-fields.js';
+import defaultGetterReturnType from './node_modules/genesys.js/eslint-rules/default-getter-return-type.js';
+import constructorTypeConsistency from './node_modules/genesys.js/eslint-rules/constructor-type-consistency.js';
+import noOverrideMethods from './node_modules/genesys.js/eslint-rules/no-override-methods.js';
+export default [
+    {
+        ignores: ['dist/**', '.engine/**', 'node_modules/**']
+    },
+    {
+        files: ['**/*.ts', '**/*.tsx'],
+        languageOptions: {
+            parser: tsParser,
+            parserOptions: {
+                project: ['./tsconfig.json']
+            }
+        },
+        plugins: {
+            'custom': {
+                rules: {
+                    'no-override-methods': noOverrideMethods,
+                    'no-default-class-fields': noDefaultClassFields,
+                    'default-getter-return-type': defaultGetterReturnType,
+                    'constructor-type-consistency': constructorTypeConsistency,
+                }
+            }
+        },
+        rules: {
+            'custom/no-override-methods': 'error',
+            'custom/no-default-class-fields': 'error',
+            'custom/default-getter-return-type': 'error',
+            'custom/constructor-type-consistency': 'error',
+        }
+    },
+    {
+        files: ['games/**/*.ts', 'games/**/*.tsx'],
+        rules: {
+            'no-restricted-imports': ['error', {
+                    patterns: ['../src/**', '!../src/index.js']
+                }]
+        }
+    }
+];

package/dist/src/templates/scripts/genesys/build-project.js

@@ -0,0 +1,42 @@
+import { getProjectRoot, isDev } from './common.js';
+const fileServerPort = !isDev ? 4000 : 4001;
+async function main() {
+    try {
+        const rootResponse = await fetch(`http://localhost:${fileServerPort}/`);
+        if (!rootResponse.ok) {
+            console.log('❌ Failed to talk to the Genesys SDK App, please make sure it is running and open the project in it!');
+            return;
+        }
+        const projectPath = getProjectRoot();
+        console.log(`🔨 Building project: ${projectPath} ...`);
+        const buildResponse = await fetch(`http://localhost:${fileServerPort}/api/build-project`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                projectPath,
+            }),
+        });
+        const responseJson = await buildResponse.json();
+        if (!buildResponse.ok) {
+            console.log('❌ Failed to build project, please check the console for errors!');
+            console.log(responseJson);
+            return;
+        }
+        /*
+        success: result.success,
+        message: result.message,
+        error: result.error
+        */
+        if (!responseJson.success) {
+            console.log(`❌ Failed to build project:\n - ${responseJson.error ?? responseJson.message}`);
+            return;
+        }
+        console.log(`✅ ${responseJson.message}`);
+    }
+    catch (error) {
+        console.log('❌ Failed to talk to the Genesys SDK App, please make sure it is running and open the project in it!');
+    }
+}
+main();