customized-fabric 1.0.0 → 1.0.1

package/lib/customizedFabric/utils.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getObject = exports.lockAllObjects = exports.lockObject = exports.loadImageFromFile = exports.isFontLoaded = exports.loadFontFromUrl = void 0;
+const fabric_1 = require("fabric");
+const constants_1 = require("./constants");
+const _1 = require(".");
+const ImagePlaceholderObject_1 = require("./ImagePlaceholderObject");
+const loadFontFromUrl = async (name, url) => {
+    if (!name || !url)
+        return;
+    const font = new FontFace(name, `url(${url})`);
+    await font.load();
+    document.fonts.add(font);
+};
+exports.loadFontFromUrl = loadFontFromUrl;
+const isFontLoaded = (name) => {
+    let isLoaded = false;
+    document.fonts.forEach((font) => {
+        if (name == font.family) {
+            isLoaded = true;
+        }
+    });
+    return isLoaded;
+};
+exports.isFontLoaded = isFontLoaded;
+const loadImageFromFile = (image) => {
+    return new Promise((resolve) => {
+        const reader = new FileReader();
+        reader.onload = function (event) {
+            const image = new Image();
+            image.src = event?.target?.result;
+            image.onload = function () {
+                resolve(new fabric_1.fabric.Image(image));
+            };
+        };
+        reader.readAsDataURL(image);
+    });
+};
+exports.loadImageFromFile = loadImageFromFile;
+const lockObject = (object, locked, selectable) => {
+    object.set({
+        hasControls: !locked,
+        lockMovementX: locked,
+        lockMovementY: locked,
+        lockRotation: locked,
+        lockScalingX: locked,
+        lockScalingY: locked,
+        lockUniScaling: locked,
+        lockSkewingX: locked,
+        lockSkewingY: locked,
+        lockScalingFlip: locked,
+        locked: locked,
+        selectable: selectable ?? !locked,
+    });
+};
+exports.lockObject = lockObject;
+const lockAllObjects = (canvas, locked) => {
+    canvas._objects.map((object) => {
+        (0, exports.lockObject)(object, locked);
+    });
+};
+exports.lockAllObjects = lockAllObjects;
+const getObject = (object, options) => {
+    switch (object.type) {
+        case constants_1.OBJECT_TYPES.textInput: {
+            const textInputObject = new _1.TextInput({
+                ...object,
+                hideStroke: options?.isOriginal,
+            });
+            return textInputObject;
+        }
+        case constants_1.OBJECT_TYPES.clipart: {
+            const clipartObject = new _1.Clipart({
+                ...object,
+                hideStroke: options?.isOriginal,
+            });
+            return clipartObject;
+        }
+        case constants_1.OBJECT_TYPES.imagePlaceHolder: {
+            const imagePlaceHolderObject = new ImagePlaceholderObject_1.ImagePlaceholder({
+                ...object,
+                hideStroke: options?.isOriginal,
+            });
+            return imagePlaceHolderObject;
+        }
+        default:
+            return;
+    }
+};
+exports.getObject = getObject;

package/lib/index.js

@@ -14,39 +14,4 @@ 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 });
-const fabric_1 = require("fabric");
-const TextInputObject_1 = require("./TextInputObject");
-const ClipartObject_1 = require("./ClipartObject");
-const ImagePlaceholderObject_1 = require("./ImagePlaceholderObject");
-const constants_1 = require("./constants");
-fabric_1.fabric.TextInput = TextInputObject_1.TextInput;
-fabric_1.fabric.Clipart = ClipartObject_1.Clipart;
-fabric_1.fabric.ImagePlaceholder = ImagePlaceholderObject_1.ImagePlaceholder;
-fabric_1.fabric.Object.prototype.transparentCorners = false;
-fabric_1.fabric.Object.prototype.cornerColor = "black";
-fabric_1.fabric.Object.prototype.cornerStyle = "circle";
-fabric_1.fabric.Object.prototype.cornerStrokeColor = "black";
-fabric_1.fabric.Object.prototype.borderColor = "black";
-fabric_1.fabric.Object.prototype.toObject = (function (toObject) {
-    return function () {
-        switch (this.type) {
-            case constants_1.OBJECT_TYPES.textInput: {
-                return fabric_1.fabric.util.object.extend(toObject.call(this), (0, TextInputObject_1.toTextInputObject)(this));
-            }
-            case constants_1.OBJECT_TYPES.clipart: {
-                return fabric_1.fabric.util.object.extend(toObject.call(this), (0, ClipartObject_1.toClipartObject)(this));
-            }
-            case constants_1.OBJECT_TYPES.imagePlaceHolder: {
-                return fabric_1.fabric.util.object.extend(toObject.call(this), (0, ImagePlaceholderObject_1.toImagePlaceholderObject)(this));
-            }
-            default: {
-                return {};
-            }
-        }
-    };
-})(fabric_1.fabric.Object.prototype.toObject);
-__exportStar(require("./TextInputObject"), exports);
-__exportStar(require("./ClipartObject"), exports);
-__exportStar(require("./ImagePlaceholderObject"), exports);
-__exportStar(require("./interfaces"), exports);
-exports.default = fabric_1.fabric;
+__exportStar(require("./customizedFabric"), exports);

package/lib/utils/objectId/bson_value.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSONValue = void 0;
+const constants_1 = require("./constants");
+/** @public */
+class BSONValue {
+    /** @internal */
+    get [Symbol.for("@@mdb.bson.version")]() {
+        return constants_1.BSON_MAJOR_VERSION;
+    }
+}
+exports.BSONValue = BSONValue;

package/lib/utils/objectId/constants.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSONType = exports.BSON_BINARY_SUBTYPE_USER_DEFINED = exports.BSON_BINARY_SUBTYPE_COLUMN = exports.BSON_BINARY_SUBTYPE_ENCRYPTED = exports.BSON_BINARY_SUBTYPE_MD5 = exports.BSON_BINARY_SUBTYPE_UUID_NEW = exports.BSON_BINARY_SUBTYPE_UUID = exports.BSON_BINARY_SUBTYPE_BYTE_ARRAY = exports.BSON_BINARY_SUBTYPE_FUNCTION = exports.BSON_BINARY_SUBTYPE_DEFAULT = exports.BSON_DATA_MAX_KEY = exports.BSON_DATA_MIN_KEY = exports.BSON_DATA_DECIMAL128 = exports.BSON_DATA_LONG = exports.BSON_DATA_TIMESTAMP = exports.BSON_DATA_INT = exports.BSON_DATA_CODE_W_SCOPE = exports.BSON_DATA_SYMBOL = exports.BSON_DATA_CODE = exports.BSON_DATA_DBPOINTER = exports.BSON_DATA_REGEXP = exports.BSON_DATA_NULL = exports.BSON_DATA_DATE = exports.BSON_DATA_BOOLEAN = exports.BSON_DATA_OID = exports.BSON_DATA_UNDEFINED = exports.BSON_DATA_BINARY = exports.BSON_DATA_ARRAY = exports.BSON_DATA_OBJECT = exports.BSON_DATA_STRING = exports.BSON_DATA_NUMBER = exports.JS_INT_MIN = exports.JS_INT_MAX = exports.BSON_INT64_MIN = exports.BSON_INT64_MAX = exports.BSON_INT32_MIN = exports.BSON_INT32_MAX = exports.BSON_MAJOR_VERSION = void 0;
+/** @internal */
+exports.BSON_MAJOR_VERSION = 5;
+/** @internal */
+exports.BSON_INT32_MAX = 0x7fffffff;
+/** @internal */
+exports.BSON_INT32_MIN = -0x80000000;
+/** @internal */
+exports.BSON_INT64_MAX = Math.pow(2, 63) - 1;
+/** @internal */
+exports.BSON_INT64_MIN = -Math.pow(2, 63);
+/**
+ * Any integer up to 2^53 can be precisely represented by a double.
+ * @internal
+ */
+exports.JS_INT_MAX = Math.pow(2, 53);
+/**
+ * Any integer down to -2^53 can be precisely represented by a double.
+ * @internal
+ */
+exports.JS_INT_MIN = -Math.pow(2, 53);
+/** Number BSON Type @internal */
+exports.BSON_DATA_NUMBER = 1;
+/** String BSON Type @internal */
+exports.BSON_DATA_STRING = 2;
+/** Object BSON Type @internal */
+exports.BSON_DATA_OBJECT = 3;
+/** Array BSON Type @internal */
+exports.BSON_DATA_ARRAY = 4;
+/** Binary BSON Type @internal */
+exports.BSON_DATA_BINARY = 5;
+/** Binary BSON Type @internal */
+exports.BSON_DATA_UNDEFINED = 6;
+/** ObjectId BSON Type @internal */
+exports.BSON_DATA_OID = 7;
+/** Boolean BSON Type @internal */
+exports.BSON_DATA_BOOLEAN = 8;
+/** Date BSON Type @internal */
+exports.BSON_DATA_DATE = 9;
+/** null BSON Type @internal */
+exports.BSON_DATA_NULL = 10;
+/** RegExp BSON Type @internal */
+exports.BSON_DATA_REGEXP = 11;
+/** Code BSON Type @internal */
+exports.BSON_DATA_DBPOINTER = 12;
+/** Code BSON Type @internal */
+exports.BSON_DATA_CODE = 13;
+/** Symbol BSON Type @internal */
+exports.BSON_DATA_SYMBOL = 14;
+/** Code with Scope BSON Type @internal */
+exports.BSON_DATA_CODE_W_SCOPE = 15;
+/** 32 bit Integer BSON Type @internal */
+exports.BSON_DATA_INT = 16;
+/** Timestamp BSON Type @internal */
+exports.BSON_DATA_TIMESTAMP = 17;
+/** Long BSON Type @internal */
+exports.BSON_DATA_LONG = 18;
+/** Decimal128 BSON Type @internal */
+exports.BSON_DATA_DECIMAL128 = 19;
+/** MinKey BSON Type @internal */
+exports.BSON_DATA_MIN_KEY = 0xff;
+/** MaxKey BSON Type @internal */
+exports.BSON_DATA_MAX_KEY = 0x7f;
+/** Binary Default Type @internal */
+exports.BSON_BINARY_SUBTYPE_DEFAULT = 0;
+/** Binary Function Type @internal */
+exports.BSON_BINARY_SUBTYPE_FUNCTION = 1;
+/** Binary Byte Array Type @internal */
+exports.BSON_BINARY_SUBTYPE_BYTE_ARRAY = 2;
+/** Binary Deprecated UUID Type @deprecated Please use BSON_BINARY_SUBTYPE_UUID_NEW @internal */
+exports.BSON_BINARY_SUBTYPE_UUID = 3;
+/** Binary UUID Type @internal */
+exports.BSON_BINARY_SUBTYPE_UUID_NEW = 4;
+/** Binary MD5 Type @internal */
+exports.BSON_BINARY_SUBTYPE_MD5 = 5;
+/** Encrypted BSON type @internal */
+exports.BSON_BINARY_SUBTYPE_ENCRYPTED = 6;
+/** Column BSON type @internal */
+exports.BSON_BINARY_SUBTYPE_COLUMN = 7;
+/** Binary User Defined Type @internal */
+exports.BSON_BINARY_SUBTYPE_USER_DEFINED = 128;
+/** @public */
+exports.BSONType = Object.freeze({
+    double: 1,
+    string: 2,
+    object: 3,
+    array: 4,
+    binData: 5,
+    undefined: 6,
+    objectId: 7,
+    bool: 8,
+    date: 9,
+    null: 10,
+    regex: 11,
+    dbPointer: 12,
+    javascript: 13,
+    symbol: 14,
+    javascriptWithScope: 15,
+    int: 16,
+    timestamp: 17,
+    long: 18,
+    decimal: 19,
+    minKey: -1,
+    maxKey: 127,
+});

package/lib/utils/objectId/error.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSONRuntimeError = exports.BSONVersionError = exports.BSONError = void 0;
+const constants_1 = require("./constants");
+/**
+ * @public
+ * @category Error
+ *
+ * `BSONError` objects are thrown when BSON ecounters an error.
+ *
+ * This is the parent class for all the other errors thrown by this library.
+ */
+class BSONError extends Error {
+    /**
+     * @internal
+     * The underlying algorithm for isBSONError may change to improve how strict it is
+     * about determining if an input is a BSONError. But it must remain backwards compatible
+     * with previous minors & patches of the current major version.
+     */
+    get bsonError() {
+        return true;
+    }
+    get name() {
+        return "BSONError";
+    }
+    constructor(message) {
+        super(message);
+    }
+    /**
+     * @public
+     *
+     * All errors thrown from the BSON library inherit from `BSONError`.
+     * This method can assist with determining if an error originates from the BSON library
+     * even if it does not pass an `instanceof` check against this class' constructor.
+     *
+     * @param value - any javascript value that needs type checking
+     */
+    static isBSONError(value) {
+        return (value != null &&
+            typeof value === "object" &&
+            "bsonError" in value &&
+            value.bsonError === true &&
+            // Do not access the following properties, just check existence
+            "name" in value &&
+            "message" in value &&
+            "stack" in value);
+    }
+}
+exports.BSONError = BSONError;
+/**
+ * @public
+ * @category Error
+ */
+class BSONVersionError extends BSONError {
+    get name() {
+        return "BSONVersionError";
+    }
+    constructor() {
+        super(`Unsupported BSON version, bson types must be from bson ${constants_1.BSON_MAJOR_VERSION}.0 or later`);
+    }
+}
+exports.BSONVersionError = BSONVersionError;
+/**
+ * @public
+ * @category Error
+ *
+ * An error generated when BSON functions encounter an unexpected input
+ * or reaches an unexpected/invalid internal state
+ *
+ */
+class BSONRuntimeError extends BSONError {
+    get name() {
+        return "BSONRuntimeError";
+    }
+    constructor(message) {
+        super(message);
+    }
+}
+exports.BSONRuntimeError = BSONRuntimeError;

package/lib/utils/objectId/index.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectId = void 0;
+const bson_value_1 = require("./bson_value");
+const error_1 = require("./error");
+const utils_1 = require("./parser/utils");
+const byte_utils_1 = require("./utils/byte_utils");
+// Regular expression that checks for hex value
+const checkForHexRegExp = new RegExp("^[0-9a-fA-F]{24}$");
+// Unique sequence for the current process (initialized on first use)
+let PROCESS_UNIQUE = null;
+const kId = Symbol("id");
+/**
+ * A class representation of the BSON ObjectId type.
+ * @public
+ * @category BSONType
+ */
+class ObjectId extends bson_value_1.BSONValue {
+    get _bsontype() {
+        return "ObjectId";
+    }
+    /**
+     * Create an ObjectId type
+     *
+     * @param inputId - Can be a 24 character hex string, 12 byte binary Buffer, or a number.
+     */
+    constructor(inputId) {
+        super();
+        // workingId is set based on type of input and whether valid id exists for the input
+        let workingId;
+        if (typeof inputId === "object" && inputId && "id" in inputId) {
+            if (typeof inputId.id !== "string" && !ArrayBuffer.isView(inputId.id)) {
+                throw new error_1.BSONError("Argument passed in must have an id that is of type string or Buffer");
+            }
+            if ("toHexString" in inputId &&
+                typeof inputId.toHexString === "function") {
+                workingId = byte_utils_1.ByteUtils.fromHex(inputId.toHexString());
+            }
+            else {
+                workingId = inputId.id;
+            }
+        }
+        else {
+            workingId = inputId;
+        }
+        // the following cases use workingId to construct an ObjectId
+        if (workingId == null || typeof workingId === "number") {
+            // The most common use case (blank id, new objectId instance)
+            // Generate a new id
+            this[kId] = ObjectId.generate(typeof workingId === "number" ? workingId : undefined);
+        }
+        else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {
+            // If intstanceof matches we can escape calling ensure buffer in Node.js environments
+            this[kId] = byte_utils_1.ByteUtils.toLocalBufferType(workingId);
+        }
+        else if (typeof workingId === "string") {
+            if (workingId.length === 12) {
+                // TODO(NODE-4361): Remove string of length 12 support
+                const bytes = byte_utils_1.ByteUtils.fromUTF8(workingId);
+                if (bytes.byteLength === 12) {
+                    this[kId] = bytes;
+                }
+                else {
+                    throw new error_1.BSONError("Argument passed in must be a string of 12 bytes");
+                }
+            }
+            else if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
+                this[kId] = byte_utils_1.ByteUtils.fromHex(workingId);
+            }
+            else {
+                throw new error_1.BSONError("Argument passed in must be a string of 12 bytes or a string of 24 hex characters or an integer");
+            }
+        }
+        else {
+            throw new error_1.BSONError("Argument passed in does not match the accepted types");
+        }
+        // If we are caching the hex string
+        if (ObjectId.cacheHexString) {
+            this.__id = byte_utils_1.ByteUtils.toHex(this.id);
+        }
+    }
+    /**
+     * The ObjectId bytes
+     * @readonly
+     */
+    get id() {
+        return this[kId];
+    }
+    set id(value) {
+        this[kId] = value;
+        if (ObjectId.cacheHexString) {
+            this.__id = byte_utils_1.ByteUtils.toHex(value);
+        }
+    }
+    /** Returns the ObjectId id as a 24 character hex string representation */
+    toHexString() {
+        if (ObjectId.cacheHexString && this.__id) {
+            return this.__id;
+        }
+        const hexString = byte_utils_1.ByteUtils.toHex(this.id);
+        if (ObjectId.cacheHexString && !this.__id) {
+            this.__id = hexString;
+        }
+        return hexString;
+    }
+    /**
+     * Update the ObjectId index
+     * @internal
+     */
+    static getInc() {
+        return (ObjectId.index = (ObjectId.index + 1) % 0xffffff);
+    }
+    /**
+     * Generate a 12 byte id buffer used in ObjectId's
+     *
+     * @param time - pass in a second based timestamp.
+     */
+    static generate(time) {
+        if ("number" !== typeof time) {
+            time = Math.floor(Date.now() / 1000);
+        }
+        const inc = ObjectId.getInc();
+        const buffer = byte_utils_1.ByteUtils.allocate(12);
+        // 4-byte timestamp
+        byte_utils_1.BSONDataView.fromUint8Array(buffer).setUint32(0, time, false);
+        // set PROCESS_UNIQUE if yet not initialized
+        if (PROCESS_UNIQUE === null) {
+            PROCESS_UNIQUE = byte_utils_1.ByteUtils.randomBytes(5);
+        }
+        // 5-byte process unique
+        buffer[4] = PROCESS_UNIQUE[0];
+        buffer[5] = PROCESS_UNIQUE[1];
+        buffer[6] = PROCESS_UNIQUE[2];
+        buffer[7] = PROCESS_UNIQUE[3];
+        buffer[8] = PROCESS_UNIQUE[4];
+        // 3-byte counter
+        buffer[11] = inc & 0xff;
+        buffer[10] = (inc >> 8) & 0xff;
+        buffer[9] = (inc >> 16) & 0xff;
+        return buffer;
+    }
+    /**
+     * Converts the id into a 24 character hex string for printing, unless encoding is provided.
+     * @param encoding - hex or base64
+     */
+    toString(encoding) {
+        // Is the id a buffer then use the buffer toString method to return the format
+        if (encoding === "base64")
+            return byte_utils_1.ByteUtils.toBase64(this.id);
+        if (encoding === "hex")
+            return this.toHexString();
+        return this.toHexString();
+    }
+    /** Converts to its JSON the 24 character hex string representation. */
+    toJSON() {
+        return this.toHexString();
+    }
+    /**
+     * Compares the equality of this ObjectId with `otherID`.
+     *
+     * @param otherId - ObjectId instance to compare against.
+     */
+    equals(otherId) {
+        if (otherId === undefined || otherId === null) {
+            return false;
+        }
+        if (otherId instanceof ObjectId) {
+            return (this[kId][11] === otherId[kId][11] &&
+                byte_utils_1.ByteUtils.equals(this[kId], otherId[kId]));
+        }
+        if (typeof otherId === "string" &&
+            ObjectId.isValid(otherId) &&
+            otherId.length === 12 &&
+            (0, utils_1.isUint8Array)(this.id)) {
+            return byte_utils_1.ByteUtils.equals(this.id, byte_utils_1.ByteUtils.fromISO88591(otherId));
+        }
+        if (typeof otherId === "string" &&
+            ObjectId.isValid(otherId) &&
+            otherId.length === 24) {
+            return otherId.toLowerCase() === this.toHexString();
+        }
+        if (typeof otherId === "string" &&
+            ObjectId.isValid(otherId) &&
+            otherId.length === 12) {
+            return byte_utils_1.ByteUtils.equals(byte_utils_1.ByteUtils.fromUTF8(otherId), this.id);
+        }
+        if (typeof otherId === "object" &&
+            "toHexString" in otherId &&
+            typeof otherId.toHexString === "function") {
+            const otherIdString = otherId.toHexString();
+            const thisIdString = this.toHexString().toLowerCase();
+            return (typeof otherIdString === "string" &&
+                otherIdString.toLowerCase() === thisIdString);
+        }
+        return false;
+    }
+    /** Returns the generation date (accurate up to the second) that this ID was generated. */
+    getTimestamp() {
+        const timestamp = new Date();
+        const time = byte_utils_1.BSONDataView.fromUint8Array(this.id).getUint32(0, false);
+        timestamp.setTime(Math.floor(time) * 1000);
+        return timestamp;
+    }
+    /** @internal */
+    static createPk() {
+        return new ObjectId();
+    }
+    /**
+     * Creates an ObjectId from a second based number, with the rest of the ObjectId zeroed out. Used for comparisons or sorting the ObjectId.
+     *
+     * @param time - an integer number representing a number of seconds.
+     */
+    static createFromTime(time) {
+        const buffer = byte_utils_1.ByteUtils.fromNumberArray([
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ]);
+        // Encode time into first 4 bytes
+        byte_utils_1.BSONDataView.fromUint8Array(buffer).setUint32(0, time, false);
+        // Return the new objectId
+        return new ObjectId(buffer);
+    }
+    /**
+     * Creates an ObjectId from a hex string representation of an ObjectId.
+     *
+     * @param hexString - create a ObjectId from a passed in 24 character hexstring.
+     */
+    static createFromHexString(hexString) {
+        if (hexString?.length !== 24) {
+            throw new error_1.BSONError("hex string must be 24 characters");
+        }
+        return new ObjectId(byte_utils_1.ByteUtils.fromHex(hexString));
+    }
+    /** Creates an ObjectId instance from a base64 string */
+    static createFromBase64(base64) {
+        if (base64?.length !== 16) {
+            throw new error_1.BSONError("base64 string must be 16 characters");
+        }
+        return new ObjectId(byte_utils_1.ByteUtils.fromBase64(base64));
+    }
+    /**
+     * Checks if a value is a valid bson ObjectId
+     *
+     * @param id - ObjectId instance to validate.
+     */
+    static isValid(id) {
+        if (id == null)
+            return false;
+        try {
+            new ObjectId(id);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** @internal */
+    toExtendedJSON() {
+        if (this.toHexString)
+            return { $oid: this.toHexString() };
+        return { $oid: this.toString("hex") };
+    }
+    /** @internal */
+    static fromExtendedJSON(doc) {
+        return new ObjectId(doc.$oid);
+    }
+    /**
+     * Converts to a string representation of this Id.
+     *
+     * @returns return the 24 character hex string representation.
+     * @internal
+     */
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return this.inspect();
+    }
+    inspect() {
+        return `new ObjectId("${this.toHexString()}")`;
+    }
+}
+exports.ObjectId = ObjectId;
+/** @internal */
+ObjectId.index = Math.floor(Math.random() * 0xffffff);

package/lib/utils/objectId/parser/utils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDate = exports.isMap = exports.isRegExp = exports.isBigUInt64Array = exports.isBigInt64Array = exports.isUint8Array = exports.isAnyArrayBuffer = void 0;
+function isAnyArrayBuffer(value) {
+    return ["[object ArrayBuffer]", "[object SharedArrayBuffer]"].includes(Object.prototype.toString.call(value));
+}
+exports.isAnyArrayBuffer = isAnyArrayBuffer;
+function isUint8Array(value) {
+    return Object.prototype.toString.call(value) === "[object Uint8Array]";
+}
+exports.isUint8Array = isUint8Array;
+function isBigInt64Array(value) {
+    return Object.prototype.toString.call(value) === "[object BigInt64Array]";
+}
+exports.isBigInt64Array = isBigInt64Array;
+function isBigUInt64Array(value) {
+    return Object.prototype.toString.call(value) === "[object BigUint64Array]";
+}
+exports.isBigUInt64Array = isBigUInt64Array;
+function isRegExp(d) {
+    return Object.prototype.toString.call(d) === "[object RegExp]";
+}
+exports.isRegExp = isRegExp;
+function isMap(d) {
+    return Object.prototype.toString.call(d) === "[object Map]";
+}
+exports.isMap = isMap;
+function isDate(d) {
+    return Object.prototype.toString.call(d) === "[object Date]";
+}
+exports.isDate = isDate;

package/lib/utils/objectId/utils/byte_utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSONDataView = exports.ByteUtils = void 0;
+const node_byte_utils_1 = require("./node_byte_utils");
+const web_byte_utils_1 = require("./web_byte_utils");
+/**
+ * Check that a global Buffer exists that is a function and
+ * does not have a '_isBuffer' property defined on the prototype
+ * (this is to prevent using the npm buffer)
+ */
+const hasGlobalBuffer = typeof Buffer === "function" && Buffer.prototype?._isBuffer !== true;
+/**
+ * This is the only ByteUtils that should be used across the rest of the BSON library.
+ *
+ * The type annotation is important here, it asserts that each of the platform specific
+ * utils implementations are compatible with the common one.
+ *
+ * @internal
+ */
+exports.ByteUtils = hasGlobalBuffer
+    ? node_byte_utils_1.nodeJsByteUtils
+    : web_byte_utils_1.webByteUtils;
+class BSONDataView extends DataView {
+    static fromUint8Array(input) {
+        return new DataView(input.buffer, input.byteOffset, input.byteLength);
+    }
+}
+exports.BSONDataView = BSONDataView;