opticedge-cloud-utils 1.1.13 → 1.1.14

package/dist/chunk.d.ts

@@ -0,0 +1 @@
+export declare function chunkByBytes(arr: any[], maxBytes?: number): any[][];

package/dist/chunk.js

@@ -0,0 +1,37 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkByBytes = chunkByBytes;
+function chunkByBytes(arr, maxBytes = 700000) {
+    // 700KB safe default
+    const chunks = [];
+    let current = [];
+    let curBytes = 0;
+    for (const item of arr) {
+        const s = JSON.stringify(item);
+        const b = Buffer.byteLength(s, 'utf8');
+        // if a single item exceeds maxBytes, push it alone (or skip)
+        if (b > maxBytes) {
+            // optionally log and skip - here we'll push as its own chunk
+            if (current.length) {
+                chunks.push(current);
+                current = [];
+                curBytes = 0;
+            }
+            chunks.push([item]);
+            continue;
+        }
+        if (curBytes + b > maxBytes) {
+            chunks.push(current);
+            current = [item];
+            curBytes = b;
+        }
+        else {
+            current.push(item);
+            curBytes += b;
+        }
+    }
+    if (current.length)
+        chunks.push(current);
+    return chunks;
+}

package/dist/env.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEnv = getEnv;
 function getEnv(name, fallback) {

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export * from './db/mongo3';
 export * from './tw/utils';
 export * from './tw/wallet';
 export * from './auth';
+export * from './chunk';
 export * from './env';
 export * from './parser';
 export * from './regex';

package/dist/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./db/mongo3"), exports);
 __exportStar(require("./tw/utils"), exports);
 __exportStar(require("./tw/wallet"), exports);
 __exportStar(require("./auth"), exports);
+__exportStar(require("./chunk"), exports);
 __exportStar(require("./env"), exports);
 __exportStar(require("./parser"), exports);
 __exportStar(require("./regex"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opticedge-cloud-utils",
-  "version": "1.1.13",
+  "version": "1.1.14",
   "description": "Common utilities for cloud functions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/chunk.ts

@@ -0,0 +1,33 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export function chunkByBytes(arr: any[], maxBytes = 700_000) {
+  // 700KB safe default
+  const chunks: any[][] = []
+  let current: any[] = []
+  let curBytes = 0
+  for (const item of arr) {
+    const s = JSON.stringify(item)
+    const b = Buffer.byteLength(s, 'utf8')
+    // if a single item exceeds maxBytes, push it alone (or skip)
+    if (b > maxBytes) {
+      // optionally log and skip - here we'll push as its own chunk
+      if (current.length) {
+        chunks.push(current)
+        current = []
+        curBytes = 0
+      }
+      chunks.push([item])
+      continue
+    }
+    if (curBytes + b > maxBytes) {
+      chunks.push(current)
+      current = [item]
+      curBytes = b
+    } else {
+      current.push(item)
+      curBytes += b
+    }
+  }
+  if (current.length) chunks.push(current)
+  return chunks
+}

package/src/env.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 export function getEnv(name: string, fallback?: any): any {
   const value = process.env[name]
   if (!value) {

package/src/index.ts

@@ -4,6 +4,7 @@ export * from './db/mongo3'
 export * from './tw/utils'
 export * from './tw/wallet'
 export * from './auth'
+export * from './chunk'
 export * from './env'
 export * from './parser'
 export * from './regex'

package/tests/chunk.test.ts

@@ -0,0 +1,48 @@
+import { chunkByBytes } from '../src/chunk'
+
+describe('chunkByBytes', () => {
+  test('splits array into chunks based on byte size', () => {
+    const arr = [
+      { id: 'a', val: 'x'.repeat(100) },
+      { id: 'b', val: 'y'.repeat(100) },
+      { id: 'c', val: 'z'.repeat(100) }
+    ]
+    const chunks = chunkByBytes(arr, 200) // 200 bytes max per chunk
+    expect(chunks.length).toBeGreaterThan(1) // should split
+    expect(chunks.flat()).toEqual(arr) // all items present
+  })
+
+  test('puts single large item in its own chunk', () => {
+    const arr = [{ id: 'big', val: 'x'.repeat(1000) }]
+    const chunks = chunkByBytes(arr, 100)
+    expect(chunks).toEqual([arr]) // large item pushed alone
+  })
+
+  test('does not split if all items fit within maxBytes', () => {
+    const arr = [
+      { id: 'a', val: 'x' },
+      { id: 'b', val: 'y' }
+    ]
+    const chunks = chunkByBytes(arr, 1000)
+    expect(chunks).toEqual([arr])
+  })
+
+  test('uses default maxBytes if not provided', () => {
+    const arr = [{ id: 'a', val: 'x'.repeat(10) }]
+    // call without maxBytes
+    const chunks = chunkByBytes(arr)
+    expect(chunks.flat()).toEqual(arr) // all items present
+  })
+
+  test('flushes current chunk when a single item exceeds maxBytes', () => {
+    const arr = [
+      { id: '1', val: 'x'.repeat(50) }, // first small item
+      { id: '2', val: 'y'.repeat(200) } // oversized item
+    ]
+    // set maxBytes small enough to trigger oversized item
+    const chunks = chunkByBytes(arr, 100)
+    expect(chunks.length).toBe(2) // first small chunk + oversized item alone
+    expect(chunks[0]).toEqual([arr[0]]) // first item in first chunk
+    expect(chunks[1]).toEqual([arr[1]]) // second item alone
+  })
+})