@slopware/sloppy-darwin-x64 0.1.0-alpha.0

package/stdlib/sloppy/node/events.js

@@ -0,0 +1,113 @@
+const onceOriginal = Symbol("onceOriginal");
+
+class EventEmitter {
+    constructor() {
+        this._events = new Map();
+    }
+
+    on(name, listener) {
+        if (typeof listener !== "function") {
+            throw new TypeError("EventEmitter listener must be a function.");
+        }
+        const listeners = this._events.get(name) ?? [];
+        listeners.push(listener);
+        this._events.set(name, listeners);
+        return this;
+    }
+
+    addListener(name, listener) {
+        return this.on(name, listener);
+    }
+
+    prependListener(name, listener) {
+        if (typeof listener !== "function") {
+            throw new TypeError("EventEmitter listener must be a function.");
+        }
+        const listeners = this._events.get(name) ?? [];
+        listeners.unshift(listener);
+        this._events.set(name, listeners);
+        return this;
+    }
+
+    once(name, listener) {
+        if (typeof listener !== "function") {
+            throw new TypeError("EventEmitter listener must be a function.");
+        }
+        const wrapped = (...args) => {
+            this.off(name, wrapped);
+            listener(...args);
+        };
+        wrapped[onceOriginal] = listener;
+        return this.on(name, wrapped);
+    }
+
+    off(name, listener) {
+        const listeners = this._events.get(name) ?? [];
+        this._events.set(
+            name,
+            listeners.filter((candidate) => candidate !== listener && candidate[onceOriginal] !== listener),
+        );
+        return this;
+    }
+
+    removeListener(name, listener) {
+        return this.off(name, listener);
+    }
+
+    emit(name, ...args) {
+        const listeners = [...(this._events.get(name) ?? [])];
+        for (const listener of listeners) {
+            listener(...args);
+        }
+        return listeners.length > 0;
+    }
+
+    listenerCount(name) {
+        return (this._events.get(name) ?? []).length;
+    }
+
+    removeAllListeners(name = undefined) {
+        if (name === undefined) {
+            this._events.clear();
+        } else {
+            this._events.delete(name);
+        }
+        return this;
+    }
+}
+
+function once(emitter, name) {
+    return new Promise((resolve) => {
+        emitter.once(name, (...args) => resolve(args));
+    });
+}
+
+async function* on(emitter, name) {
+    const queue = [];
+    let notify = undefined;
+    const listener = (...args) => {
+        queue.push(args);
+        if (notify !== undefined) {
+            notify();
+            notify = undefined;
+        }
+    };
+    emitter.on(name, listener);
+    try {
+        while (true) {
+            if (queue.length === 0) {
+                await new Promise((resolve) => {
+                    notify = resolve;
+                });
+            }
+            while (queue.length > 0) {
+                yield queue.shift();
+            }
+        }
+    } finally {
+        emitter.removeListener(name, listener);
+    }
+}
+
+export { EventEmitter, on, once };
+export default { EventEmitter, on, once };

package/stdlib/sloppy/node/fs/promises.js

@@ -0,0 +1,27 @@
+export {
+    promises as default,
+    promises,
+} from "../fs.js";
+
+import { promises } from "../fs.js";
+
+const {
+    access,
+    appendFile,
+    copyFile,
+    lstat,
+    mkdir,
+    mkdtemp,
+    readdir,
+    readFile,
+    readlink,
+    realpath,
+    rename,
+    rm,
+    stat,
+    symlink,
+    unlink,
+    writeFile,
+} = promises;
+
+export { access, appendFile, copyFile, lstat, mkdir, mkdtemp, readdir, readFile, readlink, realpath, rename, rm, stat, symlink, unlink, writeFile };

package/stdlib/sloppy/node/fs.js

@@ -0,0 +1,280 @@
+import { Directory, File } from "../fs.js";
+import { Base64, Text } from "../codec.js";
+
+function bytesFromBase64(value) {
+    return Base64.decode(value);
+}
+
+function toSloppyPath(path) {
+    if (typeof path !== "string") {
+        return path;
+    }
+    const normalized = path.replace(/\\/g, "/");
+    if (
+        normalized.startsWith("/") ||
+        /^[A-Za-z]:\//.test(normalized) ||
+        normalized.startsWith("./") ||
+        normalized.startsWith("../") ||
+        normalized.includes("://")
+    ) {
+        return normalized;
+    }
+    return `./${normalized}`;
+}
+
+function normalizeEncoding(options, operation) {
+    const encoding = typeof options === "string" ? options : options?.encoding;
+    if (encoding === undefined || encoding === null) {
+        return undefined;
+    }
+    const normalized = String(encoding).toLowerCase();
+    if (normalized === "utf8" || normalized === "utf-8") {
+        return "utf8";
+    }
+    throw new TypeError(`SLOPPY_E_NODE_FS_UNSUPPORTED_ENCODING: ${operation} only supports utf8 text encoding.`);
+}
+
+function recursiveOption(options, operation) {
+    const recursive = options?.recursive;
+    if (recursive === undefined) {
+        return false;
+    }
+    if (typeof recursive !== "boolean") {
+        throw new TypeError(`${operation} recursive option must be a boolean.`);
+    }
+    return recursive;
+}
+
+function nodeStats(stat) {
+    return Object.freeze({
+        ...stat,
+        isFile() {
+            return stat.kind === "file" || (stat.exists === true && stat.kind !== "directory");
+        },
+        isDirectory() {
+            return stat.kind === "directory";
+        },
+        isSymbolicLink() {
+            return stat.kind === "symlink" || stat.symlink === true;
+        },
+    });
+}
+
+async function readFilePromise(path, options = undefined) {
+    const encoding = normalizeEncoding(options, "node:fs.readFile");
+    return encoding === "utf8"
+        ? File.readText(toSloppyPath(path))
+        : File.readBytes(toSloppyPath(path));
+}
+
+async function writeFilePromise(path, data, options = undefined) {
+    normalizeEncoding(options, "node:fs.writeFile");
+    if (typeof data === "string") {
+        return File.writeText(toSloppyPath(path), data);
+    }
+    return File.writeBytes(toSloppyPath(path), data);
+}
+
+async function appendFilePromise(path, data, options = undefined) {
+    normalizeEncoding(options, "node:fs.appendFile");
+    if (typeof data === "string") {
+        return File.appendText(toSloppyPath(path), data);
+    }
+    return File.appendBytes(toSloppyPath(path), data);
+}
+
+async function unlinkPromise(path) {
+    return File.delete(toSloppyPath(path));
+}
+
+async function copyFilePromise(fromPath, toPath) {
+    return File.copy(toSloppyPath(fromPath), toSloppyPath(toPath));
+}
+
+async function renamePromise(fromPath, toPath) {
+    return File.move(toSloppyPath(fromPath), toSloppyPath(toPath));
+}
+
+async function readlinkPromise(path) {
+    return File.readLink(toSloppyPath(path));
+}
+
+async function symlinkPromise(targetPath, linkPath, type = undefined) {
+    return File.createSymlink(toSloppyPath(targetPath), toSloppyPath(linkPath), {
+        directory: type === "dir" || type === "junction",
+    });
+}
+
+function callbackify(method, name) {
+    return (...args) => {
+        const callback = args.pop();
+        if (typeof callback !== "function") {
+            throw new TypeError(`node:fs.${name} requires a callback.`);
+        }
+        Promise.resolve()
+            .then(() => method(...args))
+            .then(
+                (value) => callback(null, value),
+                (error) => callback(error),
+            );
+    };
+}
+
+function sealedAssetMap() {
+    const map = globalThis.__sloppy_program_assets;
+    return (map && typeof map === "object") ? map : null;
+}
+
+function lookupSealedAsset(path) {
+    const map = sealedAssetMap();
+    if (!map) {
+        return undefined;
+    }
+    const sloppyPath = toSloppyPath(path);
+    if (Object.prototype.hasOwnProperty.call(map, sloppyPath)) {
+        return map[sloppyPath];
+    }
+    if (typeof path === "string" && Object.prototype.hasOwnProperty.call(map, path)) {
+        return map[path];
+    }
+    const normalized = typeof path === "string"
+        ? path.replace(/\\/g, "/").replace(/^(\.\/)+/, "")
+        : null;
+    if (normalized && Object.prototype.hasOwnProperty.call(map, normalized)) {
+        return map[normalized];
+    }
+    return undefined;
+}
+
+function unsealedSyncError(operation, _path) {
+    return new Error(
+        `SLOPPY_E_NODE_SYNC_FS_UNSEALED: node:fs.${operation} requires the path to be a sealed package asset; the requested path was not found in the bundled asset map.`,
+    );
+}
+
+function decodeSealedAssetText(entry) {
+    if (typeof entry === "string") {
+        return entry;
+    }
+    if (entry && typeof entry === "object" && typeof entry.text === "string") {
+        return entry.text;
+    }
+    if (entry && typeof entry === "object" && typeof entry.base64 === "string") {
+        const bytes = bytesFromBase64(entry.base64);
+        return Text.utf8.decode(bytes);
+    }
+    return undefined;
+}
+
+function decodeSealedAssetBytes(entry) {
+    if (entry instanceof Uint8Array) {
+        return entry.slice();
+    }
+    if (entry && typeof entry === "object" && entry.bytes instanceof Uint8Array) {
+        return entry.bytes.slice();
+    }
+    if (entry && typeof entry === "object" && typeof entry.base64 === "string") {
+        return bytesFromBase64(entry.base64).slice();
+    }
+    if (typeof entry === "string") {
+        return Text.utf8.encode(entry);
+    }
+    return undefined;
+}
+
+function readFileSync(path, options = undefined) {
+    const entry = lookupSealedAsset(path);
+    if (entry === undefined) {
+        throw unsealedSyncError("readFileSync", path);
+    }
+    const encoding = normalizeEncoding(options, "node:fs.readFileSync");
+    if (encoding === "utf8") {
+        const text = decodeSealedAssetText(entry);
+        if (text === undefined) {
+            throw unsealedSyncError("readFileSync", path);
+        }
+        return text;
+    }
+    const bytes = decodeSealedAssetBytes(entry);
+    if (bytes === undefined) {
+        throw unsealedSyncError("readFileSync", path);
+    }
+    return bytes.slice();
+}
+
+function existsSync(path) {
+    return lookupSealedAsset(path) !== undefined;
+}
+
+function statSync(path, options = undefined) {
+    const entry = lookupSealedAsset(path);
+    if (entry === undefined) {
+        const opts = options && typeof options === "object" ? options : {};
+        if (opts.throwIfNoEntry === false) {
+            return undefined;
+        }
+        throw unsealedSyncError("statSync", path);
+    }
+    const bytes = decodeSealedAssetBytes(entry);
+    return nodeStats({
+        kind: "file",
+        exists: true,
+        size: bytes ? bytes.byteLength : 0,
+    });
+}
+
+async function unsupportedPromise(name) {
+    throw new Error(`SLOPPY_E_NODE_FS_UNSUPPORTED: node:fs.promises.${name} is not implemented by Sloppy's Node compatibility shim.`);
+}
+
+const promises = Object.freeze({
+    access: async (path) => {
+        const stat = await File.stat(toSloppyPath(path));
+        if (!stat.exists) {
+            throw new Error("SLOPPY_E_NODE_FS_ACCESS: path is not accessible.");
+        }
+    },
+    appendFile: appendFilePromise,
+    copyFile: copyFilePromise,
+    lstat: () => unsupportedPromise("lstat"),
+    mkdir: (path, options) =>
+        Directory.create(toSloppyPath(path), { recursive: recursiveOption(options, "node:fs.mkdir") }),
+    mkdtemp: () => unsupportedPromise("mkdtemp"),
+    readdir: async (path) => (await Directory.list(toSloppyPath(path))).map((entry) => entry.name),
+    readFile: readFilePromise,
+    readlink: readlinkPromise,
+    realpath: () => unsupportedPromise("realpath"),
+    rename: renamePromise,
+    rm: async (path, options = undefined) => {
+        const sloppyPath = toSloppyPath(path);
+        const stat = await File.stat(sloppyPath);
+        if (stat.kind === "directory") {
+            return Directory.delete(sloppyPath, { recursive: recursiveOption(options, "node:fs.rm") });
+        }
+        return File.delete(sloppyPath);
+    },
+    stat: async (path) => nodeStats(await File.stat(toSloppyPath(path))),
+    symlink: symlinkPromise,
+    unlink: unlinkPromise,
+    writeFile: writeFilePromise,
+});
+
+const access = callbackify(promises.access, "access");
+const appendFile = callbackify(appendFilePromise, "appendFile");
+const copyFile = callbackify(copyFilePromise, "copyFile");
+const lstat = callbackify(promises.lstat, "lstat");
+const mkdir = callbackify(promises.mkdir, "mkdir");
+const mkdtemp = callbackify(promises.mkdtemp, "mkdtemp");
+const readdir = callbackify(promises.readdir, "readdir");
+const readFile = callbackify(readFilePromise, "readFile");
+const readlink = callbackify(readlinkPromise, "readlink");
+const realpath = callbackify(promises.realpath, "realpath");
+const rename = callbackify(renamePromise, "rename");
+const rm = callbackify(promises.rm, "rm");
+const stat = callbackify(promises.stat, "stat");
+const symlink = callbackify(symlinkPromise, "symlink");
+const unlink = callbackify(unlinkPromise, "unlink");
+const writeFile = callbackify(writeFilePromise, "writeFile");
+
+export { access, appendFile, copyFile, existsSync, lstat, mkdir, mkdtemp, promises, readdir, readFile, readFileSync, readlink, realpath, rename, rm, stat, statSync, symlink, unlink, writeFile };
+export default { access, appendFile, copyFile, existsSync, lstat, mkdir, mkdtemp, promises, readdir, readFile, readFileSync, readlink, realpath, rename, rm, stat, statSync, symlink, unlink, writeFile };

package/stdlib/sloppy/node/http.js

@@ -0,0 +1,11 @@
+function unsupported(name) {
+    return () => {
+        throw new Error(`SLOPPY_E_NODE_HTTP_UNSUPPORTED: node:http.${name} is not implemented by Sloppy's Node compatibility shim.`);
+    };
+}
+
+const request = unsupported("request");
+const get = unsupported("get");
+
+export { get, request };
+export default { get, request };

package/stdlib/sloppy/node/https.js

@@ -0,0 +1,11 @@
+function unsupported(name) {
+    return () => {
+        throw new Error(`SLOPPY_E_NODE_HTTPS_UNSUPPORTED: node:https.${name} is not implemented by Sloppy's Node compatibility shim.`);
+    };
+}
+
+const request = unsupported("request");
+const get = unsupported("get");
+
+export { get, request };
+export default { get, request };

package/stdlib/sloppy/node/module.js

@@ -0,0 +1,40 @@
+const builtinModules = Object.freeze([
+    "assert",
+    "assert/strict",
+    "buffer",
+    "console",
+    "constants",
+    "crypto",
+    "diagnostics_channel",
+    "events",
+    "fs",
+    "fs/promises",
+    "http",
+    "https",
+    "module",
+    "os",
+    "path",
+    "perf_hooks",
+    "process",
+    "querystring",
+    "stream",
+    "stream/promises",
+    "string_decoder",
+    "timers",
+    "tty",
+    "url",
+    "util",
+    "zlib",
+]);
+
+function createRequire(source) {
+    if (typeof globalThis.__sloppy_program_create_require === "function") {
+        return globalThis.__sloppy_program_create_require(source);
+    }
+    throw new Error("SLOPPY_E_MODULE_REQUIRE_UNAVAILABLE: createRequire is only available in bundled Sloppy programs.");
+}
+
+const Module = Object.freeze({ builtinModules, createRequire });
+
+export { builtinModules, createRequire, Module };
+export default Module;

package/stdlib/sloppy/node/os.js

@@ -0,0 +1,22 @@
+import { Environment, System } from "../os.js";
+
+const EOL = "\n";
+
+function platform() {
+    return System?.platform ?? "sloppy";
+}
+
+function arch() {
+    return System?.arch ?? "x64";
+}
+
+function tmpdir() {
+    return Environment.get?.("TMPDIR") ?? Environment.get?.("TEMP") ?? ".";
+}
+
+function homedir() {
+    return Environment.get?.("HOME") ?? Environment.get?.("USERPROFILE") ?? ".";
+}
+
+export { arch, EOL, homedir, platform, tmpdir };
+export default { arch, EOL, homedir, platform, tmpdir };

package/stdlib/sloppy/node/path.js

@@ -0,0 +1,78 @@
+function normalize(input) {
+    const absolute = String(input || "").startsWith("/");
+    const parts = [];
+    for (const part of String(input || "").replace(/\\/g, "/").split("/")) {
+        if (part === "" || part === ".") {
+            continue;
+        }
+        if (part === "..") {
+            if (parts.length > 0 && parts[parts.length - 1] !== "..") {
+                parts.pop();
+            } else if (!absolute) {
+                parts.push("..");
+            }
+            continue;
+        }
+        parts.push(part);
+    }
+    const joined = parts.join("/");
+    return `${absolute ? "/" : ""}${joined}` || ".";
+}
+
+function join(...parts) {
+    return normalize(parts.filter((part) => part !== "").join("/"));
+}
+
+function resolve(...parts) {
+    let output = "";
+    for (const part of parts) {
+        const text = String(part);
+        output = text.startsWith("/") ? text : `${output}/${text}`;
+    }
+    return normalize(output || ".");
+}
+
+function basename(input, ext = "") {
+    const text = normalize(input);
+    const base = text.slice(text.lastIndexOf("/") + 1);
+    return ext && base.endsWith(ext) ? base.slice(0, -ext.length) : base;
+}
+
+function dirname(input) {
+    const text = normalize(input);
+    const index = text.lastIndexOf("/");
+    if (index <= 0) {
+        return text.startsWith("/") ? "/" : ".";
+    }
+    return text.slice(0, index);
+}
+
+function extname(input) {
+    const base = basename(input);
+    const index = base.lastIndexOf(".");
+    return index > 0 ? base.slice(index) : "";
+}
+
+function isAbsolute(input) {
+    return String(input || "").startsWith("/");
+}
+
+const sep = "/";
+const delimiter = ":";
+
+const posix = Object.freeze({
+    basename,
+    delimiter,
+    dirname,
+    extname,
+    isAbsolute,
+    join,
+    normalize,
+    resolve,
+    sep,
+});
+
+const win32 = posix;
+
+export { basename, delimiter, dirname, extname, isAbsolute, join, normalize, posix, resolve, sep, win32 };
+export default posix;

package/stdlib/sloppy/node/perf_hooks.js

@@ -0,0 +1,12 @@
+const fallbackTimeOrigin = Date.now() - (
+    typeof process !== "undefined" && typeof process.uptime === "function"
+        ? process.uptime() * 1000
+        : 0
+);
+const performance = globalThis.performance ?? Object.freeze({
+    now: () => Date.now() - fallbackTimeOrigin,
+    timeOrigin: fallbackTimeOrigin,
+});
+
+export { performance };
+export default { performance };