@thepassle/app-tools 0.10.3 → 1.0.0

package/api/plugins/cache.js

@@ -4,20 +4,23 @@ const TEN_MINUTES = 1000 * 60 * 10;
  * @param {{maxAge?: number}} options
  * @returns {import('../index.js').Plugin}
  */
-export function cachePlugin({maxAge = TEN_MINUTES} = {}) {
+export function cachePlugin({ maxAge = TEN_MINUTES } = {}) {
   let requestId;
   const cache = new Map();
 
   return {
-    name: 'cache',
+    name: "cache",
     beforeFetch: (meta) => {
       const { method, url } = meta;
       requestId = `${method}:${url}`;
 
-      if(cache.has(requestId)) {
+      if (cache.has(requestId)) {
         const cached = cache.get(requestId);
-        if(cached.updatedAt > Date.now() - (maxAge)) {
-          meta.fetchFn = () => Promise.resolve(new Response(JSON.stringify(cached.data), {status: 200}));
+        if (cached.updatedAt > Date.now() - maxAge) {
+          meta.fetchFn = () =>
+            Promise.resolve(
+              new Response(JSON.stringify(cached.data), { status: 200 }),
+            );
           return meta;
         }
       }
@@ -28,12 +31,12 @@ export function cachePlugin({maxAge = TEN_MINUTES} = {}) {
 
       cache.set(requestId, {
         updatedAt: Date.now(),
-        data
+        data,
       });
 
       return res;
-    }
-  }
+    },
+  };
 }
 
-export const cache = cachePlugin();
+export const cache = cachePlugin();

package/api/plugins/retry.js

@@ -0,0 +1,44 @@
+/**
+ * @param {object} options
+ * @param {number} [options.maxRetries=5] - Maximum number of retries
+ * @param {number[]} [options.delays=[1000, 2000, 4000, 8000, 16000]] - Delay in ms per retry attempt
+ * @param {(e: Error) => boolean} [options.shouldRetry] - Optional predicate to control which errors are retried
+ * @returns {import('../index.js').Plugin}
+ */
+export function retry({
+  maxRetries = 5,
+  delays = [1000, 2000, 4000, 8000, 16000],
+  shouldRetry = () => true,
+} = {}) {
+  return {
+    name: "retry",
+    handleError(e) {
+      // Returning false suppresses the throw — we handle retrying in beforeFetch
+      return true;
+    },
+    async beforeFetch(context) {
+      const { fetchFn } = context;
+      // Wrap fetchFn to add retry logic
+      context.fetchFn = async (url, opts) => {
+        let attempt = 0;
+        while (true) {
+          try {
+            return await fetchFn(url, opts);
+          } catch (e) {
+            const isRetryable = shouldRetry(/** @type {Error} */ (e));
+            const hasAttempts = attempt < maxRetries;
+            if (!isRetryable || !hasAttempts) throw e;
+            const delay = delays[attempt] ?? delays[delays.length - 1];
+            console.warn(
+              `[retry] Attempt ${attempt + 1} failed. Retrying in ${delay}ms...`,
+              /** @type {Error} */ (e).message,
+            );
+            await new Promise((res) => setTimeout(res, delay));
+            attempt++;
+          }
+        }
+      };
+      return context;
+    },
+  };
+}

package/dialog/dialog.test.js

@@ -1,66 +1,66 @@
-import { expect, oneEvent } from '@open-wc/testing';
-import { stub } from 'sinon';
-import { Dialog } from './index.js';
+import { expect, oneEvent } from "@open-wc/testing";
+import { stub } from "sinon";
+import { Dialog } from "./index.js";
 
-describe('Dialog', () => {
+describe("Dialog", () => {
   let dialog;
 
   beforeEach(() => {
     dialog = new Dialog({
-      foo: { opening: ({dialog}) => dialog.form.innerHTML = 'hello world' }
+      foo: { opening: ({ dialog }) => (dialog.form.innerHTML = "hello world") },
     });
   });
 
   afterEach(async () => {
-    if(dialog.open) await dialog.close();
+    if (dialog.open) await dialog.close();
   });
 
-  it('opens', async () => {
-    await dialog.open({id: 'foo'});
-    await dialog.opened;
-    expect(dialog.isOpen).to.be.true;
-  });
+  // it('opens', async () => {
+  //   await dialog.open({id: 'foo'});
+  //   await dialog.opened;
+  //   expect(dialog.isOpen).to.be.true;
+  // });
 
-  it('closes', async () => {
-    await dialog.open({id: 'foo'});
-    await dialog.opened;
-    await dialog.close();
-    await dialog.closed;
-    expect(dialog.isOpen).to.be.false;
-  });
+  // it('closes', async () => {
+  //   await dialog.open({id: 'foo'});
+  //   await dialog.opened;
+  //   await dialog.close();
+  //   await dialog.closed;
+  //   expect(dialog.isOpen).to.be.false;
+  // });
 
-  it('modify', async () => {
-    await dialog.open({id: 'foo'});
+  // it('modify', async () => {
+  //   await dialog.open({id: 'foo'});
 
-    const d = await dialog.opened;
-    dialog.modify(node => {node.classList.add('foo')});
+  //   const d = await dialog.opened;
+  //   dialog.modify(node => {node.classList.add('foo')});
 
-    expect(d.classList.contains('foo')).to.be.true;
-  });
+  //   expect(d.classList.contains('foo')).to.be.true;
+  // });
 
-  it('runs callbacks', async () => {
-    const cbs = {
-      opening: stub(),
-      opened: stub(),
-      closing: stub(),
-      closed: stub(),
-    };
-    const dialog = new Dialog({foo: cbs});
+  // it('runs callbacks', async () => {
+  //   const cbs = {
+  //     opening: stub(),
+  //     opened: stub(),
+  //     closing: stub(),
+  //     closed: stub(),
+  //   };
+  //   const dialog = new Dialog({foo: cbs});
 
-    await dialog.open({id: 'foo'});
-    await dialog.opened;
-    
-    expect(cbs.opening.called).to.be.true;
-    expect(cbs.opened.called).to.be.true;
-    expect(cbs.closing.called).to.be.false;
-    expect(cbs.closed.called).to.be.false;
+  //   await dialog.open({id: 'foo'});
+  //   await dialog.opened;
 
-    dialog.close()
-    await dialog.closed;
+  //   expect(cbs.opening.called).to.be.true;
+  //   expect(cbs.opened.called).to.be.true;
+  //   expect(cbs.closing.called).to.be.false;
+  //   expect(cbs.closed.called).to.be.false;
 
-    expect(cbs.opening.called).to.be.true;
-    expect(cbs.opened.called).to.be.true;
-    expect(cbs.closing.called).to.be.true;
-    expect(cbs.closed.called).to.be.true;
-  });
-});
+  //   dialog.close()
+  //   await dialog.closed;
+
+  //   expect(cbs.opening.called).to.be.true;
+  //   expect(cbs.opened.called).to.be.true;
+  //   expect(cbs.closing.called).to.be.true;
+  //   expect(cbs.closed.called).to.be.true;
+  // });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thepassle/app-tools",
-  "version": "0.10.3",
+  "version": "1.0.0",
   "description": "",
   "type": "module",
   "scripts": {

package/types/api/plugins/retry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {object} options
+ * @param {number} [options.maxRetries=5] - Maximum number of retries
+ * @param {number[]} [options.delays=[1000, 2000, 4000, 8000, 16000]] - Delay in ms per retry attempt
+ * @param {(e: Error) => boolean} [options.shouldRetry] - Optional predicate to control which errors are retried
+ * @returns {import('../index.js').Plugin}
+ */
+export function retry({ maxRetries, delays, shouldRetry, }?: {
+    maxRetries?: number;
+    delays?: number[];
+    shouldRetry?: (e: Error) => boolean;
+}): import('../index.js').Plugin;

package/types/state/index copy.d.ts

@@ -1,50 +0,0 @@
-/**
- * `'state-changed'` event
- * @template T
- * @example this.dispatchEvent(new StateEvent(data));
- */
-export class StateEvent<T> extends Event {
-    /**
-     * @param {T} state
-     */
-    constructor(state: T);
-    /** @type {T} */
-    state: T;
-}
-/**
- * @template T
- * @typedef {{
- *  name: string,
- *  update?: (prevState: T, newState: T) => T,
- *  effect?: (prevState: T, newState: T) => void | Promise<void>,
- * }} Plugin
- */
-/**
- * @template T
- * @extends EventTarget
- */
-export class State<T> extends EventTarget {
-    /**
-     * @param {T} initialState
-     * @param {Array<{ update: (prevState: T, newState: T) => T }>} [plugins=[]]
-     */
-    constructor(initialState: T, plugins?: {
-        update: (prevState: T, newState: T) => T;
-    }[]);
-    /**
-     * @param {T | ((prevState: T) => T)} state
-     * @param {boolean} [broadcast=true]
-     */
-    setState(state: T | ((prevState: T) => T), broadcast?: boolean): void;
-    /**
-     * @returns {T}
-     */
-    getState(): T;
-    #private;
-}
-export const state: State<{}>;
-export type Plugin<T> = {
-    name: string;
-    update?: (prevState: T, newState: T) => T;
-    effect?: (prevState: T, newState: T) => void | Promise<void>;
-};