customized-fabric 1.0.2 → 1.0.4

package/lib/customizedFabric/ClipartObject/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const CLIPART_OBJECT_ATTRIBUTES: {
+    name: string;
+    type: string;
+    stroke: {
+        stroke: string;
+        strokeDashArray: number[];
+        strokeWidth: number;
+    };
+};

package/lib/customizedFabric/ClipartObject/index.d.ts

@@ -0,0 +1,19 @@
+import { fabric } from "fabric";
+import { ObjectId } from "@/utils/objectId";
+import { ClipartObject, IClipartOptions } from "./interfaces";
+export declare const toClipartObject: (clipartObject: ClipartObject) => {
+    id: ObjectId;
+    personalizeId: number | undefined;
+    layerId: number | undefined;
+    name: string | undefined;
+    locked: boolean | undefined;
+    isAdditional: boolean | undefined;
+    clipartUrl: string | undefined;
+    clipartFile: File | undefined;
+    clipartRootCategoryId: string | undefined;
+    clipartCategoryId: string | undefined;
+    clipartOptionId: number | undefined;
+};
+export declare class Clipart extends fabric.Group {
+    constructor(options?: IClipartOptions);
+}

package/lib/customizedFabric/ClipartObject/interfaces.d.ts

@@ -0,0 +1,30 @@
+import { ObjectId } from "@/utils/objectId";
+export interface ClipartObject extends fabric.Group {
+    _id: ObjectId;
+    layerId?: number;
+    locked?: boolean;
+    isAdditional?: boolean;
+    clipartFile?: File;
+    clipartRootCategoryId?: string;
+    clipartRootCategoryName?: string;
+    clipartCategoryId?: string;
+    clipartCategoryName?: string;
+    clipartOptionId?: number;
+    imageObject?: fabric.Image;
+    clipartUrl?: string;
+    loadImageFromFile: (imageFile: File) => void;
+    loadImageFromUrl: (imageUrl: string) => void;
+    getSettings: (attribute: string) => any;
+    setSizes: (options: {
+        width?: number;
+        height?: number;
+    }) => void;
+}
+export interface IClipartOptions extends fabric.IGroupOptions {
+    _id?: string;
+    personalizeId?: number;
+    layerId: number;
+    clipartUrl?: string;
+    clipartFile?: File;
+    hideStroke?: boolean;
+}

package/lib/customizedFabric/ImagePlaceholderObject/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const IMAGE_PLACEHOLDER_OBJECT_ATTRIBUTES: {
+    name: string;
+    type: string;
+    stroke: {
+        stroke: string;
+        strokeDashArray: number[];
+        strokeWidth: number;
+    };
+};

package/lib/customizedFabric/ImagePlaceholderObject/index.d.ts

@@ -0,0 +1,14 @@
+import { fabric } from "fabric";
+import { ObjectId } from "@/utils/objectId";
+import { IImagePlaceholderOptions, ImagePlaceholderObject } from "./interfaces";
+export declare const toImagePlaceholderObject: (imagePlaceholderObject: ImagePlaceholderObject) => {
+    id: ObjectId;
+    personalizeId: number;
+    layerId: number;
+    name: string | undefined;
+    locked: boolean;
+    isAdditional: boolean;
+};
+export declare class ImagePlaceholder extends fabric.Group {
+    constructor(options?: IImagePlaceholderOptions);
+}

package/lib/customizedFabric/ImagePlaceholderObject/interfaces.d.ts

@@ -0,0 +1,22 @@
+import { ObjectId } from "@/utils/objectId";
+export interface ImagePlaceholderObject extends fabric.Group {
+    _id: ObjectId;
+    layerId: number;
+    locked: boolean;
+    imageFile?: File;
+    isAdditional: boolean;
+    loadImageFromFile: (imageFile: File) => void;
+    loadImageFromUrl: (imageUrl: string) => void;
+    getSettings: (attribute: string) => any;
+    setSizes: (options: {
+        width?: number;
+        height?: number;
+    }) => void;
+}
+export interface IImagePlaceholderOptions extends fabric.IGroupOptions {
+    _id?: string;
+    personalizeId?: number;
+    layerId: number;
+    imageFile?: File;
+    hideStroke?: boolean;
+}

package/lib/customizedFabric/TextInputObject/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const TEXT_INPUT_OBJECT_ATTRIBUTES: {
+    name: string;
+    type: string;
+    maxFontSize: number;
+    stroke: {
+        stroke: string;
+        strokeDashArray: number[];
+        strokeWidth: number;
+    };
+};
+export declare const PARENT_ATTRIBUTES: string[];

package/lib/customizedFabric/TextInputObject/index.d.ts

@@ -0,0 +1,30 @@
+import { fabric } from "fabric";
+import { ObjectId } from "@/utils/objectId";
+import { ITextInputOptions, TextInputObject } from "./interfaces";
+export declare const toTextInputObject: (textInputObject: TextInputObject) => {
+    id: ObjectId;
+    personalizeId: number;
+    layerId: number;
+    name: string | undefined;
+    locked: boolean;
+    fontId: number;
+    fontCategoryId: string;
+    fontUrl: string;
+    isAdditional: boolean;
+    text: {
+        fontWeight: string | number | undefined;
+        fontSize: number | undefined;
+        textAlign: string | undefined;
+        text: string | undefined;
+        fill: string | fabric.Gradient | fabric.Pattern | undefined;
+        width: number | undefined;
+        height: number | undefined;
+        fontFamily: string | undefined;
+        maxFontSize: any;
+        stroke: string | undefined;
+        strokeWidth: number | undefined;
+    };
+};
+export declare class TextInput extends fabric.Group {
+    constructor(options?: ITextInputOptions);
+}

package/lib/customizedFabric/TextInputObject/interfaces.d.ts

@@ -0,0 +1,41 @@
+import { ObjectId } from "@/utils/objectId";
+export interface TextInputObject extends fabric.Group {
+    _id: ObjectId;
+    layerId: number;
+    locked: boolean;
+    textObject: fabric.IText;
+    fontId: number;
+    fontCategoryId: string;
+    fontUrl: string;
+    isAdditional: boolean;
+    setText: (text: string) => void;
+    setMaxFontSize: (fontSize: string) => void;
+    setFontFamily: (fontName: string, fontUrl?: string) => void;
+    setTextAttributes: (options: fabric.ITextOptions) => void;
+    getTextAttribute: (attribute: string) => any;
+    getSettings: (attribute: string) => any;
+    setSizes: (options: {
+        width?: number;
+        height?: number;
+    }) => void;
+}
+export interface ITextInputOptions extends fabric.IGroupOptions {
+    _id?: ObjectId;
+    personalizeId?: string;
+    layerId: number;
+    text: {
+        fontSize?: number;
+        fill?: string;
+        width?: number;
+        height?: number;
+        textAlign?: string;
+        fontWeight?: string;
+        text: string;
+        fontFamily?: string;
+        maxFontSize: number;
+        stroke?: string;
+        strokeWidth?: number;
+    };
+    fontUrl?: string;
+    hideStroke?: boolean;
+}

package/lib/customizedFabric/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const OBJECT_TYPES: {
+    textInput: string;
+    clipart: string;
+    imagePlaceHolder: string;
+    activeSelection: string;
+};

package/lib/customizedFabric/index.d.ts

@@ -0,0 +1,8 @@
+import { fabric } from "fabric";
+export * from "./TextInputObject";
+export * from "./ClipartObject";
+export * from "./ImagePlaceholderObject";
+export * from "./constants";
+export * from "./interfaces";
+export * from "./utils";
+export default fabric;

package/lib/customizedFabric/interfaces.d.ts

@@ -0,0 +1,3 @@
+export * from "./TextInputObject/interfaces";
+export * from "./ClipartObject/interfaces";
+export * from "./ImagePlaceholderObject/interfaces";

package/lib/customizedFabric/utils.d.ts

@@ -0,0 +1,11 @@
+import { fabric } from "fabric";
+import { Clipart, TextInput } from ".";
+import { ImagePlaceholder } from "./ImagePlaceholderObject";
+export declare const loadFontFromUrl: (name: string, url: string) => Promise<void>;
+export declare const isFontLoaded: (name: string) => boolean;
+export declare const loadImageFromFile: (image: File) => Promise<fabric.Image>;
+export declare const lockObject: (object: fabric.Object | any, locked: boolean, selectable?: boolean) => void;
+export declare const lockAllObjects: (canvas: fabric.Canvas, locked: boolean) => void;
+export declare const getObject: (object: any, options?: {
+    isOriginal?: boolean;
+}) => ImagePlaceholder | TextInput | Clipart | undefined;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from "./customizedFabric";

package/lib/utils/objectId/bson_value.d.ts

@@ -0,0 +1,9 @@
+/** @public */
+export declare abstract class BSONValue {
+    /** @public */
+    abstract get _bsontype(): string;
+    /** @public */
+    abstract inspect(): string;
+    /** @internal */
+    abstract toExtendedJSON(): unknown;
+}

package/lib/utils/objectId/constants.d.ts

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

package/lib/utils/objectId/error.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @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.
+ */
+export declare 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.
+     */
+    protected get bsonError(): true;
+    get name(): string;
+    constructor(message: string);
+    /**
+     * @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: unknown): value is BSONError;
+}
+/**
+ * @public
+ * @category Error
+ */
+export declare class BSONVersionError extends BSONError {
+    get name(): "BSONVersionError";
+    constructor();
+}
+/**
+ * @public
+ * @category Error
+ *
+ * An error generated when BSON functions encounter an unexpected input
+ * or reaches an unexpected/invalid internal state
+ *
+ */
+export declare class BSONRuntimeError extends BSONError {
+    get name(): "BSONRuntimeError";
+    constructor(message: string);
+}

package/lib/utils/objectId/index.d.ts

@@ -0,0 +1,95 @@
+import { BSONValue } from "./bson_value";
+/** @public */
+export interface ObjectIdLike {
+    id: string | Uint8Array;
+    __id?: string;
+    toHexString(): string;
+}
+/** @public */
+export interface ObjectIdExtended {
+    $oid: string;
+}
+declare const kId: unique symbol;
+/**
+ * A class representation of the BSON ObjectId type.
+ * @public
+ * @category BSONType
+ */
+export declare class ObjectId extends BSONValue {
+    get _bsontype(): "ObjectId";
+    /** @internal */
+    private static index;
+    static cacheHexString: boolean;
+    /** ObjectId Bytes @internal */
+    private [kId];
+    /** ObjectId hexString cache @internal */
+    private __id?;
+    /**
+     * Create an ObjectId type
+     *
+     * @param inputId - Can be a 24 character hex string, 12 byte binary Buffer, or a number.
+     */
+    constructor(inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array);
+    /**
+     * The ObjectId bytes
+     * @readonly
+     */
+    get id(): Uint8Array;
+    set id(value: Uint8Array);
+    /** Returns the ObjectId id as a 24 character hex string representation */
+    toHexString(): string;
+    /**
+     * Update the ObjectId index
+     * @internal
+     */
+    private static getInc;
+    /**
+     * Generate a 12 byte id buffer used in ObjectId's
+     *
+     * @param time - pass in a second based timestamp.
+     */
+    static generate(time?: number): Uint8Array;
+    /**
+     * Converts the id into a 24 character hex string for printing, unless encoding is provided.
+     * @param encoding - hex or base64
+     */
+    toString(encoding?: "hex" | "base64"): string;
+    /** Converts to its JSON the 24 character hex string representation. */
+    toJSON(): string;
+    /**
+     * Compares the equality of this ObjectId with `otherID`.
+     *
+     * @param otherId - ObjectId instance to compare against.
+     */
+    equals(otherId: string | ObjectId | ObjectIdLike): boolean;
+    /** Returns the generation date (accurate up to the second) that this ID was generated. */
+    getTimestamp(): Date;
+    /** @internal */
+    static createPk(): 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: number): ObjectId;
+    /**
+     * 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: string): ObjectId;
+    /** Creates an ObjectId instance from a base64 string */
+    static createFromBase64(base64: string): ObjectId;
+    /**
+     * Checks if a value is a valid bson ObjectId
+     *
+     * @param id - ObjectId instance to validate.
+     */
+    static isValid(id: string | number | ObjectId | ObjectIdLike | Uint8Array): boolean;
+    /** @internal */
+    toExtendedJSON(): ObjectIdExtended;
+    /** @internal */
+    static fromExtendedJSON(doc: ObjectIdExtended): ObjectId;
+    inspect(): string;
+}
+export {};

package/lib/utils/objectId/parser/utils.d.ts

@@ -0,0 +1,7 @@
+export declare function isAnyArrayBuffer(value: unknown): value is ArrayBuffer;
+export declare function isUint8Array(value: unknown): value is Uint8Array;
+export declare function isBigInt64Array(value: unknown): value is BigInt64Array;
+export declare function isBigUInt64Array(value: unknown): value is BigUint64Array;
+export declare function isRegExp(d: unknown): d is RegExp;
+export declare function isMap(d: unknown): d is Map<unknown, unknown>;
+export declare function isDate(d: unknown): d is Date;

package/lib/utils/objectId/utils/byte_utils.d.ts

@@ -0,0 +1,45 @@
+/** @internal */
+export type ByteUtils = {
+    /** Transforms the input to an instance of Buffer if running on node, otherwise Uint8Array */
+    toLocalBufferType(buffer: Uint8Array | ArrayBufferView | ArrayBuffer): Uint8Array;
+    /** Create empty space of size */
+    allocate: (size: number) => Uint8Array;
+    /** Check if two Uint8Arrays are deep equal */
+    equals: (a: Uint8Array, b: Uint8Array) => boolean;
+    /** Check if two Uint8Arrays are deep equal */
+    fromNumberArray: (array: number[]) => Uint8Array;
+    /** Create a Uint8Array from a base64 string */
+    fromBase64: (base64: string) => Uint8Array;
+    /** Create a base64 string from bytes */
+    toBase64: (buffer: Uint8Array) => string;
+    /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */
+    fromISO88591: (codePoints: string) => Uint8Array;
+    /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */
+    toISO88591: (buffer: Uint8Array) => string;
+    /** Create a Uint8Array from a hex string */
+    fromHex: (hex: string) => Uint8Array;
+    /** Create a hex string from bytes */
+    toHex: (buffer: Uint8Array) => string;
+    /** Create a Uint8Array containing utf8 code units from a string */
+    fromUTF8: (text: string) => Uint8Array;
+    /** Create a string from utf8 code units */
+    toUTF8: (buffer: Uint8Array, start: number, end: number) => string;
+    /** Get the utf8 code unit count from a string if it were to be transformed to utf8 */
+    utf8ByteLength: (input: string) => number;
+    /** Encode UTF8 bytes generated from `source` string into `destination` at byteOffset. Returns the number of bytes encoded. */
+    encodeUTF8Into(destination: Uint8Array, source: string, byteOffset: number): number;
+    /** Generate a Uint8Array filled with random bytes with byteLength */
+    randomBytes(byteLength: number): Uint8Array;
+};
+/**
+ * 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
+ */
+export declare const ByteUtils: ByteUtils;
+export declare class BSONDataView extends DataView {
+    static fromUint8Array(input: Uint8Array): DataView;
+}

package/lib/utils/objectId/utils/node_byte_utils.d.ts

@@ -0,0 +1,30 @@
+type NodeJsEncoding = "base64" | "hex" | "utf8" | "binary";
+type NodeJsBuffer = ArrayBufferView & Uint8Array & {
+    write(string: string, offset: number, length: undefined, encoding: "utf8"): number;
+    copy(target: Uint8Array, targetStart: number, sourceStart: number, sourceEnd: number): number;
+    toString: (this: Uint8Array, encoding: NodeJsEncoding, start?: number, end?: number) => string;
+    equals: (this: Uint8Array, other: Uint8Array) => boolean;
+};
+/** @internal */
+export declare function nodejsMathRandomBytes(byteLength: number): NodeJsBuffer;
+/** @internal */
+export declare const nodeJsByteUtils: {
+    toLocalBufferType(potentialBuffer: Uint8Array | NodeJsBuffer | ArrayBuffer): NodeJsBuffer;
+    allocate(size: number): NodeJsBuffer;
+    equals(a: Uint8Array, b: Uint8Array): boolean;
+    fromNumberArray(array: number[]): NodeJsBuffer;
+    fromBase64(base64: string): NodeJsBuffer;
+    toBase64(buffer: Uint8Array): string;
+    /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */
+    fromISO88591(codePoints: string): NodeJsBuffer;
+    /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */
+    toISO88591(buffer: Uint8Array): string;
+    fromHex(hex: string): NodeJsBuffer;
+    toHex(buffer: Uint8Array): string;
+    fromUTF8(text: string): NodeJsBuffer;
+    toUTF8(buffer: Uint8Array, start: number, end: number): string;
+    utf8ByteLength(input: string): number;
+    encodeUTF8Into(buffer: Uint8Array, source: string, byteOffset: number): number;
+    randomBytes: (byteLength: number) => Uint8Array;
+};
+export {};

package/lib/utils/objectId/utils/web_byte_utils.d.ts

@@ -0,0 +1,26 @@
+type ArrayBufferViewWithTag = ArrayBufferView & {
+    [Symbol.toStringTag]?: string;
+};
+/** @internal */
+export declare function webMathRandomBytes(byteLength: number): Uint8Array;
+/** @internal */
+export declare const webByteUtils: {
+    toLocalBufferType(potentialUint8array: Uint8Array | ArrayBufferViewWithTag | ArrayBuffer): Uint8Array;
+    allocate(size: number): Uint8Array;
+    equals(a: Uint8Array, b: Uint8Array): boolean;
+    fromNumberArray(array: number[]): Uint8Array;
+    fromBase64(base64: string): Uint8Array;
+    toBase64(uint8array: Uint8Array): string;
+    /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */
+    fromISO88591(codePoints: string): Uint8Array;
+    /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */
+    toISO88591(uint8array: Uint8Array): string;
+    fromHex(hex: string): Uint8Array;
+    toHex(uint8array: Uint8Array): string;
+    fromUTF8(text: string): Uint8Array;
+    toUTF8(uint8array: Uint8Array, start: number, end: number): string;
+    utf8ByteLength(input: string): number;
+    encodeUTF8Into(buffer: Uint8Array, source: string, byteOffset: number): number;
+    randomBytes: (byteLength: number) => Uint8Array;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "customized-fabric",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Customized fabric",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -15,6 +15,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@types/node": "^18.15.11",
     "fabric": "^5.3.0"
   },
   "devDependencies": {