sliftutils 0.10.0 → 0.11.0

package/builders/dist/watch.ts.cache

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const runPromise_1 = require("socket-function/src/runPromise");
+const ws_1 = require("ws");
+const DEBOUNCE_DELAY_MS = 250;
+const DEFAULT_WATCH_PORT = 9876;
+async function main() {
+    var _a;
+    let args = process.argv.slice(2);
+    if (args.length < 2) {
+        console.error("Usage: watch <pattern1> [pattern2...] <command>");
+        console.error("Example: watch '*.ts' '*.tsx' 'yarn build'");
+        console.error("  - Patterns with wildcards must match the entire path");
+        console.error("  - Patterns without wildcards can appear anywhere in the path");
+        process.exit(1);
+    }
+    let patterns = args.slice(0, -1);
+    let command = args[args.length - 1];
+    // Read port configuration from package.json if available
+    let watchPort = DEFAULT_WATCH_PORT;
+    let currentDirectory = process.cwd();
+    let packageJsonPath = path_1.default.join(currentDirectory, "package.json");
+    if (fs_1.default.existsSync(packageJsonPath)) {
+        try {
+            let packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf8"));
+            if (((_a = packageJson.sliftWatch) === null || _a === void 0 ? void 0 : _a.port) !== undefined) {
+                watchPort = packageJson.sliftWatch.port;
+            }
+        }
+        catch (error) {
+            console.warn("Failed to read package.json:", error);
+        }
+    }
+    // Setup WebSocket server (unless disabled with port <= 0)
+    let wss;
+    if (watchPort > 0) {
+        wss = new ws_1.WebSocketServer({ port: watchPort });
+        console.log(`WebSocket server listening on port ${watchPort}. Set "sliftWatch.port" in package.json to change this. Set it to 0 to disable watching.`);
+        wss.on("connection", (ws) => {
+            console.log(`[${new Date().toLocaleTimeString()}] WebSocket client connected`);
+            ws.on("close", () => {
+                console.log(`[${new Date().toLocaleTimeString()}] WebSocket client disconnected`);
+            });
+        });
+    }
+    else {
+        console.log(`WebSocket server disabled (port <= 0 set in "sliftWatch.port" in package.json)`);
+    }
+    console.log(`Watching patterns: ${patterns.join(", ")}`);
+    console.log(`Running command: ${command}`);
+    console.log("");
+    let debounceTimer;
+    let isRunning = false;
+    let needsRerun = false;
+    async function executeCommand() {
+        if (isRunning) {
+            needsRerun = true;
+            return;
+        }
+        isRunning = true;
+        needsRerun = false;
+        try {
+            console.log(`\n[${new Date().toLocaleTimeString()}] Running: ${command}`);
+            await (0, runPromise_1.runPromise)(command);
+            console.log(`[${new Date().toLocaleTimeString()}] Completed successfully`);
+            // Notify all connected WebSocket clients
+            if (wss) {
+                wss.clients.forEach((client) => {
+                    if (client.readyState === 1) { // 1 = OPEN
+                        client.send(JSON.stringify({ type: "build-complete", success: true }));
+                    }
+                });
+            }
+        }
+        catch (error) {
+            console.error(`[${new Date().toLocaleTimeString()}] Error:`, error);
+            // Notify clients about build error
+            if (wss) {
+                wss.clients.forEach((client) => {
+                    if (client.readyState === 1) { // 1 = OPEN
+                        client.send(JSON.stringify({ type: "build-complete", success: false }));
+                    }
+                });
+            }
+        }
+        finally {
+            isRunning = false;
+            if (needsRerun) {
+                console.log(`[${new Date().toLocaleTimeString()}] Detected changes during build, running again...`);
+                await executeCommand();
+            }
+        }
+    }
+    function scheduleRun() {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(() => {
+            void executeCommand();
+        }, DEBOUNCE_DELAY_MS);
+    }
+    function matchesPattern(filePath, pattern) {
+        let relativePath = path_1.default.relative(currentDirectory, filePath).replace(/\\/g, "/").toLowerCase();
+        let lowerPattern = pattern.toLowerCase();
+        // If pattern contains wildcards, do full pattern matching
+        if (lowerPattern.includes("*")) {
+            // Convert wildcard pattern to regex
+            let regexPattern = lowerPattern
+                .replace(/\./g, "\\.") // Escape dots
+                .replace(/\*/g, ".*"); // * matches anything
+            let regex = new RegExp(`^${regexPattern}$`);
+            return regex.test(relativePath);
+        }
+        else {
+            // No wildcards - pattern can appear anywhere in the path
+            return relativePath.includes(lowerPattern);
+        }
+    }
+    function shouldWatch(filePath) {
+        for (let pattern of patterns) {
+            if (matchesPattern(filePath, pattern)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function watchDirectory(dir) {
+        try {
+            let watcher = fs_1.default.watch(dir, { recursive: true }, (eventType, filename) => {
+                if (!filename)
+                    return;
+                let fullPath = path_1.default.join(dir, filename);
+                if (shouldWatch(fullPath)) {
+                    console.log(`[${new Date().toLocaleTimeString()}] Detected change: ${path_1.default.relative(currentDirectory, fullPath)}`);
+                    scheduleRun();
+                }
+            });
+            watcher.on("error", (error) => {
+                console.error(`Watch error for ${dir}:`, error);
+            });
+        }
+        catch (error) {
+            console.error(`Failed to watch directory ${dir}:`, error);
+        }
+    }
+    // Start watching the current directory
+    watchDirectory(currentDirectory);
+    // Run the command once on startup
+    console.log("Initial build starting...");
+    await executeCommand();
+    console.log("\nWatching for changes... (Press Ctrl+C to exit)");
+}
+main().catch(error => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "0937822c58273597c61ad6bacc0d25bca521003adff6c2f8dde09261934dbf89"; */

package/builders/dist/webBuild.ts.cache

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+const fs_1 = __importDefault(require("fs"));
+const batching_1 = require("socket-function/src/batching");
+const bundleEntryCaller_1 = require("../bundler/bundleEntryCaller");
+const yargs_1 = __importDefault(require("yargs"));
+const format_1 = require("socket-function/src/formatting/format");
+const path_1 = __importDefault(require("path"));
+const fs_2 = require("../misc/fs");
+async function main() {
+    let time = Date.now();
+    let yargObj = (0, yargs_1.default)(process.argv)
+        .option("entryPoint", { type: "string", default: "./web/browser.tsx", desc: `Path to the entry point file` })
+        .option("indexHtml", { type: "string", default: "./web/index.html", desc: `Path to the index.html file` })
+        .option("assetsFolder", { type: "string", default: "./assets", desc: `Path to the assets folder` })
+        .option("outputFolder", { type: "string", default: "./build-web", desc: `Output folder` })
+        .argv || {};
+    // Wait for any async functions to load. 
+    await (0, batching_1.delay)(0);
+    let hasEntryPoint = fs_1.default.existsSync(yargObj.entryPoint);
+    let hasIndexHtml = fs_1.default.existsSync(yargObj.indexHtml);
+    let hasAssets = fs_1.default.existsSync(yargObj.assetsFolder);
+    if (!hasEntryPoint) {
+        throw new Error(`Entry point not found at ${yargObj.entryPoint}. Please specify the entry point with the --entryPoint option.`);
+    }
+    await fs_1.default.promises.mkdir(yargObj.outputFolder, { recursive: true });
+    await (0, bundleEntryCaller_1.bundleEntryCaller)({
+        entryPoint: yargObj.entryPoint,
+        outputFolder: yargObj.outputFolder,
+    });
+    // Collect all files to copy
+    let filesToCopy = [];
+    if (hasIndexHtml) {
+        filesToCopy.push(yargObj.indexHtml);
+    }
+    // Add assets folder files if it exists
+    if (hasAssets) {
+        for await (const file of (0, fs_2.getAllFiles)(yargObj.assetsFolder)) {
+            filesToCopy.push(file);
+        }
+    }
+    // Copy all files with timestamp checking
+    async function getTimestamp(filePath) {
+        try {
+            const stats = await fs_1.default.promises.stat(filePath);
+            return stats.mtimeMs;
+        }
+        catch (error) {
+            return 0;
+        }
+    }
+    let filesCopied = 0;
+    let root = path_1.default.resolve(".");
+    for (const file of filesToCopy) {
+        let sourcePath = path_1.default.resolve(file);
+        if (!fs_1.default.existsSync(sourcePath)) {
+            console.warn(`Warning: File not found: ${file}`);
+            continue;
+        }
+        let relativePath = path_1.default.relative(root, sourcePath);
+        let destPath = path_1.default.join(yargObj.outputFolder, relativePath);
+        let sourceTimestamp = await getTimestamp(sourcePath);
+        let destTimestamp = await getTimestamp(destPath);
+        if (sourceTimestamp > destTimestamp) {
+            await fs_1.default.promises.mkdir(path_1.default.dirname(destPath), { recursive: true });
+            await fs_1.default.promises.cp(sourcePath, destPath);
+            filesCopied++;
+        }
+    }
+    if (filesCopied > 0) {
+        console.log(`Copied ${filesCopied} changed files`);
+    }
+    let duration = Date.now() - time;
+    console.log(`Web build completed in ${(0, format_1.formatTime)(duration)}`);
+}
+main().catch(console.error).finally(() => process.exit());
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "dbe320fff55745cf35ac9154a827200b906b1ff20ae08ce997d403d7bc12b331"; */

package/bundler/dist/bundleEntry.ts.cache

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+const path_1 = __importDefault(require("path"));
+const bundler_1 = require("./bundler");
+const fs_1 = __importDefault(require("fs"));
+async function main() {
+    // NOTE: Using yargs added ~0.5s to the time to run this, and considering we run in ~1s... that's just too much 
+    let entryPoint = process.argv[2];
+    let outputFolder = process.argv[3];
+    if (!entryPoint) {
+        throw new Error("No entry point provided. Please use the --entryPoint option.");
+    }
+    if (!outputFolder) {
+        throw new Error("No output folder provided. Please use the --outputFolder option.");
+    }
+    // We prefer production, as this is what the bundler uses internally. This ensures that in the build and when run, we will have the same environment, which will result in the same requires being called. 
+    process.env.NODE_ENV = process.env.NODE_ENV || "production";
+    require(entryPoint);
+    let name = path_1.default.basename(entryPoint);
+    if (name.endsWith(".ts") || name.endsWith(".tsx")) {
+        name = name.split(".").slice(0, -1).join(".");
+    }
+    name += ".js";
+    let modules = Object.values(require.cache).filter(x => (x === null || x === void 0 ? void 0 : x.id) !== module.id);
+    let bundled = await (0, bundler_1.bundle)({
+        modules,
+        rootPath: path_1.default.resolve("."),
+        entryPoints: [entryPoint],
+    });
+    let finalPath = `${outputFolder}/${name}`;
+    let tempPath = `${finalPath}.tmp`;
+    try {
+        await fs_1.default.promises.writeFile(tempPath, bundled.bundle);
+        await fs_1.default.promises.rename(tempPath, finalPath);
+    }
+    finally {
+        try {
+            await fs_1.default.promises.unlink(tempPath);
+        }
+        catch (_a) { }
+    }
+}
+main().catch(console.error).finally(() => process.exit());
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "d70138531807b6285429b933bd406c64fe12f21719b5dfd33ea2d30d9dfdf03f"; */

package/bundler/dist/bundleEntryCaller.ts.cache

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.bundleEntryCaller = void 0;
+const runPromise_1 = require("socket-function/src/runPromise");
+const path_1 = __importDefault(require("path"));
+async function bundleEntryCaller(config) {
+    let { entryPoint, outputFolder } = config;
+    entryPoint = path_1.default.resolve(entryPoint).replace(/\\/g, "/");
+    outputFolder = path_1.default.resolve(outputFolder).replace(/\\/g, "/");
+    let bundleEntryPath = path_1.default.resolve(__dirname, "bundleEntry.ts").replace(/\\/g, "/");
+    await (0, runPromise_1.runPromise)(`node -r ./node_modules/typenode/index.js ${JSON.stringify(bundleEntryPath)} ${JSON.stringify(entryPoint)} ${JSON.stringify(outputFolder)}`);
+}
+exports.bundleEntryCaller = bundleEntryCaller;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVuZGxlRW50cnlDYWxsZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJidW5kbGVFbnRyeUNhbGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFDQSwrREFBNEQ7QUFDNUQsZ0RBQXdCO0FBRWpCLEtBQUssVUFBVSxpQkFBaUIsQ0FBQyxNQUd2QztJQUNHLElBQUksRUFBRSxVQUFVLEVBQUUsWUFBWSxFQUFFLEdBQUcsTUFBTSxDQUFDO0lBQzFDLFVBQVUsR0FBRyxjQUFJLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDMUQsWUFBWSxHQUFHLGNBQUksQ0FBQyxPQUFPLENBQUMsWUFBWSxDQUFDLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQztJQUM5RCxJQUFJLGVBQWUsR0FBRyxjQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDcEYsTUFBTSxJQUFBLHVCQUFVLEVBQUMsNENBQTRDLElBQUksQ0FBQyxTQUFTLENBQUMsZUFBZSxDQUFDLElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLFlBQVksQ0FBQyxFQUFFLENBQUMsQ0FBQztBQUNsSyxDQUFDO0FBVEQsOENBU0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgY2hpbGRfcHJvY2VzcyBmcm9tIFwiY2hpbGRfcHJvY2Vzc1wiO1xuaW1wb3J0IHsgcnVuUHJvbWlzZSB9IGZyb20gXCJzb2NrZXQtZnVuY3Rpb24vc3JjL3J1blByb21pc2VcIjtcbmltcG9ydCBwYXRoIGZyb20gXCJwYXRoXCI7XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBidW5kbGVFbnRyeUNhbGxlcihjb25maWc6IHtcbiAgICBlbnRyeVBvaW50OiBzdHJpbmc7XG4gICAgb3V0cHV0Rm9sZGVyOiBzdHJpbmc7XG59KSB7XG4gICAgbGV0IHsgZW50cnlQb2ludCwgb3V0cHV0Rm9sZGVyIH0gPSBjb25maWc7XG4gICAgZW50cnlQb2ludCA9IHBhdGgucmVzb2x2ZShlbnRyeVBvaW50KS5yZXBsYWNlKC9cXFxcL2csIFwiL1wiKTtcbiAgICBvdXRwdXRGb2xkZXIgPSBwYXRoLnJlc29sdmUob3V0cHV0Rm9sZGVyKS5yZXBsYWNlKC9cXFxcL2csIFwiL1wiKTtcbiAgICBsZXQgYnVuZGxlRW50cnlQYXRoID0gcGF0aC5yZXNvbHZlKF9fZGlybmFtZSwgXCJidW5kbGVFbnRyeS50c1wiKS5yZXBsYWNlKC9cXFxcL2csIFwiL1wiKTtcbiAgICBhd2FpdCBydW5Qcm9taXNlKGBub2RlIC1yIC4vbm9kZV9tb2R1bGVzL3R5cGVub2RlL2luZGV4LmpzICR7SlNPTi5zdHJpbmdpZnkoYnVuZGxlRW50cnlQYXRoKX0gJHtKU09OLnN0cmluZ2lmeShlbnRyeVBvaW50KX0gJHtKU09OLnN0cmluZ2lmeShvdXRwdXRGb2xkZXIpfWApO1xufVxuIl19
+ /* _JS_SOURCE_HASH = "8dea0b7e27180883c24b882d7e2ccb0e521aee4fa0e8ea430fbb1be4a424a292"; */