npm - sliftutils - Versions diffs - 0.9.0 → 0.11.0 - Mend

sliftutils 0.9.0 → 0.11.0

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 (73) hide show

package/.cursorrules +2 -0
package/.gitignore +38 -0
package/assets/icon128.png +0 -0
package/assets/icon16.png +0 -0
package/assets/icon48.png +0 -0
package/build-electron/assets/icon128.png +0 -0
package/build-electron/assets/icon16.png +0 -0
package/build-electron/assets/icon48.png +0 -0
package/build-electron/electron/electronIndex.html +12 -0
package/build-electron/electronMain.js +5185 -0
package/build-electron/electronRenderer.js +20852 -0
package/build-extension/assets/icon128.png +0 -0
package/build-extension/assets/icon16.png +0 -0
package/build-extension/assets/icon48.png +0 -0
package/build-extension/extBackground.js +5246 -0
package/build-extension/extContentScript.js +5243 -0
package/build-extension/manifest.json +29 -0
package/build-nodejs/server.js +198610 -0
package/build-web/assets/icon128.png +0 -0
package/build-web/assets/icon16.png +0 -0
package/build-web/assets/icon48.png +0 -0
package/build-web/browser.js +199266 -0
package/build-web/web/index.html +32 -0
package/builders/dist/electronBuild.ts.cache +105 -0
package/builders/dist/extensionBuild.ts.cache +146 -0
package/builders/dist/generateIndexDts.ts.cache +74 -0
package/builders/dist/hotReload.ts.cache +93 -0
package/builders/dist/nodeJSBuild.ts.cache +29 -0
package/builders/dist/watch.ts.cache +163 -0
package/builders/dist/webBuild.ts.cache +81 -0
package/builders/generateIndexDts.ts +63 -0
package/bundler/dist/bundleEntry.ts.cache +48 -0
package/bundler/dist/bundleEntryCaller.ts.cache +18 -0
package/bundler/dist/bundleRequire.ts.cache +246 -0
package/bundler/dist/bundleWrapper.ts.cache +101 -0
package/bundler/dist/bundler.ts.cache +66 -0
package/bundler/dist/sourceMaps.ts.cache +210 -0
package/dist/electronMain.ts.cache +27 -0
package/dist/electronRenderer.tsx.cache +62 -0
package/electron/dist/electronMain.ts.cache +26 -0
package/electron/dist/electronRenderer.tsx.cache +64 -0
package/extension/dist/extBackground.ts.cache +20 -0
package/extension/dist/extContentScript.ts.cache +17 -0
package/index.d.ts +46 -0
package/misc/dist/environment.ts.cache +50 -0
package/misc/dist/fs.ts.cache +29 -0
package/misc/environment.d.ts +8 -0
package/misc/fs.d.ts +1 -0
package/misc/getSecret.d.ts +8 -0
package/misc/getSecret.ts +0 -4
package/misc/types.d.ts +1 -0
package/misc/zip.d.ts +7 -0
package/nodejs/dist/exampleFile.ts.cache +11 -0
package/nodejs/dist/server.ts.cache +15 -0
package/package.json +8 -3
package/render-utils/SyncedController.d.ts +1 -0
package/render-utils/dist/observer.tsx.cache +33 -0
package/storage/dist/CachedStorage.ts.cache +31 -0
package/storage/dist/DelayedStorage.ts.cache +35 -0
package/storage/dist/DiskCollection.ts.cache +241 -0
package/storage/dist/FileFolderAPI.tsx.cache +345 -0
package/storage/dist/IndexedDBFileFolderAPI.ts.cache +142 -0
package/storage/dist/JSONStorage.ts.cache +38 -0
package/storage/dist/PendingManager.tsx.cache +73 -0
package/storage/dist/PendingStorage.ts.cache +49 -0
package/storage/dist/PrivateFileSystemStorage.ts.cache +178 -0
package/storage/dist/StorageObservable.ts.cache +120 -0
package/storage/dist/TransactionStorage.ts.cache +421 -0
package/storage/dist/fileSystemPointer.ts.cache +77 -0
package/tsconfig.declarations.json +3 -1
package/web/dist/browser.tsx.cache +66 -0
package/yarn.lock +1752 -0
package/builders/generateIndexDts.js +0 -50

package/build-web/web/index.html ADDED Viewed

@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Web App</title>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <style>
+        * {
+            box-sizing: border-box;
+            overflow-wrap: break-word;
+            word-wrap: break-word;
+            word-break: break-word;
+        }
+        body {
+            margin: 0px;
+            padding: 0px;
+            background: hsl(0, 0%, 7%);
+            color: hsl(0, 0%, 100%);
+            font-family: 'Inter', system-ui, -apple-system, Segoe UI, Roboto, 'Helvetica Neue', Arial, 'Noto Sans', 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol', sans-serif;
+        }
+        body, button, textarea {
+            font-family: Inter;
+            font-size: 12px;
+        }
+    </style>
+</head>
+<body>
+    <div id="app"></div>
+    <script src="../browser.js"></script>
+</body>
+</html>

package/builders/dist/electronBuild.ts.cache ADDED Viewed

@@ -0,0 +1,105 @@
+"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");
+const logColors_1 = require("socket-function/src/formatting/logColors");
+async function main() {
+    // Check if Electron is installed
+    try {
+        require.resolve("electron");
+    }
+    catch (error) {
+        console.error("ERROR: Electron is not installed.");
+        console.error("");
+        console.error("Electron is too heavy to be included by default for non-electron projects. Please run:");
+        console.error((0, logColors_1.green)("yarn add electron"));
+        process.exit(1);
+    }
+    let time = Date.now();
+    let yargObj = (0, yargs_1.default)(process.argv)
+        .option("mainEntry", { type: "string", default: "./electron/electronMain.ts", desc: `Path to the main process entry point` })
+        .option("rendererEntry", { type: "string", default: "./electron/electronRenderer.tsx", desc: `Path to the renderer process entry point` })
+        .option("indexHtml", { type: "string", default: "./electron/electronIndex.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-electron", desc: `Output folder` })
+        .argv || {};
+    // Wait for any async functions to load.
+    await (0, batching_1.delay)(0);
+    let hasMainEntry = fs_1.default.existsSync(yargObj.mainEntry);
+    let hasRendererEntry = fs_1.default.existsSync(yargObj.rendererEntry);
+    let hasIndexHtml = fs_1.default.existsSync(yargObj.indexHtml);
+    let hasAssets = fs_1.default.existsSync(yargObj.assetsFolder);
+    if (!hasMainEntry) {
+        throw new Error(`Main process entry point not found at ${yargObj.mainEntry}. Please specify with the --mainEntry option.`);
+    }
+    if (!hasRendererEntry) {
+        throw new Error(`Renderer process entry point not found at ${yargObj.rendererEntry}. Please specify with the --rendererEntry option.`);
+    }
+    await fs_1.default.promises.mkdir(yargObj.outputFolder, { recursive: true });
+    // Build main and renderer processes in parallel
+    await Promise.all([
+        (0, bundleEntryCaller_1.bundleEntryCaller)({
+            entryPoint: yargObj.mainEntry,
+            outputFolder: yargObj.outputFolder,
+        }),
+        (0, bundleEntryCaller_1.bundleEntryCaller)({
+            entryPoint: yargObj.rendererEntry,
+            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(`Electron 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 = "c198b9f3055795f50d284069a0f26ef42cc4ff468b064cfe78076e0fefcadd28"; */

package/builders/dist/extensionBuild.ts.cache ADDED Viewed

@@ -0,0 +1,146 @@
+"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() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    let time = Date.now();
+    //todonext
+    // We need to build both the extBackground.ts and extContentScript.ts
+    // And copy the manifest.json
+    // AND copy everything in ./assets which has updated
+    let yargObj = (0, yargs_1.default)(process.argv)
+        .option("backgroundEntry", { type: "string", default: "./extension/extBackground.ts", desc: `Path to the entry point file` })
+        .option("contentEntry", { type: "string", default: "./extension/extContentScript.ts", desc: `Path to the entry point file` })
+        .option("manifestPath", { type: "string", default: "./extension/manifest.json", desc: `Path to the manifest.json file` })
+        .option("assetsFolder", { type: "string", default: "./assets", desc: `Path to the assets folder` })
+        .option("outputFolder", { type: "string", default: "./build-extension", desc: `Output folder` })
+        .argv || {};
+    // Wait for any async functions to load.
+    await (0, batching_1.delay)(0);
+    let hasBackgroundEntry = fs_1.default.existsSync(yargObj.backgroundEntry);
+    let hasContentEntry = fs_1.default.existsSync(yargObj.contentEntry);
+    let hasManifest = fs_1.default.existsSync(yargObj.manifestPath);
+    let hasAssets = fs_1.default.existsSync(yargObj.assetsFolder);
+    if (!hasBackgroundEntry && !hasContentEntry) {
+        throw new Error("No extension entry points found. Please specify at least one entry point with the --backgroundEntry or --contentEntry option. Or, create the default file at ./extBackground.ts or ./extContentScript.ts.");
+    }
+    if (!hasManifest) {
+        throw new Error("No manifest file found. Please specify the manifest file with the --manifestPath option. Or, create the default file at ./manifest.json.");
+    }
+    await fs_1.default.promises.mkdir("./build-extension", { recursive: true });
+    // Build background and content scripts in parallel
+    let bundlePromises = [];
+    if (hasBackgroundEntry) {
+        bundlePromises.push((0, bundleEntryCaller_1.bundleEntryCaller)({
+            entryPoint: yargObj.backgroundEntry,
+            outputFolder: yargObj.outputFolder,
+        }));
+    }
+    if (hasContentEntry) {
+        bundlePromises.push((0, bundleEntryCaller_1.bundleEntryCaller)({
+            entryPoint: yargObj.contentEntry,
+            outputFolder: yargObj.outputFolder,
+        }));
+    }
+    await Promise.all([
+        ...bundlePromises,
+        fs_1.default.promises.cp(yargObj.manifestPath, path_1.default.join(yargObj.outputFolder, "manifest.json"))
+    ]);
+    // Parse manifest and collect referenced files
+    let manifestContent = await fs_1.default.promises.readFile(yargObj.manifestPath, "utf-8");
+    let manifest = JSON.parse(manifestContent);
+    // Collect all files to copy
+    let filesToCopy = [];
+    // Helper to add icons (can be string or object of strings)
+    function addIconPaths(icon) {
+        if (!icon)
+            return;
+        if (typeof icon === "string") {
+            filesToCopy.push(icon);
+        }
+        else if (typeof icon === "object") {
+            for (const iconPath of Object.values(icon)) {
+                if (typeof iconPath === "string") {
+                    filesToCopy.push(iconPath);
+                }
+            }
+        }
+    }
+    // Add manifest-referenced files
+    if ((_a = manifest.action) === null || _a === void 0 ? void 0 : _a.default_popup)
+        filesToCopy.push(manifest.action.default_popup);
+    if ((_b = manifest.browser_action) === null || _b === void 0 ? void 0 : _b.default_popup)
+        filesToCopy.push(manifest.browser_action.default_popup);
+    if ((_c = manifest.page_action) === null || _c === void 0 ? void 0 : _c.default_popup)
+        filesToCopy.push(manifest.page_action.default_popup);
+    if (manifest.options_page)
+        filesToCopy.push(manifest.options_page);
+    if ((_d = manifest.options_ui) === null || _d === void 0 ? void 0 : _d.page)
+        filesToCopy.push(manifest.options_ui.page);
+    if (manifest.devtools_page)
+        filesToCopy.push(manifest.devtools_page);
+    if ((_e = manifest.sidebar_action) === null || _e === void 0 ? void 0 : _e.default_panel)
+        filesToCopy.push(manifest.sidebar_action.default_panel);
+    if ((_f = manifest.chrome_url_overrides) === null || _f === void 0 ? void 0 : _f.newtab)
+        filesToCopy.push(manifest.chrome_url_overrides.newtab);
+    if ((_g = manifest.chrome_url_overrides) === null || _g === void 0 ? void 0 : _g.bookmarks)
+        filesToCopy.push(manifest.chrome_url_overrides.bookmarks);
+    if ((_h = manifest.chrome_url_overrides) === null || _h === void 0 ? void 0 : _h.history)
+        filesToCopy.push(manifest.chrome_url_overrides.history);
+    // Add icons
+    addIconPaths(manifest.icons);
+    addIconPaths((_j = manifest.action) === null || _j === void 0 ? void 0 : _j.default_icon);
+    addIconPaths((_k = manifest.browser_action) === null || _k === void 0 ? void 0 : _k.default_icon);
+    addIconPaths((_l = manifest.page_action) === null || _l === void 0 ? void 0 : _l.default_icon);
+    // 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 assets`);
+    }
+    let duration = Date.now() - time;
+    console.log(`Extension 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 = "9a2ad461ccf4b8c8b3ad7052b4a38d002f5b1c97389602f23186edfd1211aba6"; */

package/builders/dist/generateIndexDts.ts.cache ADDED Viewed

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const FOLDERS_TO_INCLUDE = ["render-utils", "misc"];
+function getAllDtsFiles(dir, fileList = []) {
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            getAllDtsFiles(filePath, fileList);
+        }
+        else if (file.endsWith(".d.ts")) {
+            fileList.push(filePath);
+        }
+    }
+    return fileList;
+}
+function generateIndexDts() {
+    const allModules = [];
+    for (const folderName of FOLDERS_TO_INCLUDE) {
+        const folderPath = path.join(__dirname, "..", folderName);
+        if (!fs.existsSync(folderPath)) {
+            console.log(`Warning: Folder ${folderName} does not exist, skipping...`);
+            continue;
+        }
+        const dtsFiles = getAllDtsFiles(folderPath);
+        const modules = dtsFiles
+            .map(filePath => {
+            const relativePath = path.relative(folderPath, filePath);
+            const withoutExt = relativePath.replace(/\.d\.ts$/, "");
+            const modulePath = "sliftutils/" + folderName + "/" + withoutExt.replace(/\\/g, "/");
+            const content = fs.readFileSync(filePath, "utf8");
+            const indentedContent = content
+                .split("\n")
+                .map(line => line ? "    " + line : line)
+                .join("\n");
+            return `declare module "${modulePath}" {\n${indentedContent}\n}`;
+        });
+        allModules.push(...modules);
+    }
+    const sortedModules = allModules.sort().join("\n\n");
+    const outputPath = path.join(__dirname, "..", "index.d.ts");
+    const header = `// Auto-generated file. Do not edit manually.\n// Generated by: yarn generate-index-dts\n\n`;
+    fs.writeFileSync(outputPath, header + sortedModules + "\n", "utf8");
+    console.log(`Generated ${outputPath} with ${allModules.length} module declarations`);
+}
+generateIndexDts();
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "7aa0476717e0d99e8ee6eb241bcad9def77971b4a515d5c677dcfe761fb019dc"; */

package/builders/dist/hotReload.ts.cache ADDED Viewed

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.enableHotReloading = void 0;
+const HotReloadController_1 = require("socket-function/hot/HotReloadController");
+const environment_1 = require("../misc/environment");
+const DEFAULT_WATCH_PORT = 9876;
+async function enableHotReloading(config) {
+    if ((0, environment_1.isInChromeExtensionBackground)()) {
+        chromeExtensionBackgroundHotReload(config === null || config === void 0 ? void 0 : config.port);
+    }
+    else if ((0, environment_1.isInChromeExtensionContentScript)()) {
+        chromeExtensionContentScriptHotReload();
+    }
+    else if (typeof window !== "undefined" && typeof window.location && typeof window.location.reload === "function") {
+        // For most reloadable environments, just refresh
+        watchPortHotReload(config === null || config === void 0 ? void 0 : config.port, () => {
+            window.location.reload();
+        });
+    }
+    else {
+        (0, HotReloadController_1.watchFilesAndTriggerHotReloading)();
+    }
+}
+exports.enableHotReloading = enableHotReloading;
+function watchPortHotReload(port = DEFAULT_WATCH_PORT, onReload) {
+    let reconnectTimer;
+    let ws;
+    let everConnected = false;
+    function connect() {
+        try {
+            ws = new WebSocket(`ws://localhost:${port}`);
+            ws.onopen = () => {
+                console.log(`[Hot Reload] Connected to watch server on port ${port}`);
+                everConnected = true;
+            };
+            ws.onmessage = (event) => {
+                try {
+                    let data = JSON.parse(event.data);
+                    if (data.type === "build-complete" && data.success) {
+                        console.log("[Hot Reload] Build complete, reloading page...");
+                        onReload();
+                    }
+                }
+                catch (error) {
+                    console.error("[Hot Reload] Failed to parse message:", error);
+                }
+            };
+            ws.onerror = (error) => {
+                console.warn(`[Hot Reload] WebSocket error. Use the watch script to enable watching.`);
+            };
+            ws.onclose = () => {
+                if (everConnected) {
+                    console.log("[Hot Reload] Disconnected from watch server, reconnecting in 2s...");
+                    if (reconnectTimer) {
+                        clearTimeout(reconnectTimer);
+                    }
+                    reconnectTimer = setTimeout(() => {
+                        connect();
+                    }, 2000);
+                }
+            };
+        }
+        catch (error) {
+            console.error("[Hot Reload] Failed to connect:", error);
+        }
+    }
+    connect();
+}
+function chromeExtensionBackgroundHotReload(port = DEFAULT_WATCH_PORT) {
+    chrome.runtime.onConnect.addListener((port) => {
+        if (port.name === "hotReload") {
+            // Keep the port open so content scripts can detect when we disconnect
+        }
+    });
+    watchPortHotReload(port, () => {
+        chrome.runtime.reload();
+    });
+}
+function chromeExtensionContentScriptHotReload() {
+    let port = chrome.runtime.connect({ name: "hotReload" });
+    let startTime = Date.now();
+    port.onDisconnect.addListener(() => {
+        let timeToFail = Date.now() - startTime;
+        if (timeToFail > 10000) {
+            console.warn("[Hot Reload] Could not connect to background script. Make sure the background script calls enableHotReloading().");
+            return;
+        }
+        console.log("[Hot Reload] Extension reloaded, refreshing page...");
+        window.location.reload();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hotReload.js","sourceRoot":"","sources":["hotReload.ts"],"names":[],"mappings":";;;AAAA,iFAA2F;AAC3F,qDAAwI;AAExI,MAAM,kBAAkB,GAAG,IAAI,CAAC;AAEzB,KAAK,UAAU,kBAAkB,CAAC,MAExC;IACG,IAAI,IAAA,2CAA6B,GAAE,EAAE,CAAC;QAClC,kCAAkC,CAAC,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,IAAI,CAAC,CAAC;IACrD,CAAC;SAAM,IAAI,IAAA,8CAAgC,GAAE,EAAE,CAAC;QAC5C,qCAAqC,EAAE,CAAC;IAC5C,CAAC;SAAM,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,MAAM,CAAC,QAAQ,IAAI,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QACjH,iDAAiD;QACjD,kBAAkB,CAAC,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,IAAI,EAAE,GAAG,EAAE;YAClC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;IACP,CAAC;SAAM,CAAC;QACJ,IAAA,sDAAgC,GAAE,CAAC;IACvC,CAAC;AACL,CAAC;AAfD,gDAeC;AAED,SAAS,kBAAkB,CAAC,IAAI,GAAG,kBAAkB,EAAE,QAAoB;IACvE,IAAI,cAAkC,CAAC;IACvC,IAAI,EAAyB,CAAC;IAE9B,IAAI,aAAa,GAAG,KAAK,CAAC;IAE1B,SAAS,OAAO;QACZ,IAAI,CAAC;YACD,EAAE,GAAG,IAAI,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC;YAE7C,EAAE,CAAC,MAAM,GAAG,GAAG,EAAE;gBACb,OAAO,CAAC,GAAG,CAAC,kDAAkD,IAAI,EAAE,CAAC,CAAC;gBACtE,aAAa,GAAG,IAAI,CAAC;YACzB,CAAC,CAAC;YAEF,EAAE,CAAC,SAAS,GAAG,CAAC,KAAK,EAAE,EAAE;gBACrB,IAAI,CAAC;oBACD,IAAI,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;oBAClC,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;wBACjD,OAAO,CAAC,GAAG,CAAC,gDAAgD,CAAC,CAAC;wBAC9D,QAAQ,EAAE,CAAC;oBACf,CAAC;gBACL,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACb,OAAO,CAAC,KAAK,CAAC,uCAAuC,EAAE,KAAK,CAAC,CAAC;gBAClE,CAAC;YACL,CAAC,CAAC;YAEF,EAAE,CAAC,OAAO,GAAG,CAAC,KAAK,EAAE,EAAE;gBACnB,OAAO,CAAC,IAAI,CAAC,wEAAwE,CAAC,CAAC;YAC3F,CAAC,CAAC;YAEF,EAAE,CAAC,OAAO,GAAG,GAAG,EAAE;gBACd,IAAI,aAAa,EAAE,CAAC;oBAChB,OAAO,CAAC,GAAG,CAAC,oEAAoE,CAAC,CAAC;oBAClF,IAAI,cAAc,EAAE,CAAC;wBACjB,YAAY,CAAC,cAAc,CAAC,CAAC;oBACjC,CAAC;oBACD,cAAc,GAAG,UAAU,CAAC,GAAG,EAAE;wBAC7B,OAAO,EAAE,CAAC;oBACd,CAAC,EAAE,IAAI,CAAQ,CAAC;gBACpB,CAAC;YACL,CAAC,CAAC;QACN,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,iCAAiC,EAAE,KAAK,CAAC,CAAC;QAC5D,CAAC;IACL,CAAC;IAED,OAAO,EAAE,CAAC;AACd,CAAC;AAED,SAAS,kCAAkC,CAAC,IAAI,GAAG,kBAAkB;IACjE,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,IAAI,EAAE,EAAE;QAC1C,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YAC5B,sEAAsE;QAC1E,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,kBAAkB,CAAC,IAAI,EAAE,GAAG,EAAE;QAC1B,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;IAC5B,CAAC,CAAC,CAAC;AACP,CAAC;AAED,SAAS,qCAAqC;IAC1C,IAAI,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;IAEzD,IAAI,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAE3B,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,GAAG,EAAE;QAC/B,IAAI,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;QACxC,IAAI,UAAU,GAAG,KAAK,EAAE,CAAC;YACrB,OAAO,CAAC,IAAI,CAAC,kHAAkH,CAAC,CAAC;YACjI,OAAO;QACX,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,qDAAqD,CAAC,CAAC;QACnE,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;IAC7B,CAAC,CAAC,CAAC;AACP,CAAC","sourcesContent":["import { watchFilesAndTriggerHotReloading } from \"socket-function/hot/HotReloadController\";\nimport { isInBrowser, isInChromeExtension, isInChromeExtensionBackground, isInChromeExtensionContentScript } from \"../misc/environment\";\n\nconst DEFAULT_WATCH_PORT = 9876;\n\nexport async function enableHotReloading(config?: {\n    port?: number;\n}) {\n    if (isInChromeExtensionBackground()) {\n        chromeExtensionBackgroundHotReload(config?.port);\n    } else if (isInChromeExtensionContentScript()) {\n        chromeExtensionContentScriptHotReload();\n    } else if (typeof window !== \"undefined\" && typeof window.location && typeof window.location.reload === \"function\") {\n        // For most reloadable environments, just refresh\n        watchPortHotReload(config?.port, () => {\n            window.location.reload();\n        });\n    } else {\n        watchFilesAndTriggerHotReloading();\n    }\n}\n\nfunction watchPortHotReload(port = DEFAULT_WATCH_PORT, onReload: () => void) {\n    let reconnectTimer: number | undefined;\n    let ws: WebSocket | undefined;\n\n    let everConnected = false;\n\n    function connect() {\n        try {\n            ws = new WebSocket(`ws://localhost:${port}`);\n\n            ws.onopen = () => {\n                console.log(`[Hot Reload] Connected to watch server on port ${port}`);\n                everConnected = true;\n            };\n\n            ws.onmessage = (event) => {\n                try {\n                    let data = JSON.parse(event.data);\n                    if (data.type === \"build-complete\" && data.success) {\n                        console.log(\"[Hot Reload] Build complete, reloading page...\");\n                        onReload();\n                    }\n                } catch (error) {\n                    console.error(\"[Hot Reload] Failed to parse message:\", error);\n                }\n            };\n\n            ws.onerror = (error) => {\n                console.warn(`[Hot Reload] WebSocket error. Use the watch script to enable watching.`);\n            };\n\n            ws.onclose = () => {\n                if (everConnected) {\n                    console.log(\"[Hot Reload] Disconnected from watch server, reconnecting in 2s...\");\n                    if (reconnectTimer) {\n                        clearTimeout(reconnectTimer);\n                    }\n                    reconnectTimer = setTimeout(() => {\n                        connect();\n                    }, 2000) as any;\n                }\n            };\n        } catch (error) {\n            console.error(\"[Hot Reload] Failed to connect:\", error);\n        }\n    }\n\n    connect();\n}\n\nfunction chromeExtensionBackgroundHotReload(port = DEFAULT_WATCH_PORT) {\n    chrome.runtime.onConnect.addListener((port) => {\n        if (port.name === \"hotReload\") {\n            // Keep the port open so content scripts can detect when we disconnect\n        }\n    });\n\n    watchPortHotReload(port, () => {\n        chrome.runtime.reload();\n    });\n}\n\nfunction chromeExtensionContentScriptHotReload() {\n    let port = chrome.runtime.connect({ name: \"hotReload\" });\n\n    let startTime = Date.now();\n\n    port.onDisconnect.addListener(() => {\n        let timeToFail = Date.now() - startTime;\n        if (timeToFail > 10000) {\n            console.warn(\"[Hot Reload] Could not connect to background script. Make sure the background script calls enableHotReloading().\");\n            return;\n        }\n        console.log(\"[Hot Reload] Extension reloaded, refreshing page...\");\n        window.location.reload();\n    });\n}"]}
+ /* _JS_SOURCE_HASH = "f5fb4d27159854e9af81d26046814c288cd00447b65fd189e9db57ee849baaf2"; */

package/builders/dist/nodeJSBuild.ts.cache ADDED Viewed

@@ -0,0 +1,29 @@
+"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");
+async function main() {
+    let time = Date.now();
+    let yargObj = (0, yargs_1.default)(process.argv)
+        .option("entryPoint", { type: "string", default: "./nodejs/server.ts", desc: `Path to the entry point file` })
+        .option("outputFolder", { type: "string", default: "./build-nodejs", desc: `Output folder` })
+        .argv || {};
+    // Wait for any async functions to load.
+    await (0, batching_1.delay)(0);
+    await fs_1.default.promises.mkdir("./build-nodejs", { recursive: true });
+    await (0, bundleEntryCaller_1.bundleEntryCaller)({
+        entryPoint: yargObj.entryPoint,
+        outputFolder: yargObj.outputFolder,
+    });
+    let duration = Date.now() - time;
+    console.log(`NodeJS 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 = "f90af51dd8c3ad3f23ef4090178a331552cc3fc96ab7a839a5ac8972b37229fc"; */