@kikiutils/shared 14.0.1 → 14.1.0

package/dist/buffer.d.ts

@@ -4,34 +4,33 @@ import { Buffer } from "node:buffer";
 //#region src/buffer.d.ts
 
 /**
- * Converts a Blob, Buffer, or File to a Buffer.
+ * Converts various binary data types to a Node.js Buffer.
  *
- * This function provides a unified way to convert various binary data types
- * to Node.js Buffer. If the input is already a Buffer, it returns it as-is.
- * For Blob or File inputs, it converts them to Buffer via ArrayBuffer.
+ * This function provides a unified, efficient way to convert different binary formats
+ * (Blob, Buffer, File, ArrayBuffer, or Uint8Array) into a Node.js Buffer.
+ * It prioritizes zero-copy conversions for TypedArrays and ArrayBuffers to ensure
+ * optimal performance.
  *
- * @param {Blob | Buffer | File} input - The input to convert to Buffer
+ * @param {ArrayBuffer | Blob | Buffer | File | Uint8Array} input - The binary data input to convert.
+ * Supports Blob, Buffer, File, ArrayBuffer, and Uint8Array.
  *
- * @returns {Promise<Buffer>} A Promise that resolves to a Buffer
+ * @returns {Promise<Buffer>} A promise that resolves to a Node.js Buffer.
  *
  * @example
  * ```typescript
- * import { toBuffer } from '@kikiutils/shared/general';
+ * import { toBuffer } from '@kikiutils/shared/buffer';
  *
- * // Convert a Buffer (returns as-is)
- * const buffer = Buffer.from('Hello World');
- * const result1 = await toBuffer(buffer);
- * console.log(result1); // <Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64>
+ * // From ArrayBuffer
+ * const ab = new ArrayBuffer(8);
+ * const bufferFromAB = await toBuffer(ab);
  *
- * // Convert a Blob
- * const blob = new Blob(['Hello from Blob'], { type: 'text/plain' });
- * const result2 = await toBuffer(blob);
- * console.log(result2.toString()); // 'Hello from Blob'
+ * // From Uint8Array (Zero-copy)
+ * const u8 = new Uint8Array([10, 20, 30]);
+ * const bufferFromU8 = await toBuffer(u8);
  *
- * // Convert a File
- * const file = new File(['File content'], 'test.txt', { type: 'text/plain' });
- * const result3 = await toBuffer(file);
- * console.log(result3.toString()); // 'File content'
+ * // From Blob or File
+ * const blob = new Blob(['data'], { type: 'text/plain' });
+ * const bufferFromBlob = await toBuffer(blob);
  * ```
  */
 declare function toBuffer(input: BinaryInput): Promise<Buffer<ArrayBufferLike>>;

package/dist/buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buffer.d.ts","names":[],"sources":["../src/buffer.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,QAAA,QAAgB,cAAW,QAAA,OAAA"}
+{"version":3,"file":"buffer.d.ts","names":[],"sources":["../src/buffer.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,QAAA,QAAgB,cAAW,QAAA,OAAA"}

package/dist/buffer.js

@@ -2,39 +2,41 @@ import { Buffer } from "node:buffer";
 
 //#region src/buffer.ts
 /**
-* Converts a Blob, Buffer, or File to a Buffer.
+* Converts various binary data types to a Node.js Buffer.
 *
-* This function provides a unified way to convert various binary data types
-* to Node.js Buffer. If the input is already a Buffer, it returns it as-is.
-* For Blob or File inputs, it converts them to Buffer via ArrayBuffer.
+* This function provides a unified, efficient way to convert different binary formats
+* (Blob, Buffer, File, ArrayBuffer, or Uint8Array) into a Node.js Buffer.
+* It prioritizes zero-copy conversions for TypedArrays and ArrayBuffers to ensure
+* optimal performance.
 *
-* @param {Blob | Buffer | File} input - The input to convert to Buffer
+* @param {ArrayBuffer | Blob | Buffer | File | Uint8Array} input - The binary data input to convert.
+* Supports Blob, Buffer, File, ArrayBuffer, and Uint8Array.
 *
-* @returns {Promise<Buffer>} A Promise that resolves to a Buffer
+* @returns {Promise<Buffer>} A promise that resolves to a Node.js Buffer.
 *
 * @example
 * ```typescript
-* import { toBuffer } from '@kikiutils/shared/general';
+* import { toBuffer } from '@kikiutils/shared/buffer';
 *
-* // Convert a Buffer (returns as-is)
-* const buffer = Buffer.from('Hello World');
-* const result1 = await toBuffer(buffer);
-* console.log(result1); // <Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64>
+* // From ArrayBuffer
+* const ab = new ArrayBuffer(8);
+* const bufferFromAB = await toBuffer(ab);
 *
-* // Convert a Blob
-* const blob = new Blob(['Hello from Blob'], { type: 'text/plain' });
-* const result2 = await toBuffer(blob);
-* console.log(result2.toString()); // 'Hello from Blob'
+* // From Uint8Array (Zero-copy)
+* const u8 = new Uint8Array([10, 20, 30]);
+* const bufferFromU8 = await toBuffer(u8);
 *
-* // Convert a File
-* const file = new File(['File content'], 'test.txt', { type: 'text/plain' });
-* const result3 = await toBuffer(file);
-* console.log(result3.toString()); // 'File content'
+* // From Blob or File
+* const blob = new Blob(['data'], { type: 'text/plain' });
+* const bufferFromBlob = await toBuffer(blob);
 * ```
 */
 async function toBuffer(input) {
 	if (Buffer.isBuffer(input)) return input;
-	return Buffer.from(await input.arrayBuffer());
+	if (input instanceof ArrayBuffer) return Buffer.from(input);
+	if (input instanceof Uint8Array) return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+	if (typeof input.arrayBuffer === "function") return Buffer.from(await input.arrayBuffer());
+	throw new TypeError("The provided input is not a supported binary type (Blob, Buffer, File, ArrayBuffer, or Uint8Array).");
 }
 
 //#endregion

package/dist/buffer.js.map

@@ -1 +1 @@
-{"version":3,"file":"buffer.js","names":[],"sources":["../src/buffer.ts"],"sourcesContent":["import { Buffer } from 'node:buffer';\n\nimport type { BinaryInput } from './types';\n\n/**\n * Converts a Blob, Buffer, or File to a Buffer.\n *\n * This function provides a unified way to convert various binary data types\n * to Node.js Buffer. If the input is already a Buffer, it returns it as-is.\n * For Blob or File inputs, it converts them to Buffer via ArrayBuffer.\n *\n * @param {Blob | Buffer | File} input - The input to convert to Buffer\n *\n * @returns {Promise<Buffer>} A Promise that resolves to a Buffer\n *\n * @example\n * ```typescript\n * import { toBuffer } from '@kikiutils/shared/general';\n *\n * // Convert a Buffer (returns as-is)\n * const buffer = Buffer.from('Hello World');\n * const result1 = await toBuffer(buffer);\n * console.log(result1); // <Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64>\n *\n * // Convert a Blob\n * const blob = new Blob(['Hello from Blob'], { type: 'text/plain' });\n * const result2 = await toBuffer(blob);\n * console.log(result2.toString()); // 'Hello from Blob'\n *\n * // Convert a File\n * const file = new File(['File content'], 'test.txt', { type: 'text/plain' });\n * const result3 = await toBuffer(file);\n * console.log(result3.toString()); // 'File content'\n * ```\n */\nexport async function toBuffer(input: BinaryInput) {\n    if (Buffer.isBuffer(input)) return input;\n    return Buffer.from(await input.arrayBuffer());\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,eAAsB,SAAS,OAAoB;AAC/C,KAAI,OAAO,SAAS,MAAM,CAAE,QAAO;AACnC,QAAO,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC"}
+{"version":3,"file":"buffer.js","names":[],"sources":["../src/buffer.ts"],"sourcesContent":["import { Buffer } from 'node:buffer';\n\nimport type { BinaryInput } from './types';\n\n/**\n * Converts various binary data types to a Node.js Buffer.\n *\n * This function provides a unified, efficient way to convert different binary formats\n * (Blob, Buffer, File, ArrayBuffer, or Uint8Array) into a Node.js Buffer.\n * It prioritizes zero-copy conversions for TypedArrays and ArrayBuffers to ensure\n * optimal performance.\n *\n * @param {ArrayBuffer | Blob | Buffer | File | Uint8Array} input - The binary data input to convert.\n * Supports Blob, Buffer, File, ArrayBuffer, and Uint8Array.\n *\n * @returns {Promise<Buffer>} A promise that resolves to a Node.js Buffer.\n *\n * @example\n * ```typescript\n * import { toBuffer } from '@kikiutils/shared/buffer';\n *\n * // From ArrayBuffer\n * const ab = new ArrayBuffer(8);\n * const bufferFromAB = await toBuffer(ab);\n *\n * // From Uint8Array (Zero-copy)\n * const u8 = new Uint8Array([10, 20, 30]);\n * const bufferFromU8 = await toBuffer(u8);\n *\n * // From Blob or File\n * const blob = new Blob(['data'], { type: 'text/plain' });\n * const bufferFromBlob = await toBuffer(blob);\n * ```\n */\nexport async function toBuffer(input: BinaryInput) {\n    if (Buffer.isBuffer(input)) return input;\n    if (input instanceof ArrayBuffer) return Buffer.from(input);\n    if (input instanceof Uint8Array) return Buffer.from(input.buffer, input.byteOffset, input.byteLength);\n    if (typeof input.arrayBuffer === 'function') return Buffer.from(await input.arrayBuffer());\n    // eslint-disable-next-line style/max-len\n    throw new TypeError('The provided input is not a supported binary type (Blob, Buffer, File, ArrayBuffer, or Uint8Array).');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,eAAsB,SAAS,OAAoB;AAC/C,KAAI,OAAO,SAAS,MAAM,CAAE,QAAO;AACnC,KAAI,iBAAiB,YAAa,QAAO,OAAO,KAAK,MAAM;AAC3D,KAAI,iBAAiB,WAAY,QAAO,OAAO,KAAK,MAAM,QAAQ,MAAM,YAAY,MAAM,WAAW;AACrG,KAAI,OAAO,MAAM,gBAAgB,WAAY,QAAO,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAE1F,OAAM,IAAI,UAAU,sGAAsG"}

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@ import { Blob as Blob$1, Buffer, File as File$1 } from "node:buffer";
 
 //#region src/types/index.d.ts
 type AnyRecord = Record<string, any>;
-type BinaryInput = Blob | Buffer | File | Blob$1 | File$1;
+type BinaryInput = ArrayBuffer | Blob | Buffer | File | Blob$1 | File$1 | Uint8Array;
 type Booleanish = 'false' | 'true' | boolean;
 type MaybePartial<T> = Partial<T> | T;
 type MaybeReadonly<T> = Readonly<T> | T;

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":[],"mappings":";;;;KAQY,SAAA,GAAY;KACZ,WAAA,GAAc,OAAO,SAAS,OAAO,SAAW;AADhD,KAEA,UAAA,GAFS,OAAG,GAAM,MAAA,GAAA,OAAA;AAClB,KAEA,YAFW,CAAA,CAAA,CAAA,GAEO,OAFP,CAEe,CAFf,CAAA,GAEoB,CAFpB;AAAG,KAGd,aAHc,CAAA,CAAA,CAAA,GAGK,QAHL,CAGc,CAHd,CAAA,GAGmB,CAHnB;AAAO,KAIrB,QAJqB,CAAA,CAAA,CAAA,GAAA,IAAA,GAIA,CAJA;AAAS,KAK9B,SAAA,GAL8B,MAAA,GAAA,MAAA;AAAO,KAMrC,aANqC,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAMG,OANH,CAMW,MANX,CAMkB,CANlB,EAMqB,CANrB,CAAA,CAAA;AAAW,KAOhD,qBAPgD,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAOA,QAPA,CAOS,aAPT,CAOuB,CAPvB,EAO0B,CAP1B,CAAA,CAAA;AAAQ,KAQxD,cARwD,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAQf,QARe,CAQN,MARM,CAQC,CARD,EAQI,CARJ,CAAA,CAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":[],"mappings":";;;;KAQY,SAAA,GAAY;KACZ,WAAA,GAAc,cAAc,OAAO,SAAS,OAAO,SAAW,SAAW;AADzE,KAEA,UAAA,GAFS,OAAG,GAAM,MAAA,GAAA,OAAA;AAClB,KAEA,YAFW,CAAA,CAAA,CAAA,GAEO,OAFP,CAEe,CAFf,CAAA,GAEoB,CAFpB;AAAG,KAGd,aAHc,CAAA,CAAA,CAAA,GAGK,QAHL,CAGc,CAHd,CAAA,GAGmB,CAHnB;AAAc,KAI5B,QAJ4B,CAAA,CAAA,CAAA,GAAA,IAAA,GAIP,CAJO;AAAO,KAKnC,SAAA,GALmC,MAAA,GAAA,MAAA;AAAS,KAM5C,aAN4C,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAMJ,OANI,CAMI,MANJ,CAMW,CANX,EAMc,CANd,CAAA,CAAA;AAAO,KAOnD,qBAPmD,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAOH,QAPG,CAOM,aAPN,CAOoB,CAPpB,EAOuB,CAPvB,CAAA,CAAA;AAAW,KAQ9D,cAR8D,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAQrB,QARqB,CAQZ,MARY,CAQL,CARK,EAQF,CARE,CAAA,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kikiutils/shared",
   "type": "module",
-  "version": "14.0.1",
+  "version": "14.1.0",
   "description": "A lightweight and modular utility library for modern JavaScript and TypeScript — includes secure hashing, flexible logging, datetime tools, Vue/web helpers, storage abstraction, and more.",
   "author": "kiki-kanri",
   "license": "MIT",
@@ -170,7 +170,7 @@
     "depcheck": "^1.4.7",
     "element-plus": "^2.13.0",
     "fs-extra": "^11.3.3",
-    "jsdom": "^27.3.0",
+    "jsdom": "^27.4.0",
     "lru-cache": "^11.2.4",
     "millify": "^6.1.0",
     "msgpackr": "^1.11.8",
@@ -179,7 +179,7 @@
     "pino-pretty": "^13.1.3",
     "publint": "^0.3.16",
     "ts-unused-exports": "^11.0.1",
-    "tsdown": "^0.18.3",
+    "tsdown": "^0.18.4",
     "typescript": "^5.9.3",
     "unplugin-unused": "^0.5.6",
     "vitest": "^4.0.16",

package/src/buffer.ts

@@ -3,37 +3,40 @@ import { Buffer } from 'node:buffer';
 import type { BinaryInput } from './types';
 
 /**
- * Converts a Blob, Buffer, or File to a Buffer.
+ * Converts various binary data types to a Node.js Buffer.
  *
- * This function provides a unified way to convert various binary data types
- * to Node.js Buffer. If the input is already a Buffer, it returns it as-is.
- * For Blob or File inputs, it converts them to Buffer via ArrayBuffer.
+ * This function provides a unified, efficient way to convert different binary formats
+ * (Blob, Buffer, File, ArrayBuffer, or Uint8Array) into a Node.js Buffer.
+ * It prioritizes zero-copy conversions for TypedArrays and ArrayBuffers to ensure
+ * optimal performance.
  *
- * @param {Blob | Buffer | File} input - The input to convert to Buffer
+ * @param {ArrayBuffer | Blob | Buffer | File | Uint8Array} input - The binary data input to convert.
+ * Supports Blob, Buffer, File, ArrayBuffer, and Uint8Array.
  *
- * @returns {Promise<Buffer>} A Promise that resolves to a Buffer
+ * @returns {Promise<Buffer>} A promise that resolves to a Node.js Buffer.
  *
  * @example
  * ```typescript
- * import { toBuffer } from '@kikiutils/shared/general';
+ * import { toBuffer } from '@kikiutils/shared/buffer';
  *
- * // Convert a Buffer (returns as-is)
- * const buffer = Buffer.from('Hello World');
- * const result1 = await toBuffer(buffer);
- * console.log(result1); // <Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64>
+ * // From ArrayBuffer
+ * const ab = new ArrayBuffer(8);
+ * const bufferFromAB = await toBuffer(ab);
  *
- * // Convert a Blob
- * const blob = new Blob(['Hello from Blob'], { type: 'text/plain' });
- * const result2 = await toBuffer(blob);
- * console.log(result2.toString()); // 'Hello from Blob'
+ * // From Uint8Array (Zero-copy)
+ * const u8 = new Uint8Array([10, 20, 30]);
+ * const bufferFromU8 = await toBuffer(u8);
  *
- * // Convert a File
- * const file = new File(['File content'], 'test.txt', { type: 'text/plain' });
- * const result3 = await toBuffer(file);
- * console.log(result3.toString()); // 'File content'
+ * // From Blob or File
+ * const blob = new Blob(['data'], { type: 'text/plain' });
+ * const bufferFromBlob = await toBuffer(blob);
  * ```
  */
 export async function toBuffer(input: BinaryInput) {
     if (Buffer.isBuffer(input)) return input;
-    return Buffer.from(await input.arrayBuffer());
+    if (input instanceof ArrayBuffer) return Buffer.from(input);
+    if (input instanceof Uint8Array) return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+    if (typeof input.arrayBuffer === 'function') return Buffer.from(await input.arrayBuffer());
+    // eslint-disable-next-line style/max-len
+    throw new TypeError('The provided input is not a supported binary type (Blob, Buffer, File, ArrayBuffer, or Uint8Array).');
 }

package/src/types/index.ts

@@ -7,7 +7,7 @@ import type {
 export type { FilteredKeyPath } from './filtered-key-path';
 
 export type AnyRecord = Record<string, any>;
-export type BinaryInput = Blob | Buffer | File | NodeBlob | NodeFile;
+export type BinaryInput = ArrayBuffer | Blob | Buffer | File | NodeBlob | NodeFile | Uint8Array;
 export type Booleanish = 'false' | 'true' | boolean;
 export type MaybePartial<T> = Partial<T> | T;
 export type MaybeReadonly<T> = Readonly<T> | T;