@nocobase/plugin-multi-portal 2.2.0-alpha.10

package/dist/node_modules/tar/dist/commonjs/path-reservations.d.ts

@@ -0,0 +1,11 @@
+export type Reservation = {
+    paths: string[];
+    dirs: Set<string>;
+};
+export type Handler = (clear: () => void) => void;
+export declare class PathReservations {
+    #private;
+    reserve(paths: string[], fn: Handler): boolean;
+    check(fn: Handler): boolean;
+}
+//# sourceMappingURL=path-reservations.d.ts.map

package/dist/node_modules/tar/dist/commonjs/path-reservations.js

@@ -0,0 +1,170 @@
+"use strict";
+// A path exclusive reservation system
+// reserve([list, of, paths], fn)
+// When the fn is first in line for all its paths, it
+// is called with a cb that clears the reservation.
+//
+// Used by async unpack to avoid clobbering paths in use,
+// while still allowing maximal safe parallelization.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathReservations = void 0;
+const node_path_1 = require("node:path");
+const normalize_unicode_js_1 = require("./normalize-unicode.js");
+const strip_trailing_slashes_js_1 = require("./strip-trailing-slashes.js");
+const platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
+const isWindows = platform === 'win32';
+// return a set of parent dirs for a given path
+// '/a/b/c/d' -> ['/', '/a', '/a/b', '/a/b/c', '/a/b/c/d']
+const getDirs = (path) => {
+    const dirs = path
+        .split('/')
+        .slice(0, -1)
+        .reduce((set, path) => {
+        const s = set.at(-1);
+        if (s !== undefined) {
+            path = (0, node_path_1.join)(s, path);
+        }
+        set.push(path || '/');
+        return set;
+    }, []);
+    return dirs;
+};
+class PathReservations {
+    // path => [function or Set]
+    // A Set object means a directory reservation
+    // A fn is a direct reservation on that path
+    #queues = new Map();
+    // fn => {paths:[path,...], dirs:[path, ...]}
+    #reservations = new Map();
+    // functions currently running
+    #running = new Set();
+    reserve(paths, fn) {
+        paths =
+            isWindows ?
+                ['win32 parallelization disabled']
+                : paths.map(p => {
+                    // don't need normPath, because we skip this entirely for windows
+                    return (0, strip_trailing_slashes_js_1.stripTrailingSlashes)((0, node_path_1.join)((0, normalize_unicode_js_1.normalizeUnicode)(p)));
+                });
+        const dirs = new Set(paths.map(path => getDirs(path)).reduce((a, b) => a.concat(b)));
+        this.#reservations.set(fn, { dirs, paths });
+        for (const p of paths) {
+            const q = this.#queues.get(p);
+            if (!q) {
+                this.#queues.set(p, [fn]);
+            }
+            else {
+                q.push(fn);
+            }
+        }
+        for (const dir of dirs) {
+            const q = this.#queues.get(dir);
+            if (!q) {
+                this.#queues.set(dir, [new Set([fn])]);
+            }
+            else {
+                const l = q.at(-1);
+                if (l instanceof Set) {
+                    l.add(fn);
+                }
+                else {
+                    q.push(new Set([fn]));
+                }
+            }
+        }
+        return this.#run(fn);
+    }
+    // return the queues for each path the function cares about
+    // fn => {paths, dirs}
+    #getQueues(fn) {
+        const res = this.#reservations.get(fn);
+        /* c8 ignore start */
+        if (!res) {
+            throw new Error('function does not have any path reservations');
+        }
+        /* c8 ignore stop */
+        return {
+            paths: res.paths.map((path) => this.#queues.get(path)),
+            dirs: [...res.dirs].map(path => this.#queues.get(path)),
+        };
+    }
+    // check if fn is first in line for all its paths, and is
+    // included in the first set for all its dir queues
+    check(fn) {
+        const { paths, dirs } = this.#getQueues(fn);
+        return (paths.every(q => q && q[0] === fn) &&
+            dirs.every(q => q && q[0] instanceof Set && q[0].has(fn)));
+    }
+    // run the function if it's first in line and not already running
+    #run(fn) {
+        if (this.#running.has(fn) || !this.check(fn)) {
+            return false;
+        }
+        this.#running.add(fn);
+        fn(() => this.#clear(fn));
+        return true;
+    }
+    #clear(fn) {
+        if (!this.#running.has(fn)) {
+            return false;
+        }
+        const res = this.#reservations.get(fn);
+        /* c8 ignore start */
+        if (!res) {
+            throw new Error('invalid reservation');
+        }
+        /* c8 ignore stop */
+        const { paths, dirs } = res;
+        const next = new Set();
+        for (const path of paths) {
+            const q = this.#queues.get(path);
+            /* c8 ignore start */
+            if (!q || q?.[0] !== fn) {
+                continue;
+            }
+            /* c8 ignore stop */
+            const q0 = q[1];
+            if (!q0) {
+                this.#queues.delete(path);
+                continue;
+            }
+            q.shift();
+            if (typeof q0 === 'function') {
+                next.add(q0);
+            }
+            else {
+                for (const f of q0) {
+                    next.add(f);
+                }
+            }
+        }
+        for (const dir of dirs) {
+            const q = this.#queues.get(dir);
+            const q0 = q?.[0];
+            /* c8 ignore next - type safety only */
+            if (!q || !(q0 instanceof Set))
+                continue;
+            if (q0.size === 1 && q.length === 1) {
+                this.#queues.delete(dir);
+                continue;
+            }
+            else if (q0.size === 1) {
+                q.shift();
+                // next one must be a function,
+                // or else the Set would've been reused
+                const n = q[0];
+                if (typeof n === 'function') {
+                    next.add(n);
+                }
+            }
+            else {
+                q0.delete(fn);
+            }
+        }
+        this.#running.delete(fn);
+        next.forEach(fn => this.#run(fn));
+        return true;
+    }
+}
+exports.PathReservations = PathReservations;
+//# sourceMappingURL=path-reservations.js.map

package/dist/node_modules/tar/dist/commonjs/pax.d.ts

@@ -0,0 +1,26 @@
+import type { HeaderData } from './header.js';
+export declare class Pax implements HeaderData {
+    atime?: Date;
+    mtime?: Date;
+    ctime?: Date;
+    charset?: string;
+    comment?: string;
+    gid?: number;
+    uid?: number;
+    gname?: string;
+    uname?: string;
+    linkpath?: string;
+    dev?: number;
+    ino?: number;
+    nlink?: number;
+    path?: string;
+    size?: number;
+    mode?: number;
+    global: boolean;
+    constructor(obj: HeaderData, global?: boolean);
+    encode(): Buffer<ArrayBuffer>;
+    encodeBody(): string;
+    encodeField(field: keyof Pax): string;
+    static parse(str: string, ex?: HeaderData, g?: boolean): Pax;
+}
+//# sourceMappingURL=pax.d.ts.map

package/dist/node_modules/tar/dist/commonjs/pax.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pax = void 0;
+const node_path_1 = require("node:path");
+const header_js_1 = require("./header.js");
+class Pax {
+    atime;
+    mtime;
+    ctime;
+    charset;
+    comment;
+    gid;
+    uid;
+    gname;
+    uname;
+    linkpath;
+    dev;
+    ino;
+    nlink;
+    path;
+    size;
+    mode;
+    global;
+    constructor(obj, global = false) {
+        this.atime = obj.atime;
+        this.charset = obj.charset;
+        this.comment = obj.comment;
+        this.ctime = obj.ctime;
+        this.dev = obj.dev;
+        this.gid = obj.gid;
+        this.global = global;
+        this.gname = obj.gname;
+        this.ino = obj.ino;
+        this.linkpath = obj.linkpath;
+        this.mtime = obj.mtime;
+        this.nlink = obj.nlink;
+        this.path = obj.path;
+        this.size = obj.size;
+        this.uid = obj.uid;
+        this.uname = obj.uname;
+    }
+    encode() {
+        const body = this.encodeBody();
+        if (body === '') {
+            return Buffer.allocUnsafe(0);
+        }
+        const bodyLen = Buffer.byteLength(body);
+        // round up to 512 bytes
+        // add 512 for header
+        const bufLen = 512 * Math.ceil(1 + bodyLen / 512);
+        const buf = Buffer.allocUnsafe(bufLen);
+        // 0-fill the header section, it might not hit every field
+        for (let i = 0; i < 512; i++) {
+            buf[i] = 0;
+        }
+        new header_js_1.Header({
+            // XXX split the path
+            // then the path should be PaxHeader + basename, but less than 99,
+            // prepend with the dirname
+            /* c8 ignore start */
+            path: ('PaxHeader/' + (0, node_path_1.basename)(this.path ?? '')).slice(0, 99),
+            /* c8 ignore stop */
+            mode: this.mode || 0o644,
+            uid: this.uid,
+            gid: this.gid,
+            size: bodyLen,
+            mtime: this.mtime,
+            type: this.global ? 'GlobalExtendedHeader' : 'ExtendedHeader',
+            linkpath: '',
+            uname: this.uname || '',
+            gname: this.gname || '',
+            devmaj: 0,
+            devmin: 0,
+            atime: this.atime,
+            ctime: this.ctime,
+        }).encode(buf);
+        buf.write(body, 512, bodyLen, 'utf8');
+        // null pad after the body
+        for (let i = bodyLen + 512; i < buf.length; i++) {
+            buf[i] = 0;
+        }
+        return buf;
+    }
+    encodeBody() {
+        return (this.encodeField('path') +
+            this.encodeField('ctime') +
+            this.encodeField('atime') +
+            this.encodeField('dev') +
+            this.encodeField('ino') +
+            this.encodeField('nlink') +
+            this.encodeField('charset') +
+            this.encodeField('comment') +
+            this.encodeField('gid') +
+            this.encodeField('gname') +
+            this.encodeField('linkpath') +
+            this.encodeField('mtime') +
+            this.encodeField('size') +
+            this.encodeField('uid') +
+            this.encodeField('uname'));
+    }
+    encodeField(field) {
+        if (this[field] === undefined) {
+            return '';
+        }
+        const r = this[field];
+        const v = r instanceof Date ? r.getTime() / 1000 : r;
+        const s = ' ' +
+            (field === 'dev' || field === 'ino' || field === 'nlink' ?
+                'SCHILY.'
+                : '') +
+            field +
+            '=' +
+            v +
+            '\n';
+        const byteLen = Buffer.byteLength(s);
+        // the digits includes the length of the digits in ascii base-10
+        // so if it's 9 characters, then adding 1 for the 9 makes it 10
+        // which makes it 11 chars.
+        let digits = Math.floor(Math.log(byteLen) / Math.log(10)) + 1;
+        if (byteLen + digits >= Math.pow(10, digits)) {
+            digits += 1;
+        }
+        const len = digits + byteLen;
+        return len + s;
+    }
+    static parse(str, ex, g = false) {
+        return new Pax(merge(parseKV(str), ex), g);
+    }
+}
+exports.Pax = Pax;
+const merge = (a, b) => b ? Object.assign({}, b, a) : a;
+const parseKV = (str) => str
+    .replace(/\n$/, '')
+    .split('\n')
+    .reduce(parseKVLine, Object.create(null));
+const parseKVLine = (set, line) => {
+    const n = parseInt(line, 10);
+    // XXX Values with \n in them will fail this.
+    // Refactor to not be a naive line-by-line parse.
+    if (n !== Buffer.byteLength(line) + 1) {
+        return set;
+    }
+    line = line.slice((n + ' ').length);
+    const kv = line.split('=');
+    const r = kv.shift();
+    if (!r) {
+        return set;
+    }
+    const k = r.replace(/^SCHILY\.(dev|ino|nlink)/, '$1');
+    const v = kv.join('=');
+    set[k] =
+        /^([A-Z]+\.)?([mac]|birth|creation)time$/.test(k) ?
+            new Date(Number(v) * 1000)
+            : /^[0-9]+$/.test(v) ? +v
+                : v;
+    return set;
+};
+//# sourceMappingURL=pax.js.map

package/dist/node_modules/tar/dist/commonjs/process-umask.d.ts

@@ -0,0 +1,2 @@
+export declare const umask: () => number;
+//# sourceMappingURL=process-umask.d.ts.map

package/dist/node_modules/tar/dist/commonjs/process-umask.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.umask = void 0;
+// separate file so I stop getting nagged in vim about deprecated API.
+const umask = () => process.umask();
+exports.umask = umask;
+//# sourceMappingURL=process-umask.js.map

package/dist/node_modules/tar/dist/commonjs/read-entry.d.ts

@@ -0,0 +1,36 @@
+import { Minipass } from 'minipass';
+import type { Header } from './header.js';
+import type { Pax } from './pax.js';
+import type { EntryTypeName } from './types.js';
+export declare class ReadEntry extends Minipass<Buffer, Buffer> {
+    #private;
+    extended?: Pax;
+    globalExtended?: Pax;
+    header: Header;
+    startBlockSize: number;
+    blockRemain: number;
+    remain: number;
+    type: EntryTypeName;
+    meta: boolean;
+    ignore: boolean;
+    path: string;
+    mode?: number;
+    uid?: number;
+    gid?: number;
+    uname?: string;
+    gname?: string;
+    size: number;
+    mtime?: Date;
+    atime?: Date;
+    ctime?: Date;
+    linkpath?: string;
+    dev?: number;
+    ino?: number;
+    nlink?: number;
+    invalid: boolean;
+    absolute?: string;
+    unsupported: boolean;
+    constructor(header: Header, ex?: Pax, gex?: Pax);
+    write(data: Buffer): boolean;
+}
+//# sourceMappingURL=read-entry.d.ts.map

package/dist/node_modules/tar/dist/commonjs/read-entry.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadEntry = void 0;
+const minipass_1 = require("minipass");
+const normalize_windows_path_js_1 = require("./normalize-windows-path.js");
+class ReadEntry extends minipass_1.Minipass {
+    extended;
+    globalExtended;
+    header;
+    startBlockSize;
+    blockRemain;
+    remain;
+    type;
+    meta = false;
+    ignore = false;
+    path;
+    mode;
+    uid;
+    gid;
+    uname;
+    gname;
+    size = 0;
+    mtime;
+    atime;
+    ctime;
+    linkpath;
+    dev;
+    ino;
+    nlink;
+    invalid = false;
+    absolute;
+    unsupported = false;
+    constructor(header, ex, gex) {
+        super({});
+        // read entries always start life paused.  this is to avoid the
+        // situation where Minipass's auto-ending empty streams results
+        // in an entry ending before we're ready for it.
+        this.pause();
+        this.extended = ex;
+        this.globalExtended = gex;
+        this.header = header;
+        /* c8 ignore start */
+        this.remain = header.size ?? 0;
+        /* c8 ignore stop */
+        this.startBlockSize = 512 * Math.ceil(this.remain / 512);
+        this.blockRemain = this.startBlockSize;
+        this.type = header.type;
+        switch (this.type) {
+            case 'File':
+            case 'OldFile':
+            case 'Link':
+            case 'SymbolicLink':
+            case 'CharacterDevice':
+            case 'BlockDevice':
+            case 'Directory':
+            case 'FIFO':
+            case 'ContiguousFile':
+            case 'GNUDumpDir':
+                break;
+            case 'NextFileHasLongLinkpath':
+            case 'NextFileHasLongPath':
+            case 'OldGnuLongPath':
+            case 'GlobalExtendedHeader':
+            case 'ExtendedHeader':
+            case 'OldExtendedHeader':
+                this.meta = true;
+                break;
+            // NOTE: gnutar and bsdtar treat unrecognized types as 'File'
+            // it may be worth doing the same, but with a warning.
+            default:
+                this.ignore = true;
+        }
+        /* c8 ignore start */
+        if (!header.path) {
+            throw new Error('no path provided for tar.ReadEntry');
+        }
+        /* c8 ignore stop */
+        this.path = (0, normalize_windows_path_js_1.normalizeWindowsPath)(header.path);
+        this.mode = header.mode;
+        if (this.mode) {
+            this.mode = this.mode & 0o7777;
+        }
+        this.uid = header.uid;
+        this.gid = header.gid;
+        this.uname = header.uname;
+        this.gname = header.gname;
+        this.size = this.remain;
+        this.mtime = header.mtime;
+        this.atime = header.atime;
+        this.ctime = header.ctime;
+        /* c8 ignore start */
+        this.linkpath =
+            header.linkpath ? (0, normalize_windows_path_js_1.normalizeWindowsPath)(header.linkpath) : undefined;
+        /* c8 ignore stop */
+        this.uname = header.uname;
+        this.gname = header.gname;
+        if (ex) {
+            this.#slurp(ex);
+        }
+        if (gex) {
+            this.#slurp(gex, true);
+        }
+    }
+    write(data) {
+        const writeLen = data.length;
+        if (writeLen > this.blockRemain) {
+            throw new Error('writing more to entry than is appropriate');
+        }
+        const r = this.remain;
+        const br = this.blockRemain;
+        this.remain = Math.max(0, r - writeLen);
+        this.blockRemain = Math.max(0, br - writeLen);
+        if (this.ignore) {
+            return true;
+        }
+        if (r >= writeLen) {
+            return super.write(data);
+        }
+        // r < writeLen
+        return super.write(data.subarray(0, r));
+    }
+    #slurp(ex, gex = false) {
+        if (ex.path)
+            ex.path = (0, normalize_windows_path_js_1.normalizeWindowsPath)(ex.path);
+        if (ex.linkpath)
+            ex.linkpath = (0, normalize_windows_path_js_1.normalizeWindowsPath)(ex.linkpath);
+        Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
+            // we slurp in everything except for the path attribute in
+            // a global extended header, because that's weird. Also, any
+            // null/undefined values are ignored.
+            return !(v === null || v === undefined || (k === 'path' && gex));
+        })));
+    }
+}
+exports.ReadEntry = ReadEntry;
+//# sourceMappingURL=read-entry.js.map

package/dist/node_modules/tar/dist/commonjs/replace.d.ts

@@ -0,0 +1,2 @@
+export declare const replace: import("./make-command.js").TarCommand<never, never>;
+//# sourceMappingURL=replace.d.ts.map