windmill-utils-internal 1.3.2 → 1.3.4

package/dist/cjs/config/config.js

@@ -0,0 +1,231 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WINDMILL_ACTIVE_INSTANCE_FILE = exports.INSTANCES_CONFIG_FILE = exports.WINDMILL_WORKSPACE_CONFIG_FILE = exports.WINDMILL_ACTIVE_WORKSPACE_FILE = exports.WINDMILL_CONFIG_DIR = void 0;
+exports.getBaseConfigDir = getBaseConfigDir;
+exports.getConfigDirPath = getConfigDirPath;
+exports.getWorkspaceConfigFilePath = getWorkspaceConfigFilePath;
+exports.getActiveWorkspaceConfigFilePath = getActiveWorkspaceConfigFilePath;
+exports.getInstancesConfigFilePath = getInstancesConfigFilePath;
+exports.getActiveInstanceFilePath = getActiveInstanceFilePath;
+// Runtime detection
+// @ts-ignore - Cross-platform runtime detection
+const isDeno = typeof Deno !== "undefined";
+// @ts-ignore - Cross-platform runtime detection  
+const isNode = typeof process !== "undefined" && process.versions?.node;
+exports.WINDMILL_CONFIG_DIR = "windmill";
+exports.WINDMILL_ACTIVE_WORKSPACE_FILE = "activeWorkspace";
+exports.WINDMILL_WORKSPACE_CONFIG_FILE = "remotes.ndjson";
+exports.INSTANCES_CONFIG_FILE = "instances.ndjson";
+exports.WINDMILL_ACTIVE_INSTANCE_FILE = "activeInstance";
+// Cross-platform environment variable access
+function getEnv(key) {
+    if (isDeno) {
+        // @ts-ignore - Deno API
+        return Deno.env.get(key);
+    }
+    else {
+        // @ts-ignore - Node API
+        return process.env[key];
+    }
+}
+// Cross-platform OS detection with normalization
+function getOS() {
+    if (isDeno) {
+        // @ts-ignore - Deno API
+        return Deno.build.os;
+    }
+    else if (isNode) {
+        // @ts-ignore - Node API
+        const platform = process.platform;
+        switch (platform) {
+            case "linux": return "linux";
+            case "darwin": return "darwin";
+            case "win32": return "windows"; // Normalize win32 to windows
+            default: return null;
+        }
+    }
+    return null;
+}
+// Cross-platform file system operations
+async function stat(path) {
+    if (isDeno) {
+        // @ts-ignore - Deno API
+        return await Deno.stat(path);
+    }
+    else {
+        // @ts-ignore - Node API
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        return await fs.stat(path);
+    }
+}
+async function mkdir(path, options) {
+    if (isDeno) {
+        // @ts-ignore - Deno API
+        await Deno.mkdir(path, options);
+    }
+    else {
+        // @ts-ignore - Node API
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        await fs.mkdir(path, options);
+    }
+}
+function throwIfNotDirectory(fileInfo) {
+    if (!fileInfo.isDirectory) {
+        throw new Error("Path is not a directory");
+    }
+}
+function config_dir() {
+    const os = getOS();
+    switch (os) {
+        case "linux": {
+            const xdg = getEnv("XDG_CONFIG_HOME");
+            if (xdg)
+                return xdg;
+            const home = getEnv("HOME");
+            if (home)
+                return `${home}/.config`;
+            break;
+        }
+        case "darwin": {
+            const home = getEnv("HOME");
+            if (home)
+                return `${home}/Library/Preferences`;
+            break;
+        }
+        case "windows":
+            return getEnv("APPDATA") ?? null;
+    }
+    return null;
+}
+function tmp_dir() {
+    const os = getOS();
+    switch (os) {
+        case "linux": {
+            const xdg = getEnv("XDG_RUNTIME_DIR");
+            if (xdg)
+                return `${xdg}-/tmp`;
+            const tmpDir = getEnv("TMPDIR");
+            if (tmpDir)
+                return tmpDir;
+            const tempDir = getEnv("TEMP");
+            if (tempDir)
+                return tempDir;
+            const tmp = getEnv("TMP");
+            if (tmp)
+                return tmp;
+            return "/var/tmp";
+        }
+        case "darwin":
+            return getEnv("TMPDIR") ?? null;
+        case "windows":
+            return getEnv("TMP") ?? getEnv("TEMP") ?? null;
+    }
+    return null;
+}
+async function ensureDir(dir) {
+    try {
+        const fileInfo = await stat(dir);
+        throwIfNotDirectory(fileInfo);
+        return;
+    }
+    catch (err) {
+        // Check for file not found error in cross-platform way
+        if (isDeno) {
+            // @ts-ignore - Deno API
+            if (!(err instanceof Deno.errors.NotFound)) {
+                throw err;
+            }
+        }
+        else {
+            // Node.js error codes
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+        }
+    }
+    // The dir doesn't exist. Create it.
+    // This can be racy. So we catch AlreadyExists and check stat again.
+    try {
+        await mkdir(dir, { recursive: true });
+    }
+    catch (err) {
+        // Check for already exists error in cross-platform way
+        if (isDeno) {
+            // @ts-ignore - Deno API
+            if (!(err instanceof Deno.errors.AlreadyExists)) {
+                throw err;
+            }
+        }
+        else {
+            // Node.js error codes
+            if (err.code !== 'EEXIST') {
+                throw err;
+            }
+        }
+        const fileInfo = await stat(dir);
+        throwIfNotDirectory(fileInfo);
+    }
+}
+async function getBaseConfigDir(configDirOverride) {
+    const baseDir = configDirOverride ??
+        getEnv("WMILL_CONFIG_DIR") ??
+        config_dir() ??
+        tmp_dir() ??
+        "/tmp/";
+    return baseDir;
+}
+async function getConfigDirPath(configDirOverride) {
+    const baseDir = await getBaseConfigDir(configDirOverride);
+    const store = baseDir + `/${exports.WINDMILL_CONFIG_DIR}/`;
+    await ensureDir(store);
+    return store;
+}
+async function getWorkspaceConfigFilePath(configDirOverride) {
+    const configDir = await getConfigDirPath(configDirOverride);
+    return `${configDir}/${exports.WINDMILL_WORKSPACE_CONFIG_FILE}`;
+}
+async function getActiveWorkspaceConfigFilePath(configDirOverride) {
+    const configDir = await getConfigDirPath(configDirOverride);
+    return `${configDir}/${exports.WINDMILL_ACTIVE_WORKSPACE_FILE}`;
+}
+async function getInstancesConfigFilePath(configDirOverride) {
+    const configDir = await getConfigDirPath(configDirOverride);
+    return `${configDir}/${exports.INSTANCES_CONFIG_FILE}`;
+}
+async function getActiveInstanceFilePath(configDirOverride) {
+    const configDir = await getConfigDirPath(configDirOverride);
+    return `${configDir}/${exports.WINDMILL_ACTIVE_INSTANCE_FILE}`;
+}

package/dist/cjs/config/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config"), exports);

package/dist/cjs/constants.js

@@ -0,0 +1,44 @@
+"use strict";
+// constants.ts
+/**
+ * Cross-platform path separator constants
+ * Compatible with both Node.js and Deno environments
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELIMITER = exports.SEP = void 0;
+/**
+ * Detects if the current platform is Windows by checking various environment indicators.
+ * Uses multiple fallback methods to ensure compatibility across Node.js, Deno, and browser environments.
+ *
+ * @returns True if running on Windows, false otherwise
+ */
+const isWindows = (() => {
+    // Try Node.js process.platform first (most reliable)
+    if (typeof process !== "undefined" && process.platform) {
+        return process.platform === "win32";
+    }
+    // Try Deno specific detection via globalThis
+    if (typeof globalThis !== "undefined" && "Deno" in globalThis) {
+        return globalThis.Deno?.build?.os === "windows";
+    }
+    // Try navigator.platform (browser/some Deno contexts)
+    // @ts-ignore
+    if (typeof navigator !== "undefined" && navigator.platform) {
+        // @ts-ignore
+        return navigator.platform.toLowerCase().includes("win");
+    }
+    // Fallback - assume Unix-like (safest default)
+    return false;
+})();
+/**
+ * Path separator constant - equivalent to Deno's SEPARATOR or Node's path.sep
+ * On Windows: "\"
+ * On Unix-like systems: "/"
+ */
+exports.SEP = isWindows ? "\\" : "/";
+/**
+ * Path delimiter constant for environment variables like PATH
+ * On Windows: ";"
+ * On Unix-like systems: ":"
+ */
+exports.DELIMITER = isWindows ? ";" : ":";

package/dist/cjs/gen/core/ApiError.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+class ApiError extends Error {
+    url;
+    status;
+    statusText;
+    body;
+    request;
+    constructor(request, response, message) {
+        super(message);
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}
+exports.ApiError = ApiError;

package/dist/cjs/gen/core/ApiRequestOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/gen/core/ApiResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/gen/core/CancelablePromise.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelablePromise = exports.CancelError = void 0;
+class CancelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CancelError';
+    }
+    get isCancelled() {
+        return true;
+    }
+}
+exports.CancelError = CancelError;
+class CancelablePromise {
+    _isResolved;
+    _isRejected;
+    _isCancelled;
+    cancelHandlers;
+    promise;
+    _resolve;
+    _reject;
+    constructor(executor) {
+        this._isResolved = false;
+        this._isRejected = false;
+        this._isCancelled = false;
+        this.cancelHandlers = [];
+        this.promise = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+            const onResolve = (value) => {
+                if (this._isResolved || this._isRejected || this._isCancelled) {
+                    return;
+                }
+                this._isResolved = true;
+                if (this._resolve)
+                    this._resolve(value);
+            };
+            const onReject = (reason) => {
+                if (this._isResolved || this._isRejected || this._isCancelled) {
+                    return;
+                }
+                this._isRejected = true;
+                if (this._reject)
+                    this._reject(reason);
+            };
+            const onCancel = (cancelHandler) => {
+                if (this._isResolved || this._isRejected || this._isCancelled) {
+                    return;
+                }
+                this.cancelHandlers.push(cancelHandler);
+            };
+            Object.defineProperty(onCancel, 'isResolved', {
+                get: () => this._isResolved,
+            });
+            Object.defineProperty(onCancel, 'isRejected', {
+                get: () => this._isRejected,
+            });
+            Object.defineProperty(onCancel, 'isCancelled', {
+                get: () => this._isCancelled,
+            });
+            return executor(onResolve, onReject, onCancel);
+        });
+    }
+    get [Symbol.toStringTag]() {
+        return "Cancellable Promise";
+    }
+    then(onFulfilled, onRejected) {
+        return this.promise.then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return this.promise.catch(onRejected);
+    }
+    finally(onFinally) {
+        return this.promise.finally(onFinally);
+    }
+    cancel() {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+            return;
+        }
+        this._isCancelled = true;
+        if (this.cancelHandlers.length) {
+            try {
+                for (const cancelHandler of this.cancelHandlers) {
+                    cancelHandler();
+                }
+            }
+            catch (error) {
+                console.warn('Cancellation threw an error', error);
+                return;
+            }
+        }
+        this.cancelHandlers.length = 0;
+        if (this._reject)
+            this._reject(new CancelError('Request aborted'));
+    }
+    get isCancelled() {
+        return this._isCancelled;
+    }
+}
+exports.CancelablePromise = CancelablePromise;

package/dist/cjs/gen/core/OpenAPI.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPI = exports.Interceptors = void 0;
+const getEnv = (key) => {
+    return process.env[key];
+};
+const baseUrl = getEnv("BASE_INTERNAL_URL") ?? getEnv("BASE_URL") ?? "http://localhost:8000";
+const baseUrlApi = (baseUrl ?? '') + "/api";
+class Interceptors {
+    _fns;
+    constructor() {
+        this._fns = [];
+    }
+    eject(fn) {
+        const index = this._fns.indexOf(fn);
+        if (index !== -1) {
+            this._fns = [...this._fns.slice(0, index), ...this._fns.slice(index + 1)];
+        }
+    }
+    use(fn) {
+        this._fns = [...this._fns, fn];
+    }
+}
+exports.Interceptors = Interceptors;
+exports.OpenAPI = {
+    BASE: baseUrlApi,
+    CREDENTIALS: 'include',
+    ENCODE_PATH: undefined,
+    HEADERS: undefined,
+    PASSWORD: undefined,
+    TOKEN: getEnv("WM_TOKEN"),
+    USERNAME: undefined,
+    VERSION: '1.628.3',
+    WITH_CREDENTIALS: true,
+    interceptors: {
+        request: new Interceptors(),
+        response: new Interceptors(),
+    },
+};