orgnote-api 0.42.9 → 0.50.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orgnote-api",
-  "version": "0.42.9",
+  "version": "0.50.1",
   "description": "Official API for creating extensions for OrgNote app",
   "type": "module",
   "main": "./index.js",

package/utils/__tests__/run-with-concurrency.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/__tests__/run-with-concurrency.spec.js

@@ -0,0 +1,63 @@
+import { expect, expectTypeOf, test, vi } from 'vitest';
+import { runWithConcurrency } from "../run-with-concurrency.js";
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+test('runWithConcurrency returns results in input order', async () => {
+    const result = await runWithConcurrency([3, 1, 2], 2, async (value) => {
+        await sleep(value * 2);
+        return `item-${value}`;
+    });
+    expect(result).toEqual(['item-3', 'item-1', 'item-2']);
+});
+test('runWithConcurrency does not exceed the concurrency limit', async () => {
+    let activeCount = 0;
+    let maxActiveCount = 0;
+    await runWithConcurrency([1, 2, 3, 4, 5, 6], 3, async (value) => {
+        activeCount += 1;
+        maxActiveCount = Math.max(maxActiveCount, activeCount);
+        await sleep(value === 1 ? 15 : 5);
+        activeCount -= 1;
+        return value;
+    });
+    expect(maxActiveCount).toBeLessThanOrEqual(3);
+});
+test('runWithConcurrency supports synchronous workers', async () => {
+    const result = await runWithConcurrency([1, 2, 3], 2, (value) => value * 10);
+    expect(result).toEqual([10, 20, 30]);
+});
+test('runWithConcurrency returns empty array for empty input', async () => {
+    const worker = vi.fn();
+    const result = await runWithConcurrency([], 4, worker);
+    expect(result).toEqual([]);
+    expect(worker).not.toHaveBeenCalled();
+});
+test('runWithConcurrency handles concurrency larger than input length', async () => {
+    const result = await runWithConcurrency([1, 2], 100, async (value) => value * 2);
+    expect(result).toEqual([2, 4]);
+});
+test('runWithConcurrency rejects invalid concurrency values', async () => {
+    await expect(runWithConcurrency([1], 0, async (value) => value)).rejects.toThrow(RangeError);
+    await expect(runWithConcurrency([1], -1, async (value) => value)).rejects.toThrow(RangeError);
+    await expect(runWithConcurrency([1], 1.5, async (value) => value)).rejects.toThrow(RangeError);
+    await expect(runWithConcurrency([1], Number.POSITIVE_INFINITY, async (value) => value)).rejects.toThrow(RangeError);
+    await expect(runWithConcurrency([1], Number.NaN, async (value) => value)).rejects.toThrow(RangeError);
+});
+test('runWithConcurrency rejects when worker fails', async () => {
+    const failure = new Error('boom');
+    await expect(runWithConcurrency([1, 2, 3], 2, async (value) => {
+        if (value === 2)
+            throw failure;
+        await sleep(5);
+        return value;
+    })).rejects.toBe(failure);
+});
+test('runWithConcurrency infers resolved result types', async () => {
+    const promise = runWithConcurrency([1, 2, 3], 2, async (value) => ({
+        id: value,
+        label: `item-${value}`,
+    }));
+    expectTypeOf(promise).toEqualTypeOf();
+    const result = await promise;
+    expect(result[0]).toEqual({ id: 1, label: 'item-1' });
+});

package/utils/index.d.ts

@@ -13,3 +13,4 @@ export * from './auth-state.js';
 export * from './nullable-guards.js';
 export * from './binary.js';
 export * from './sort-files.js';
+export * from './run-with-concurrency.js';

package/utils/index.js

@@ -13,3 +13,4 @@ export * from "./auth-state.js";
 export * from "./nullable-guards.js";
 export * from "./binary.js";
 export * from "./sort-files.js";
+export * from "./run-with-concurrency.js";

package/utils/run-with-concurrency.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Run workers with a bounded concurrency level while preserving input order.
+ * If one worker rejects, the returned promise rejects immediately. Other
+ * in-flight workers may still finish their current item because promises are
+ * not cancellable.
+ */
+export declare const runWithConcurrency: <TItem, TResult>(items: readonly TItem[], concurrency: number, worker: (item: TItem, index: number) => TResult | PromiseLike<TResult>) => Promise<Array<Awaited<TResult>>>;

package/utils/run-with-concurrency.js

@@ -0,0 +1,31 @@
+const assertConcurrency = (concurrency) => {
+    if (Number.isInteger(concurrency) && concurrency > 0)
+        return;
+    throw new RangeError('concurrency must be a positive integer');
+};
+const createWorkers = (items, concurrency, worker, results) => {
+    let nextIndex = 0;
+    const runWorker = async () => {
+        while (nextIndex < items.length) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            results[currentIndex] = await worker(items[currentIndex], currentIndex);
+        }
+    };
+    return Array.from({ length: Math.min(concurrency, items.length) }, () => runWorker());
+};
+/**
+ * Run workers with a bounded concurrency level while preserving input order.
+ * If one worker rejects, the returned promise rejects immediately. Other
+ * in-flight workers may still finish their current item because promises are
+ * not cancellable.
+ */
+export const runWithConcurrency = async (items, concurrency, worker) => {
+    assertConcurrency(concurrency);
+    if (items.length === 0)
+        return [];
+    const results = new Array(items.length);
+    const workers = createWorkers(items, concurrency, worker, results);
+    await Promise.all(workers);
+    return results;
+};