sliftutils 1.8.20 → 1.9.1

package/.cursor/rules/coding-styles.mdc

@@ -14,7 +14,6 @@ alwaysApply: true
 - When functions have more than one primitive parameter, such that you could confuse them (even something as simple as start time and end time), you should put them inside of an object and call that object `config`, so the function only has a single parameter.
 - Never use return codes, always prefer to throw on error. Include a lot of context information in the error. If any values might be extremely large, such as parsing a file, limit them (ex, to 500 characters).
 - Use double quotes, not single quotes.
-- Never use the ternary operator. Instead, do this: `x ? y : z` => `x && y || z`.
 - Never use non-null assertion operator, instead check the value, and if necessary (because it is accessed in nested functions), use a `const` variable to preserve the type.
 - Errors should almost always use a template string to include the expected value, and the actual value, as in: `throw new Error(\`Expected X, was \${Y}\`);`
 - Don't use switch statements. Use if/else statements instead.

package/.cursor/rules/styling-css.mdc

@@ -34,7 +34,7 @@ className={css
     + (conditionalExample && css.opacity(0.5))
 }
 ```
-Specifically, it should be a value that you check for, and then the value. Don't use ternary, don't do `|| ""`. If you have multiple values, chain them with `||` and `&&`. Keep the CSS simple, don't add too much, because it's easier to add than to remove.
+Specifically, it should be a value that you check for, and then the value. Don't do `|| ""`. If you have multiple values, chain them with `||` and `&&`. Keep the CSS simple, don't add too much, because it's easier to add than to remove.
 
 ## Aliases and Helpers
 

package/CLAUDE.md

@@ -102,7 +102,7 @@ className={css.size(100, 100).hbox(4)
 }
 ```
 
-Conditionals come after, never as a ternary:
+Conditionals come after:
 
 ```tsx
 className={css

package/index.d.ts

@@ -60,6 +60,7 @@ declare module "sliftutils/misc/getSecret" {
 }
 
 declare module "sliftutils/misc/helpers" {
+    export declare function throwDetached(error: unknown): void;
     export declare function waitForDiskCollectionFlush(): Promise<void>;
 
 }
@@ -851,6 +852,25 @@ declare module "sliftutils/render-utils/colors" {
 
 }
 
+declare module "sliftutils/render-utils/drag" {
+    export declare let dragCount: number;
+    type DragOffset = {
+        x: number;
+        y: number;
+    };
+    export declare function performDrag(e: MouseEvent, onMove: (offset: DragOffset) => void, onDone?: (offset: DragOffset) => void): void;
+    export declare function performDrag2(config: {
+        e: MouseEvent;
+        onMove?: (offset: DragOffset) => void;
+        onDone?: (offset: DragOffset) => void;
+        onFinally?: (passedSlop: boolean) => void;
+        slop?: number;
+    }): void;
+    export declare function cancelDrag(): void;
+    export {};
+
+}
+
 declare module "sliftutils/render-utils/mobxTyped" {
     import { observable, runInAction, computed, autorun, onBecomeObserved, onBecomeUnobserved, Reaction } from "mobx";
     export { observable, runInAction, computed, autorun, onBecomeObserved, onBecomeUnobserved, Reaction };
@@ -3023,6 +3043,9 @@ declare module "sliftutils/storage/backblaze" {
         private getBucketAPI;
         private currentReset;
         private last503Reset;
+        private lastAPIReset;
+        private consecutiveFailures;
+        private resetAPIs;
         private apiRetryLogic;
         get(fileName: string, config?: GetConfig): Promise<Buffer | undefined>;
         get2(fileName: string, config?: GetConfig): Promise<{

package/misc/helpers.d.ts

@@ -1 +1,2 @@
+export declare function throwDetached(error: unknown): void;
 export declare function waitForDiskCollectionFlush(): Promise<void>;

package/misc/helpers.ts

@@ -1,6 +1,12 @@
 import { delay } from "socket-function/src/batching";
 import { hasPending } from "../storage/PendingManager";
 
+export function throwDetached(error: unknown): void {
+    void Promise.resolve().then(() => {
+        throw error;
+    });
+}
+
 export async function waitForDiskCollectionFlush() {
     await delay(2000);
     while (hasPending()) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.8.20",
+    "version": "1.9.1",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/render-utils/drag.d.ts

@@ -0,0 +1,15 @@
+export declare let dragCount: number;
+type DragOffset = {
+    x: number;
+    y: number;
+};
+export declare function performDrag(e: MouseEvent, onMove: (offset: DragOffset) => void, onDone?: (offset: DragOffset) => void): void;
+export declare function performDrag2(config: {
+    e: MouseEvent;
+    onMove?: (offset: DragOffset) => void;
+    onDone?: (offset: DragOffset) => void;
+    onFinally?: (passedSlop: boolean) => void;
+    slop?: number;
+}): void;
+export declare function cancelDrag(): void;
+export {};

package/render-utils/drag.ts

@@ -0,0 +1,161 @@
+import { MaybePromise } from "socket-function/src/types";
+import { runInAction } from "./mobxTyped";
+
+export let dragCount = 0;
+
+type DragOffset = { x: number; y: number };
+
+function throttleFunctionFast<Args extends unknown[]>(
+    fnc: (...args: Args) => MaybePromise<void>
+): (...args: Args) => void {
+    let pendingCall: { args: Args } | undefined;
+    let inCall = false;
+    return async (...args: Args) => {
+        if (inCall) {
+            pendingCall = { args };
+            return;
+        }
+        inCall = true;
+        try {
+            await fnc(...args);
+        } finally {
+            inCall = false;
+            if (pendingCall) {
+                let call = pendingCall;
+                pendingCall = undefined;
+                void fnc(...call.args);
+            }
+        }
+    };
+}
+
+function inAction<Args extends unknown[]>(fnc: (...args: Args) => void): (...args: Args) => void {
+    return (...args: Args) => runInAction(() => fnc(...args));
+}
+
+export function performDrag(
+    e: MouseEvent,
+    onMove: (offset: DragOffset) => void,
+    onDone?: (offset: DragOffset) => void,
+) {
+    return performDrag2({ e, onMove, onDone });
+}
+
+export function performDrag2(
+    config: {
+        e: MouseEvent;
+        onMove?: (offset: DragOffset) => void;
+        onDone?: (offset: DragOffset) => void;
+        onFinally?: (passedSlop: boolean) => void;
+        slop?: number;
+    }
+) {
+    let { e, slop } = config;
+    let onMove = inAction(config.onMove ?? (() => { }));
+    let onDone = config.onDone && inAction(config.onDone);
+    let onFinally = config.onFinally && inAction(config.onFinally);
+    dragCount++;
+
+    let startMouseX = e.clientX;
+    let startMouseY = e.clientY;
+    let lastMouseX = e.clientX;
+    let lastMouseY = e.clientY;
+
+    let passedSlop = !slop;
+
+    function cancel() {
+        lastMouseX = startMouseX;
+        lastMouseY = startMouseY;
+        finish();
+    }
+
+    let finished = false;
+    let disposed = false;
+
+    const triggerMove = throttleFunctionFast(async () => {
+        if (disposed) return;
+        let deltaX = lastMouseX - startMouseX;
+        let deltaY = lastMouseY - startMouseY;
+        if (slop) {
+            let dist = Math.sqrt(deltaX ** 2 + deltaY ** 2);
+            if (dist > slop) passedSlop = true;
+            if (!passedSlop) return;
+        }
+        onMove({ x: deltaX, y: deltaY });
+        await new Promise(r => requestAnimationFrame(r));
+    });
+
+    const onMouseMove = (e: MouseEvent) => {
+        if (finished) return;
+        if (e.buttons === 0) {
+            finish();
+            return;
+        }
+        if (lastMouseX === e.clientX && lastMouseY === e.clientY) return;
+        lastMouseX = e.clientX;
+        lastMouseY = e.clientY;
+        triggerMove();
+    };
+    let finish = () => {
+        selfCancelCallback.delete(cancel);
+        try {
+            if (finished) return;
+            finished = true;
+            dragCount--;
+            window.removeEventListener("mousemove", onMouseMove);
+            window.removeEventListener("mouseup", finish, { capture: true });
+            window.removeEventListener("blur", onBlur);
+            document.removeEventListener("keydown", keyDown);
+            triggerMove();
+            if (onDone) {
+                let deltaX = lastMouseX - startMouseX;
+                let deltaY = lastMouseY - startMouseY;
+                if (slop) {
+                    let dist = Math.sqrt(deltaX ** 2 + deltaY ** 2);
+                    if (dist > slop) passedSlop = true;
+                    if (!passedSlop) return;
+                }
+                onDone({ x: deltaX, y: deltaY });
+            }
+        } finally {
+            setTimeout(() => {
+                onFinally?.(passedSlop);
+            }, 0);
+        }
+        disposed = true;
+    };
+
+    const keyDown = (e: KeyboardEvent) => {
+        if (finished) return;
+        if (e.code === "Escape") {
+            cancel();
+        }
+    };
+
+    const onBlur = () => {
+        if (finished) return;
+        cancel();
+    };
+
+    window.addEventListener("mousemove", onMouseMove);
+    window.addEventListener("mouseup", finish, { capture: true });
+    window.addEventListener("blur", onBlur);
+    document.addEventListener("keydown", keyDown);
+    selfCancelCallback.add(cancel);
+
+    if (!slop) {
+        onMove({ x: 0, y: 0 });
+    }
+}
+
+let selfCancelCallback = new Set<() => void>();
+export function cancelDrag() {
+    for (let callback of selfCancelCallback) {
+        try {
+            callback();
+        } catch (e) {
+            console.error(`Error in drag cancel callback: ${(e as Error).stack ?? e}`);
+        }
+    }
+    selfCancelCallback.clear();
+}

package/storage/backblaze.d.ts

@@ -21,6 +21,9 @@ export declare class ArchivesBackblaze implements IArchives {
     private getBucketAPI;
     private currentReset;
     private last503Reset;
+    private lastAPIReset;
+    private consecutiveFailures;
+    private resetAPIs;
     private apiRetryLogic;
     get(fileName: string, config?: GetConfig): Promise<Buffer | undefined>;
     get2(fileName: string, config?: GetConfig): Promise<{

package/storage/backblaze.ts

@@ -29,6 +29,9 @@ let backblazeCreds = lazy(async (): Promise<BackblazeCreds> => {
 const MIN_BUCKET_CACHE_TIME = 60 * 1000;
 // Backblaze requires 5MB chunks for large files, but larger is more efficient for us (and their "last part" size check misbehaves on retries, which chunks this big sidestep - see setLargeFile)
 const LARGE_FILE_MIN_CHUNK_SIZE = 32 * 1024 * 1024;
+const CONSECUTIVE_FAILURES_BEFORE_RESET = 10;
+const MIN_API_RESET_INTERVAL = 1000;
+const CONNECTION_DEAD_MARKERS = ["TLS", "ECONNRESET", "ECONNREFUSED", "EPIPE", "socket hang up", "socket disconnected"];
 
 // A B2 download/HEAD response's headers carry the file's metadata. content-range's total wins over content-length for ranged responses (which only report the slice's length).
 function parseFileMetadataHeaders(response: HttpsResponseInfo): { size: number; writeTime: number } {
@@ -562,6 +565,17 @@ export class ArchivesBackblaze implements IArchives {
 
     // Keep track of when we last reset because of a 503
     private last503Reset = 0;
+    private lastAPIReset = 0;
+    private consecutiveFailures = 0;
+
+    private resetAPIs(context: string, reason: string, err: Error) {
+        if (Date.now() - this.lastAPIReset < MIN_API_RESET_INTERVAL) return;
+        this.lastAPIReset = Date.now();
+        console.warn(`[${context}] Resetting getAPI and getBucketAPI for ${this.getDebugName()} (${reason}, ${this.consecutiveFailures} consecutive failures): ${err.message}`);
+        getAPI.reset();
+        this.getBucketAPI.reset();
+        this.consecutiveFailures = 0;
+    }
     // IMPORTANT! We must always CATCH AROUND the apiRetryLogic, NEVER inside of fnc. Otherwise we won't be able to recreate the auth token. `context` is a short label (verb + file path) included in every retry/error log so a stuck silent-retry loop is identifiable from the logs.
     private async apiRetryLogic<T>(
         context: string,
@@ -571,10 +585,10 @@ export class ArchivesBackblaze implements IArchives {
         let api: B2Api | undefined;
         try {
             api = await this.getBucketAPI();
-            return await fnc(api);
+            let result = await fnc(api);
+            this.consecutiveFailures = 0;
+            return result;
         } catch (err: any) {
-            if (retries <= 0) throw err;
-
             // A file that does not exist is an answer, not a failure. It is the one error here that
             // cannot become anything else by asking again, so it is thrown at once instead of being
             // slept on twice - callers turn it into undefined, which is what they were asking.
@@ -583,9 +597,21 @@ export class ArchivesBackblaze implements IArchives {
                 || err.stack.includes(`file_not_found`)
                 || err.stack.includes(`"status": 404`)
             ) {
+                this.consecutiveFailures = 0;
                 throw err;
             }
 
+            this.consecutiveFailures++;
+            if (!api) {
+                this.resetAPIs(context, "acquiring the api failed, so the lazy holds a rejected promise", err);
+            } else if (CONNECTION_DEAD_MARKERS.some(marker => err.stack.includes(marker))) {
+                this.resetAPIs(context, "connection level error", err);
+            } else if (this.consecutiveFailures >= CONSECUTIVE_FAILURES_BEFORE_RESET) {
+                this.resetAPIs(context, `${CONSECUTIVE_FAILURES_BEFORE_RESET} calls in a row failed`, err);
+            }
+
+            if (retries <= 0) throw err;
+
             // If it's a 503 and it's been a minute since we last reset, then Wait and reset.
             if (
                 (err.stack.includes(`"status": 503`)

package/storage/remoteStorage/ArchivesDelayed.ts

@@ -1,4 +1,5 @@
 import { runInfinitePoll } from "socket-function/src/batching";
+import { throwDetached } from "../../misc/helpers";
 import {
     IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, DelConfig,
     FindConfig, GetConfig, GetInfoConfig, SetConfig, SetLargeFileConfig, SourceConfig,
@@ -105,8 +106,13 @@ export class ArchivesDelayed implements IArchives {
         let deadlineReached = force || this.deadlinePassed();
         for (let [fileName, entry] of [...this.pending]) {
             if (!deadlineReached && entry.dueAt > now) continue;
+            try {
+                await this.write(fileName, entry);
+            } catch (e) {
+                throwDetached(new Error(`Flushing ${JSON.stringify(fileName)} (${entry.data.length} bytes, writeTime ${entry.writeTime}) to ${this.inner.getDebugName()} failed, it stays pending: ${(e as Error).stack ?? e}`));
+                continue;
+            }
             // Only drop it if it wasn't overwritten while we were writing
-            await this.write(fileName, entry);
             if (this.pending.get(fileName) === entry) {
                 this.pending.delete(fileName);
             }