@uniformdev/canvas 19.209.1 → 19.210.1-alpha.7

package/dist/index.d.mts

@@ -11627,9 +11627,24 @@ declare function createBatchEnhancer<TArgs, TResult>({ handleBatch, shouldQueue,
 declare const compose: (input: ComponentParameterEnhancer<any, any> | ComponentParameterEnhancerFunction<any>, ...composers: ReadonlyArray<ComponentParameterEnhancer<any, any> | ComponentParameterEnhancerFunction<any>>) => ComponentParameterEnhancer<any, any>;
 
 type LimitPolicy = <ReturnValue>(func: () => Promise<ReturnValue>) => Promise<ReturnValue>;
-declare function createLimitPolicy({ throttle, retry, }: {
+/**
+ * Creates a request limit policy that can be passed to Uniform API clients to limit concurrent requests and handle retries and rate limits
+ *
+ * Limiting vs Throttling:
+ * - Throttling controls how quickly new promises can be started.
+ *    This is generally what we want for API rate limiting, but it does not care how many promises total are in flight.
+ * - Limiting controls how many promises can be in flight at once.
+ *    This is important when retries are involved because retries are not subject to throttling, and this can result in heavy promise loads.
+ *
+ * @param throttle - Throttle options to limit how fast requests can be initiated. If false, throttling is disabled.
+ * @param retry - Retry options to handle retries. If false, retries are disabled.
+ * @param limit - Limit the number of concurrent in-flight requests. If false, the limit is disabled.
+ * @returns A function that can be passed to Uniform API clients to limit concurrent requests and handle retries and rate limits
+ */
+declare function createLimitPolicy({ throttle, retry, limit, }: {
     throttle?: Options | false;
     retry?: Options$1 | false;
+    limit?: number | false;
 }): LimitPolicy;
 declare const nullLimitPolicy: LimitPolicy;
 

package/dist/index.d.ts

@@ -11627,9 +11627,24 @@ declare function createBatchEnhancer<TArgs, TResult>({ handleBatch, shouldQueue,
 declare const compose: (input: ComponentParameterEnhancer<any, any> | ComponentParameterEnhancerFunction<any>, ...composers: ReadonlyArray<ComponentParameterEnhancer<any, any> | ComponentParameterEnhancerFunction<any>>) => ComponentParameterEnhancer<any, any>;
 
 type LimitPolicy = <ReturnValue>(func: () => Promise<ReturnValue>) => Promise<ReturnValue>;
-declare function createLimitPolicy({ throttle, retry, }: {
+/**
+ * Creates a request limit policy that can be passed to Uniform API clients to limit concurrent requests and handle retries and rate limits
+ *
+ * Limiting vs Throttling:
+ * - Throttling controls how quickly new promises can be started.
+ *    This is generally what we want for API rate limiting, but it does not care how many promises total are in flight.
+ * - Limiting controls how many promises can be in flight at once.
+ *    This is important when retries are involved because retries are not subject to throttling, and this can result in heavy promise loads.
+ *
+ * @param throttle - Throttle options to limit how fast requests can be initiated. If false, throttling is disabled.
+ * @param retry - Retry options to handle retries. If false, retries are disabled.
+ * @param limit - Limit the number of concurrent in-flight requests. If false, the limit is disabled.
+ * @returns A function that can be passed to Uniform API clients to limit concurrent requests and handle retries and rate limits
+ */
+declare function createLimitPolicy({ throttle, retry, limit, }: {
     throttle?: Options | false;
     retry?: Options$1 | false;
+    limit?: number | false;
 }): LimitPolicy;
 declare const nullLimitPolicy: LimitPolicy;
 

package/dist/index.esm.js

@@ -30,6 +30,124 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 
+// ../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js
+var require_yocto_queue = __commonJS({
+  "../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js"(exports, module) {
+    "use strict";
+    var Node = class {
+      /// value;
+      /// next;
+      constructor(value) {
+        this.value = value;
+        this.next = void 0;
+      }
+    };
+    var Queue = class {
+      // TODO: Use private class fields when targeting Node.js 12.
+      // #_head;
+      // #_tail;
+      // #_size;
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node = new Node(value);
+        if (this._head) {
+          this._tail.next = node;
+          this._tail = node;
+        } else {
+          this._head = node;
+          this._tail = node;
+        }
+        this._size++;
+      }
+      dequeue() {
+        const current = this._head;
+        if (!current) {
+          return;
+        }
+        this._head = this._head.next;
+        this._size--;
+        return current.value;
+      }
+      clear() {
+        this._head = void 0;
+        this._tail = void 0;
+        this._size = 0;
+      }
+      get size() {
+        return this._size;
+      }
+      *[Symbol.iterator]() {
+        let current = this._head;
+        while (current) {
+          yield current.value;
+          current = current.next;
+        }
+      }
+    };
+    module.exports = Queue;
+  }
+});
+
+// ../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js
+var require_p_limit = __commonJS({
+  "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports, module) {
+    "use strict";
+    var Queue = require_yocto_queue();
+    var pLimit2 = (concurrency) => {
+      if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+        throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+      }
+      const queue = new Queue();
+      let activeCount = 0;
+      const next = () => {
+        activeCount--;
+        if (queue.size > 0) {
+          queue.dequeue()();
+        }
+      };
+      const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+          await result;
+        } catch (e) {
+        }
+        next();
+      };
+      const enqueue = (fn, resolve, ...args) => {
+        queue.enqueue(run.bind(null, fn, resolve, ...args));
+        (async () => {
+          await Promise.resolve();
+          if (activeCount < concurrency && queue.size > 0) {
+            queue.dequeue()();
+          }
+        })();
+      };
+      const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+      });
+      Object.defineProperties(generator, {
+        activeCount: {
+          get: () => activeCount
+        },
+        pendingCount: {
+          get: () => queue.size
+        },
+        clearQueue: {
+          value: () => {
+            queue.clear();
+          }
+        }
+      });
+      return generator;
+    };
+    module.exports = pLimit2;
+  }
+});
+
 // ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
 var require_retry_operation = __commonJS({
   "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module) {
@@ -265,6 +383,7 @@ var require_retry2 = __commonJS({
 import { ApiClient } from "@uniformdev/context/api";
 
 // src/enhancement/createLimitPolicy.ts
+var import_p_limit = __toESM(require_p_limit());
 import { ApiClientError } from "@uniformdev/context/api";
 
 // ../../node_modules/.pnpm/p-retry@5.1.2/node_modules/p-retry/index.js
@@ -431,15 +550,21 @@ function pThrottle({ limit, interval, strict }) {
 // src/enhancement/createLimitPolicy.ts
 function createLimitPolicy({
   throttle = { interval: 1e3, limit: 10 },
-  retry: retry2 = { retries: 1, factor: 1.66 }
+  retry: retry2 = { retries: 1, factor: 1.66 },
+  limit = 10
 }) {
   const throttler = throttle ? pThrottle(throttle) : null;
+  const limiter = limit ? (0, import_p_limit.default)(limit) : null;
   return function limitPolicy(func) {
     let currentFunc = async () => await func();
     if (throttler) {
       const throttleFunc = currentFunc;
       currentFunc = throttler(throttleFunc);
     }
+    if (limiter) {
+      const limitFunc = currentFunc;
+      currentFunc = () => limiter(limitFunc);
+    }
     if (retry2) {
       const retryFunc = currentFunc;
       currentFunc = () => pRetry(retryFunc, {
@@ -448,7 +573,7 @@ function createLimitPolicy({
           if (retry2.onFailedAttempt) {
             await retry2.onFailedAttempt(error);
           }
-          if (error instanceof ApiClientError && typeof error.statusCode === "number" && error.statusCode.toString().startsWith("4")) {
+          if (error instanceof ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
             throw error;
           }
         }

package/dist/index.js

@@ -36,6 +36,124 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 
+// ../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js
+var require_yocto_queue = __commonJS({
+  "../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js"(exports2, module2) {
+    "use strict";
+    var Node = class {
+      /// value;
+      /// next;
+      constructor(value) {
+        this.value = value;
+        this.next = void 0;
+      }
+    };
+    var Queue = class {
+      // TODO: Use private class fields when targeting Node.js 12.
+      // #_head;
+      // #_tail;
+      // #_size;
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node = new Node(value);
+        if (this._head) {
+          this._tail.next = node;
+          this._tail = node;
+        } else {
+          this._head = node;
+          this._tail = node;
+        }
+        this._size++;
+      }
+      dequeue() {
+        const current = this._head;
+        if (!current) {
+          return;
+        }
+        this._head = this._head.next;
+        this._size--;
+        return current.value;
+      }
+      clear() {
+        this._head = void 0;
+        this._tail = void 0;
+        this._size = 0;
+      }
+      get size() {
+        return this._size;
+      }
+      *[Symbol.iterator]() {
+        let current = this._head;
+        while (current) {
+          yield current.value;
+          current = current.next;
+        }
+      }
+    };
+    module2.exports = Queue;
+  }
+});
+
+// ../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js
+var require_p_limit = __commonJS({
+  "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports2, module2) {
+    "use strict";
+    var Queue = require_yocto_queue();
+    var pLimit2 = (concurrency) => {
+      if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+        throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+      }
+      const queue = new Queue();
+      let activeCount = 0;
+      const next = () => {
+        activeCount--;
+        if (queue.size > 0) {
+          queue.dequeue()();
+        }
+      };
+      const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+          await result;
+        } catch (e) {
+        }
+        next();
+      };
+      const enqueue = (fn, resolve, ...args) => {
+        queue.enqueue(run.bind(null, fn, resolve, ...args));
+        (async () => {
+          await Promise.resolve();
+          if (activeCount < concurrency && queue.size > 0) {
+            queue.dequeue()();
+          }
+        })();
+      };
+      const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+      });
+      Object.defineProperties(generator, {
+        activeCount: {
+          get: () => activeCount
+        },
+        pendingCount: {
+          get: () => queue.size
+        },
+        clearQueue: {
+          value: () => {
+            queue.clear();
+          }
+        }
+      });
+      return generator;
+    };
+    module2.exports = pLimit2;
+  }
+});
+
 // ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
 var require_retry_operation = __commonJS({
   "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports2, module2) {
@@ -425,6 +543,7 @@ var import_api2 = require("@uniformdev/context/api");
 
 // src/enhancement/createLimitPolicy.ts
 var import_api = require("@uniformdev/context/api");
+var import_p_limit = __toESM(require_p_limit());
 
 // ../../node_modules/.pnpm/p-retry@5.1.2/node_modules/p-retry/index.js
 var import_retry = __toESM(require_retry2(), 1);
@@ -590,15 +709,21 @@ function pThrottle({ limit, interval, strict }) {
 // src/enhancement/createLimitPolicy.ts
 function createLimitPolicy({
   throttle = { interval: 1e3, limit: 10 },
-  retry: retry2 = { retries: 1, factor: 1.66 }
+  retry: retry2 = { retries: 1, factor: 1.66 },
+  limit = 10
 }) {
   const throttler = throttle ? pThrottle(throttle) : null;
+  const limiter = limit ? (0, import_p_limit.default)(limit) : null;
   return function limitPolicy(func) {
     let currentFunc = async () => await func();
     if (throttler) {
       const throttleFunc = currentFunc;
       currentFunc = throttler(throttleFunc);
     }
+    if (limiter) {
+      const limitFunc = currentFunc;
+      currentFunc = () => limiter(limitFunc);
+    }
     if (retry2) {
       const retryFunc = currentFunc;
       currentFunc = () => pRetry(retryFunc, {
@@ -607,7 +732,7 @@ function createLimitPolicy({
           if (retry2.onFailedAttempt) {
             await retry2.onFailedAttempt(error);
           }
-          if (error instanceof import_api.ApiClientError && typeof error.statusCode === "number" && error.statusCode.toString().startsWith("4")) {
+          if (error instanceof import_api.ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
             throw error;
           }
         }

package/dist/index.mjs

@@ -30,6 +30,124 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 
+// ../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js
+var require_yocto_queue = __commonJS({
+  "../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js"(exports, module) {
+    "use strict";
+    var Node = class {
+      /// value;
+      /// next;
+      constructor(value) {
+        this.value = value;
+        this.next = void 0;
+      }
+    };
+    var Queue = class {
+      // TODO: Use private class fields when targeting Node.js 12.
+      // #_head;
+      // #_tail;
+      // #_size;
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node = new Node(value);
+        if (this._head) {
+          this._tail.next = node;
+          this._tail = node;
+        } else {
+          this._head = node;
+          this._tail = node;
+        }
+        this._size++;
+      }
+      dequeue() {
+        const current = this._head;
+        if (!current) {
+          return;
+        }
+        this._head = this._head.next;
+        this._size--;
+        return current.value;
+      }
+      clear() {
+        this._head = void 0;
+        this._tail = void 0;
+        this._size = 0;
+      }
+      get size() {
+        return this._size;
+      }
+      *[Symbol.iterator]() {
+        let current = this._head;
+        while (current) {
+          yield current.value;
+          current = current.next;
+        }
+      }
+    };
+    module.exports = Queue;
+  }
+});
+
+// ../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js
+var require_p_limit = __commonJS({
+  "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports, module) {
+    "use strict";
+    var Queue = require_yocto_queue();
+    var pLimit2 = (concurrency) => {
+      if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+        throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+      }
+      const queue = new Queue();
+      let activeCount = 0;
+      const next = () => {
+        activeCount--;
+        if (queue.size > 0) {
+          queue.dequeue()();
+        }
+      };
+      const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+          await result;
+        } catch (e) {
+        }
+        next();
+      };
+      const enqueue = (fn, resolve, ...args) => {
+        queue.enqueue(run.bind(null, fn, resolve, ...args));
+        (async () => {
+          await Promise.resolve();
+          if (activeCount < concurrency && queue.size > 0) {
+            queue.dequeue()();
+          }
+        })();
+      };
+      const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+      });
+      Object.defineProperties(generator, {
+        activeCount: {
+          get: () => activeCount
+        },
+        pendingCount: {
+          get: () => queue.size
+        },
+        clearQueue: {
+          value: () => {
+            queue.clear();
+          }
+        }
+      });
+      return generator;
+    };
+    module.exports = pLimit2;
+  }
+});
+
 // ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
 var require_retry_operation = __commonJS({
   "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module) {
@@ -265,6 +383,7 @@ var require_retry2 = __commonJS({
 import { ApiClient } from "@uniformdev/context/api";
 
 // src/enhancement/createLimitPolicy.ts
+var import_p_limit = __toESM(require_p_limit());
 import { ApiClientError } from "@uniformdev/context/api";
 
 // ../../node_modules/.pnpm/p-retry@5.1.2/node_modules/p-retry/index.js
@@ -431,15 +550,21 @@ function pThrottle({ limit, interval, strict }) {
 // src/enhancement/createLimitPolicy.ts
 function createLimitPolicy({
   throttle = { interval: 1e3, limit: 10 },
-  retry: retry2 = { retries: 1, factor: 1.66 }
+  retry: retry2 = { retries: 1, factor: 1.66 },
+  limit = 10
 }) {
   const throttler = throttle ? pThrottle(throttle) : null;
+  const limiter = limit ? (0, import_p_limit.default)(limit) : null;
   return function limitPolicy(func) {
     let currentFunc = async () => await func();
     if (throttler) {
       const throttleFunc = currentFunc;
       currentFunc = throttler(throttleFunc);
     }
+    if (limiter) {
+      const limitFunc = currentFunc;
+      currentFunc = () => limiter(limitFunc);
+    }
     if (retry2) {
       const retryFunc = currentFunc;
       currentFunc = () => pRetry(retryFunc, {
@@ -448,7 +573,7 @@ function createLimitPolicy({
           if (retry2.onFailedAttempt) {
             await retry2.onFailedAttempt(error);
           }
-          if (error instanceof ApiClientError && typeof error.statusCode === "number" && error.statusCode.toString().startsWith("4")) {
+          if (error instanceof ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
             throw error;
           }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniformdev/canvas",
-  "version": "19.209.1",
+  "version": "19.210.1-alpha.7+5402269e8e",
   "description": "Common functionality and types for Uniform Canvas",
   "license": "SEE LICENSE IN LICENSE.txt",
   "main": "./dist/index.js",
@@ -33,14 +33,15 @@
   "devDependencies": {
     "@types/retry": "0.12.5",
     "lexical": "0.17.1",
+    "p-limit": "3.1.0",
     "p-retry": "5.1.2",
     "p-throttle": "5.0.0",
     "pusher-js": "8.2.0"
   },
   "dependencies": {
-    "@uniformdev/assets": "19.209.1",
-    "@uniformdev/context": "19.209.1",
-    "@uniformdev/richtext": "19.209.1",
+    "@uniformdev/assets": "19.210.1-alpha.7+5402269e8e",
+    "@uniformdev/context": "19.210.1-alpha.7+5402269e8e",
+    "@uniformdev/richtext": "19.210.1-alpha.7+5402269e8e",
     "immer": "10.1.1"
   },
   "files": [
@@ -49,5 +50,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4dd40ad208d31d9c446a01434e804a0d47a562a9"
+  "gitHead": "5402269e8e1d1f8d955c4c2bb30ab7ac1a96e66b"
 }