@evitcastudio/kit 3.2.1 → 3.3.0

package/lib/cli/resource-builder.js

@@ -1,6 +1,7 @@
-import { promises as fs, watch as fsWatch, existsSync } from 'fs';
-import { join, extname, basename, resolve } from 'path';
+import { promises as fs, existsSync } from 'fs';
+import { join, extname, basename, resolve, relative } from 'path';
 import chalk from 'chalk';
+import { watch as chokidarWatch } from 'chokidar';
 import { v4 as uuidv4 } from 'uuid';
 import { VYI } from '../vendor/vyi';
 import { bundleApp } from './app-bundler';
@@ -100,9 +101,22 @@ async function processDirectory(pDirectoryPath) {
 function isValidExtension(pExtension) {
     return VALID_EXTENSIONS.includes(pExtension);
 }
+// Engine resource formats handled by Vylocity obfuscation
+const ENGINE_EXTENSIONS = ['vyint', 'vyi', 'vym', 'vymac'];
+/**
+ * Checks if a file extension is a Vylocity engine binary/definition format.
+ * @param pExtension - The file extension to test.
+ * @returns True if the extension is an engine format.
+ */
+function isEngineExtension(pExtension) {
+    return ENGINE_EXTENSIONS.includes(pExtension);
+}
 /**
  * Recursively copies a directory to destination, preserving subdirectories and files.
- * Ignores engine resource files that are already handled by Vylocity obfuscation.
+ * Ignores engine resource files (vyint, vyi, vym, vymac) that are handled by Vylocity obfuscation,
+ * while ensuring media and custom assets (sounds, images, fonts, json) retain their structure.
+ * @param pSourceDir - The source directory to copy.
+ * @param pDestDir - The target destination directory.
  */
 async function mirrorDirectory(pSourceDir, pDestDir) {
     const entries = await fs.readdir(pSourceDir, { withFileTypes: true });
@@ -115,9 +129,10 @@ async function mirrorDirectory(pSourceDir, pDestDir) {
         }
         else {
             const ext = extname(entry.name).slice(1);
-            // Only copy non-engine files (images, custom JSON, fonts, etc.)
-            if (!isValidExtension(ext)) {
-                await fs.copyFile(srcPath, destPath);
+            // Copy all assets except internal Vylocity engine binary formats
+            if (!isEngineExtension(ext)) {
+                const data = await fs.readFile(srcPath);
+                await fs.writeFile(destPath, data);
             }
         }
     }
@@ -361,7 +376,11 @@ async function clearResourceTypeDirectories(pBaseDirectory) {
 async function copyFile(pSource, pDestinationDir, pNewName) {
     try {
         await fs.mkdir(pDestinationDir, { recursive: true });
-        await fs.copyFile(pSource, join(pDestinationDir, pNewName));
+        // Use readFile + writeFile instead of fs.copyFile to avoid macOS APFS
+        // clone operations, which emit phantom FSEvents on the source file and
+        // cause external editors (e.g. Viewer) to falsely detect modifications.
+        const data = await fs.readFile(pSource);
+        await fs.writeFile(join(pDestinationDir, pNewName), data);
     }
     catch (pError) {
         logError(`[Error] Copying file ${pSource}: ${pError}`);
@@ -417,39 +436,139 @@ async function runBuild() {
  */
 async function runWatch() {
     await runBuild();
-    console.log(chalk.cyan(`\n👀 Watching for changes in: ${chalk.bold(resourceInDirectory)}`));
+    const pathsToWatch = [];
+    if (existsSync(resourceInDirectory)) {
+        pathsToWatch.push(resourceInDirectory);
+    }
+    const srcDir = join(projectRootDirectory, 'src');
+    if (shouldBundleApp && existsSync(srcDir) && srcDir !== resourceInDirectory) {
+        pathsToWatch.push(srcDir);
+    }
+    const displayPaths = pathsToWatch
+        .map(p => chalk.bold(relative(projectRootDirectory, p) || p))
+        .join(', ');
+    console.log(chalk.cyan(`\nWatching for changes in: ${displayPaths}`));
     let debounceTimer = null;
+    let isRebuilding = false;
+    let queuedChange = null;
     const triggerRebuild = (pFilename) => {
         if (debounceTimer)
             clearTimeout(debounceTimer);
         debounceTimer = setTimeout(async () => {
-            console.log(chalk.dim(`\nFile changed: ${pFilename}, rebuilding...`));
-            await runBuild();
+            if (isRebuilding) {
+                queuedChange = pFilename;
+                return;
+            }
+            isRebuilding = true;
+            try {
+                console.log(chalk.dim(`\nFile changed: ${pFilename}, rebuilding...`));
+                await runBuild();
+            }
+            finally {
+                isRebuilding = false;
+                if (queuedChange) {
+                    const next = queuedChange;
+                    queuedChange = null;
+                    triggerRebuild(next);
+                }
+            }
         }, 150);
     };
-    const watchers = [];
-    if (existsSync(resourceInDirectory)) {
-        const resWatcher = fsWatch(resourceInDirectory, { recursive: true }, (_eventType, pFilename) => {
-            if (pFilename)
-                triggerRebuild(pFilename);
-        });
-        watchers.push(resWatcher);
-    }
-    const srcDir = join(projectRootDirectory, 'src');
-    if (shouldBundleApp && existsSync(srcDir) && srcDir !== resourceInDirectory) {
-        const srcWatcher = fsWatch(srcDir, { recursive: true }, (_eventType, pFilename) => {
-            if (!pFilename)
-                return;
-            // Ignore resources folder if inside src to prevent double triggers
-            if (pFilename.startsWith('resources'))
-                return;
-            triggerRebuild(pFilename);
-        });
-        watchers.push(srcWatcher);
+    const normalizedOutDir = resourceOutDirectory ? resourceOutDirectory.replace(/\\/g, '/') : '';
+    const isIgnored = (pPath) => {
+        const normalized = pPath.replace(/\\/g, '/');
+        // Ignore output directory
+        if (normalizedOutDir && (normalized === normalizedOutDir || normalized.startsWith(`${normalizedOutDir}/`))) {
+            return true;
+        }
+        // Ignore VCS and dependency folders
+        if (/(^|[/\\])(\.git|node_modules|\.DS_Store|Thumbs\.db)($|[/\\])/.test(normalized)) {
+            return true;
+        }
+        // Ignore vendor directory (precompiled/static vendor assets)
+        if (/(^|[/\\])vendor([/\\]|$)/.test(normalized)) {
+            return true;
+        }
+        // Ignore sourcemaps
+        if (normalized.endsWith('.map')) {
+            return true;
+        }
+        // Ignore generated manifest metadata files in project root
+        if (normalized.endsWith('resource.json') ||
+            normalized.endsWith('bounds.json') ||
+            normalized.endsWith('icon-points.json') ||
+            normalized.endsWith('sizes.json')) {
+            return true;
+        }
+        return false;
+    };
+    // Track known file modification times and sizes to eliminate phantom change events from copy/read operations
+    const fileStats = new Map();
+    const recordFileStat = async (pFilePath) => {
+        try {
+            const stats = await fs.stat(pFilePath);
+            if (stats.isFile()) {
+                fileStats.set(resolve(pFilePath), { mtime: stats.mtimeMs, size: stats.size });
+            }
+        }
+        catch {
+            // Ignored
+        }
+    };
+    const primeDirectoryStats = async (pDirPath) => {
+        try {
+            const entries = await fs.readdir(pDirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(pDirPath, entry.name);
+                if (isIgnored(fullPath))
+                    continue;
+                if (entry.isDirectory()) {
+                    await primeDirectoryStats(fullPath);
+                }
+                else if (entry.isFile()) {
+                    await recordFileStat(fullPath);
+                }
+            }
+        }
+        catch {
+            // Ignored
+        }
+    };
+    for (const p of pathsToWatch) {
+        await primeDirectoryStats(p);
     }
-    process.on('SIGINT', () => {
-        for (const w of watchers)
-            w.close();
+    const watcher = chokidarWatch(pathsToWatch, {
+        ignored: isIgnored,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 100,
+            pollInterval: 50
+        }
+    });
+    watcher.on('all', async (event, filePath) => {
+        if (event === 'addDir' || event === 'unlinkDir')
+            return;
+        const absPath = resolve(filePath);
+        if (event === 'unlink') {
+            fileStats.delete(absPath);
+            const relativePath = relative(projectRootDirectory, filePath).replace(/\\/g, '/');
+            triggerRebuild(relativePath);
+            return;
+        }
+        // Verify mtime or size actually changed to eliminate phantom OS events
+        const stats = await fs.stat(absPath).catch(() => null);
+        if (!stats)
+            return;
+        const prev = fileStats.get(absPath);
+        if (prev && prev.mtime === stats.mtimeMs && prev.size === stats.size) {
+            return;
+        }
+        fileStats.set(absPath, { mtime: stats.mtimeMs, size: stats.size });
+        const relativePath = relative(projectRootDirectory, filePath).replace(/\\/g, '/');
+        triggerRebuild(relativePath);
+    });
+    process.on('SIGINT', async () => {
+        await watcher.close();
         process.exit(0);
     });
 }

package/lib/cli-runner.cjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+// Target the compiled Bun bundle
+const cliScript = path.join(__dirname, 'bundle', 'cli', 'cli.js');
+
+// If currently running under Bun, import and execute directly
+if (typeof Bun !== 'undefined') {
+    import(cliScript);
+} else {
+    // Running under Node.js -> delegate to Bun runtime
+    const result = spawnSync('bun', [cliScript, ...process.argv.slice(2)], {
+        stdio: 'inherit',
+        shell: process.platform === 'win32'
+    });
+    process.exit(result.status ?? 0);
+}