@cj-tech-master/excelts 0.1.0-canary.20251025023400.dff1908

package/dist/esm/utils/stream-buf.js

@@ -0,0 +1,333 @@
+import { Duplex } from "stream";
+import { inherits, nop } from "./utils.js";
+import { StringBuf } from "./string-buf.js";
+// =============================================================================
+// data chunks - encapsulating incoming data
+class StringChunk {
+    constructor(data, encoding) {
+        this._data = data;
+        this._encoding = encoding;
+    }
+    get length() {
+        return this.toBuffer().length;
+    }
+    // copy to target buffer
+    copy(target, targetOffset, offset, length) {
+        return this.toBuffer().copy(target, targetOffset, offset, length);
+    }
+    toBuffer() {
+        if (!this._buffer) {
+            this._buffer = Buffer.from(this._data, this._encoding);
+        }
+        return this._buffer;
+    }
+}
+class StringBufChunk {
+    constructor(data) {
+        this._data = data;
+    }
+    get length() {
+        return this._data.length;
+    }
+    // copy to target buffer
+    copy(target, targetOffset, offset, length) {
+        return this._data._buf.copy(target, targetOffset, offset, length);
+    }
+    toBuffer() {
+        return this._data.toBuffer();
+    }
+}
+class BufferChunk {
+    constructor(data) {
+        this._data = data;
+    }
+    get length() {
+        return this._data.length;
+    }
+    // copy to target buffer
+    copy(target, targetOffset, offset, length) {
+        this._data.copy(target, targetOffset, offset, length);
+    }
+    toBuffer() {
+        return this._data;
+    }
+}
+// =============================================================================
+// ReadWriteBuf - a single buffer supporting simple read-write
+class ReadWriteBuf {
+    constructor(size) {
+        this.size = size;
+        // the buffer
+        this.buffer = Buffer.alloc(size);
+        // read index
+        this.iRead = 0;
+        // write index
+        this.iWrite = 0;
+    }
+    toBuffer() {
+        if (this.iRead === 0 && this.iWrite === this.size) {
+            return this.buffer;
+        }
+        const buf = Buffer.alloc(this.iWrite - this.iRead);
+        this.buffer.copy(buf, 0, this.iRead, this.iWrite);
+        return buf;
+    }
+    get length() {
+        return this.iWrite - this.iRead;
+    }
+    get eod() {
+        return this.iRead === this.iWrite;
+    }
+    get full() {
+        return this.iWrite === this.size;
+    }
+    read(size) {
+        let buf;
+        // read size bytes from buffer and return buffer
+        if (size === 0) {
+            // special case - return null if no data requested
+            return null;
+        }
+        if (size === undefined || size >= this.length) {
+            // if no size specified or size is at least what we have then return all of the bytes
+            buf = this.toBuffer();
+            this.iRead = this.iWrite;
+            return buf;
+        }
+        // otherwise return a chunk
+        buf = Buffer.alloc(size);
+        this.buffer.copy(buf, 0, this.iRead, size);
+        this.iRead += size;
+        return buf;
+    }
+    write(chunk, offset, length) {
+        // write as many bytes from data from optional source offset
+        // and return number of bytes written
+        const size = Math.min(length, this.size - this.iWrite);
+        chunk.copy(this.buffer, this.iWrite, offset, offset + size);
+        this.iWrite += size;
+        return size;
+    }
+}
+// =============================================================================
+// StreamBuf - a multi-purpose read-write stream
+//  As MemBuf - write as much data as you like. Then call toBuffer() to consolidate
+//  As StreamHub - pipe to multiple writables
+//  As readable stream - feed data into the writable part and have some other code read from it.
+// Note: Not sure why but StreamBuf does not like JS "class" sugar. It fails the
+// integration tests
+const StreamBuf = function (options) {
+    if (!(this instanceof StreamBuf)) {
+        return new StreamBuf(options);
+    }
+    Duplex.call(this, options);
+    options = options || {};
+    this.bufSize = options.bufSize || 1024 * 1024;
+    this.buffers = [];
+    // batch mode fills a buffer completely before passing the data on
+    // to pipes or 'readable' event listeners
+    this.batch = options.batch || false;
+    this.corked = false;
+    // where in the current writable buffer we're up to
+    this.inPos = 0;
+    // where in the current readable buffer we've read up to
+    this.outPos = 0;
+    // consuming pipe streams go here
+    this.pipes = [];
+    // controls emit('data')
+    this.paused = false;
+    this.encoding = null;
+};
+inherits(StreamBuf, Duplex, {
+    toBuffer() {
+        switch (this.buffers.length) {
+            case 0:
+                return null;
+            case 1:
+                return this.buffers[0].toBuffer();
+            default:
+                return Buffer.concat(this.buffers.map((rwBuf) => rwBuf.toBuffer()));
+        }
+    },
+    // writable
+    // event drain - if write returns false (which it won't), indicates when safe to write again.
+    // finish - end() has been called
+    // pipe(src) - pipe() has been called on readable
+    // unpipe(src) - unpipe() has been called on readable
+    // error - duh
+    _getWritableBuffer() {
+        if (this.buffers.length) {
+            const last = this.buffers[this.buffers.length - 1];
+            if (!last.full) {
+                return last;
+            }
+        }
+        const buf = new ReadWriteBuf(this.bufSize);
+        this.buffers.push(buf);
+        return buf;
+    },
+    async _pipe(chunk) {
+        const write = function (pipe) {
+            return new Promise(resolve => {
+                pipe.write(chunk.toBuffer(), () => {
+                    resolve();
+                });
+            });
+        };
+        await Promise.all(this.pipes.map(write));
+    },
+    _writeToBuffers(chunk) {
+        let inPos = 0;
+        const inLen = chunk.length;
+        while (inPos < inLen) {
+            // find writable buffer
+            const buffer = this._getWritableBuffer();
+            // write some data
+            inPos += buffer.write(chunk, inPos, inLen - inPos);
+        }
+    },
+    async write(data, encoding, callback) {
+        if (encoding instanceof Function) {
+            callback = encoding;
+            encoding = "utf8";
+        }
+        callback = callback || nop;
+        // encapsulate data into a chunk
+        let chunk;
+        // Use constructor name check for better ES6 module compatibility
+        if (data instanceof StringBuf || (data && data.constructor?.name === "StringBuf")) {
+            chunk = new StringBufChunk(data);
+        }
+        else if (data instanceof Buffer) {
+            chunk = new BufferChunk(data);
+        }
+        else if (typeof data === "string" || data instanceof String || data instanceof ArrayBuffer) {
+            chunk = new StringChunk(String(data), encoding);
+        }
+        else {
+            throw new Error("Chunk must be one of type String, Buffer or StringBuf.");
+        }
+        // now, do something with the chunk
+        if (this.pipes.length) {
+            if (this.batch) {
+                this._writeToBuffers(chunk);
+                while (!this.corked && this.buffers.length > 1) {
+                    this._pipe(this.buffers.shift());
+                }
+            }
+            else if (!this.corked) {
+                await this._pipe(chunk);
+                callback();
+            }
+            else {
+                this._writeToBuffers(chunk);
+                process.nextTick(callback);
+            }
+        }
+        else {
+            if (!this.paused) {
+                this.emit("data", chunk.toBuffer());
+            }
+            this._writeToBuffers(chunk);
+            this.emit("readable");
+        }
+        return true;
+    },
+    cork() {
+        this.corked = true;
+    },
+    _flush() {
+        // if we have comsumers...
+        if (this.pipes.length) {
+            // and there's stuff not written
+            while (this.buffers.length) {
+                this._pipe(this.buffers.shift());
+            }
+        }
+    },
+    uncork() {
+        this.corked = false;
+        this._flush();
+    },
+    end(chunk, encoding, callback) {
+        const writeComplete = (error) => {
+            if (error) {
+                callback(error);
+            }
+            else {
+                this._flush();
+                this.pipes.forEach((pipe) => {
+                    pipe.end();
+                });
+                this.emit("finish");
+            }
+        };
+        if (chunk) {
+            this.write(chunk, encoding, writeComplete);
+        }
+        else {
+            writeComplete();
+        }
+    },
+    // readable
+    // event readable - some data is now available
+    // event data - switch to flowing mode - feeds chunks to handler
+    // event end - no more data
+    // event close - optional, indicates upstream close
+    // event error - duh
+    read(size) {
+        let buffers;
+        // read min(buffer, size || infinity)
+        if (size) {
+            buffers = [];
+            while (size && this.buffers.length && !this.buffers[0].eod) {
+                const first = this.buffers[0];
+                const buffer = first.read(size);
+                size -= buffer.length;
+                buffers.push(buffer);
+                if (first.eod && first.full) {
+                    this.buffers.shift();
+                }
+            }
+            return Buffer.concat(buffers);
+        }
+        buffers = this.buffers.map((buf) => buf.toBuffer()).filter(Boolean);
+        this.buffers = [];
+        return Buffer.concat(buffers);
+    },
+    setEncoding(encoding) {
+        // causes stream.read or stream.on('data) to return strings of encoding instead of Buffer objects
+        this.encoding = encoding;
+    },
+    pause() {
+        this.paused = true;
+    },
+    resume() {
+        this.paused = false;
+    },
+    isPaused() {
+        return !!this.paused;
+    },
+    pipe(destination) {
+        // add destination to pipe list & write current buffer
+        this.pipes.push(destination);
+        if (!this.paused && this.buffers.length) {
+            this.end();
+        }
+        return destination;
+    },
+    unpipe(destination) {
+        // remove destination from pipe list
+        this.pipes = this.pipes.filter((pipe) => pipe !== destination);
+    },
+    unshift() {
+        // some numpty has read some data that's not for them and they want to put it back!
+        // Might implement this some day
+        throw new Error("Not Implemented");
+    },
+    wrap() {
+        // not implemented
+        throw new Error("Not Implemented");
+    }
+});
+export { StreamBuf };

package/dist/esm/utils/string-buf.js

@@ -0,0 +1,65 @@
+// StringBuf - a way to keep string memory operations to a minimum
+// while building the strings for the xml files
+class StringBuf {
+    constructor(options) {
+        this._buf = Buffer.alloc((options && options.size) || 16384);
+        this._encoding = (options && options.encoding) || "utf8";
+        // where in the buffer we are at
+        this._inPos = 0;
+        // for use by toBuffer()
+        this._buffer = undefined;
+    }
+    get length() {
+        return this._inPos;
+    }
+    get capacity() {
+        return this._buf.length;
+    }
+    get buffer() {
+        return this._buf;
+    }
+    toBuffer() {
+        // return the current data as a single enclosing buffer
+        if (!this._buffer) {
+            this._buffer = Buffer.alloc(this.length);
+            this._buf.copy(this._buffer, 0, 0, this.length);
+        }
+        return this._buffer;
+    }
+    reset(position) {
+        position = position || 0;
+        this._buffer = undefined;
+        this._inPos = position;
+    }
+    _grow(min) {
+        let size = this._buf.length * 2;
+        while (size < min) {
+            size *= 2;
+        }
+        const buf = Buffer.alloc(size);
+        this._buf.copy(buf, 0);
+        this._buf = buf;
+    }
+    addText(text) {
+        this._buffer = undefined;
+        let inPos = this._inPos + this._buf.write(text, this._inPos, this._encoding);
+        // if we've hit (or nearing capacity), grow the buf
+        while (inPos >= this._buf.length - 4) {
+            this._grow(this._inPos + text.length);
+            // keep trying to write until we've completely written the text
+            inPos = this._inPos + this._buf.write(text, this._inPos, this._encoding);
+        }
+        this._inPos = inPos;
+    }
+    addStringBuf(inBuf) {
+        if (inBuf.length) {
+            this._buffer = undefined;
+            if (this.length + inBuf.length > this.capacity) {
+                this._grow(this.length + inBuf.length);
+            }
+            inBuf._buf.copy(this._buf, this._inPos, 0, inBuf.length);
+            this._inPos += inBuf.length;
+        }
+    }
+}
+export { StringBuf };

package/dist/esm/utils/under-dash.js

@@ -0,0 +1,171 @@
+const { toString } = Object.prototype;
+const escapeHtmlRegex = /["&<>]/;
+export function isEqual(a, b) {
+    const aType = typeof a;
+    const bType = typeof b;
+    const aArray = Array.isArray(a);
+    const bArray = Array.isArray(b);
+    let keys;
+    if (aType !== bType) {
+        return false;
+    }
+    switch (typeof a) {
+        case "object":
+            if (aArray || bArray) {
+                if (aArray && bArray) {
+                    return (a.length === b.length &&
+                        a.every((aValue, index) => {
+                            const bValue = b[index];
+                            return isEqual(aValue, bValue);
+                        }));
+                }
+                return false;
+            }
+            if (a === null || b === null) {
+                return a === b;
+            }
+            // Compare object keys and values
+            keys = Object.keys(a);
+            if (Object.keys(b).length !== keys.length) {
+                return false;
+            }
+            for (const key of keys) {
+                if (!Object.prototype.hasOwnProperty.call(b, key)) {
+                    return false;
+                }
+            }
+            return keys.every(key => {
+                const aValue = a[key];
+                const bValue = b[key];
+                return isEqual(aValue, bValue);
+            });
+        default:
+            return a === b;
+    }
+}
+export function escapeHtml(html) {
+    const regexResult = escapeHtmlRegex.exec(html);
+    if (!regexResult) {
+        return html;
+    }
+    let result = "";
+    let escape = "";
+    let lastIndex = 0;
+    let i = regexResult.index;
+    for (; i < html.length; i++) {
+        switch (html.charAt(i)) {
+            case '"':
+                escape = "&quot;";
+                break;
+            case "&":
+                escape = "&amp;";
+                break;
+            case "<":
+                escape = "&lt;";
+                break;
+            case ">":
+                escape = "&gt;";
+                break;
+            default:
+                continue;
+        }
+        if (lastIndex !== i) {
+            result += html.substring(lastIndex, i);
+        }
+        lastIndex = i + 1;
+        result += escape;
+    }
+    if (lastIndex !== i) {
+        return result + html.substring(lastIndex, i);
+    }
+    return result;
+}
+export function isUndefined(val) {
+    return toString.call(val) === "[object Undefined]";
+}
+export function isObject(val) {
+    return toString.call(val) === "[object Object]";
+}
+export function deepMerge(...args) {
+    const target = args[0] || {};
+    const { length } = args;
+    let src, clone, copyIsArray;
+    function assignValue(val, key) {
+        src = target[key];
+        copyIsArray = Array.isArray(val);
+        if (isObject(val) || copyIsArray) {
+            if (copyIsArray) {
+                copyIsArray = false;
+                clone = src && Array.isArray(src) ? src : [];
+            }
+            else {
+                clone = src && isObject(src) ? src : {};
+            }
+            target[key] = deepMerge(clone, val);
+        }
+        else if (!isUndefined(val)) {
+            target[key] = val;
+        }
+    }
+    for (let i = 0; i < length; i++) {
+        const arg = args[i];
+        if (arg) {
+            if (Array.isArray(arg)) {
+                arg.forEach((val, index) => assignValue(val, index));
+            }
+            else {
+                Object.entries(arg).forEach(([key, val]) => {
+                    // Prevent prototype pollution
+                    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+                        return;
+                    }
+                    assignValue(val, key);
+                });
+            }
+        }
+    }
+    return target;
+}
+export function cloneDeep(obj, preserveUndefined) {
+    if (preserveUndefined === undefined) {
+        preserveUndefined = true;
+    }
+    let clone;
+    if (obj === null) {
+        return null;
+    }
+    if (obj instanceof Date) {
+        return obj;
+    }
+    if (obj instanceof Array) {
+        clone = [];
+        obj.forEach((value, index) => {
+            if (value !== undefined) {
+                clone[index] = cloneDeep(value, preserveUndefined);
+            }
+            else if (preserveUndefined) {
+                clone[index] = undefined;
+            }
+        });
+    }
+    else if (typeof obj === "object") {
+        clone = {};
+        Object.keys(obj).forEach(name => {
+            const value = obj[name];
+            if (value !== undefined) {
+                clone[name] = cloneDeep(value, preserveUndefined);
+            }
+            else if (preserveUndefined) {
+                clone[name] = undefined;
+            }
+        });
+    }
+    else {
+        return obj;
+    }
+    return clone;
+}
+export function get(obj, path, defaultValue) {
+    const keys = path.split(".");
+    return keys.reduce((result, key) => result?.[key], obj) ?? defaultValue;
+}