sliftutils 1.2.1 → 1.2.3

package/.cursor/rules/api-calls.mdc

@@ -0,0 +1,16 @@
+---
+description: API calls and controller usage
+alwaysApply: true
+---
+
+# API Calls
+
+When in an event callback (which must be async):
+```typescript
+APIController(getExtNodeId()).getModels.promise()
+```
+
+When in a render function/context:
+```typescript
+APIController(getExtNodeId()).getModels()
+```

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

@@ -0,0 +1,50 @@
+---
+description: General coding styles and conventions
+alwaysApply: true
+---
+
+# Coding Styles
+
+- Times should almost always be in milliseconds, and if not told, you should assume a time is in milliseconds.
+- Don't make functions that will never be reused and are short. This just makes the code too confusing. If the function is under five lines and it's not being reused, you shouldn't create it, unless instructed explicitly to create it.
+- Comments should be used sparingly and only if it's required to explain what's being done. If you're calling a function called `createImageName` and the comment is called "create imageName", you will be fired because that's just stupid. It's a waste of lines.
+- Comments go in the line before, never after the semicolon.
+- Try not to use `null`, and instead always use `undefined`.
+- Almost never check for `undefined` or `null`, just check for falsey.
+- 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.
+- Don't use `!` when accessing a value from a map. Use the get / if undefined initialize and set, and then use style. It's faster, and more type safe.
+- Sort with this function, which takes a single function to map each object to a sortable value:
+  ```typescript
+  import { sort } from "socket-function/src/misc";
+  export function sort<T>(arr: T[], sortKey: (obj: T) => unknown);
+  ```
+- Prefer to return, instead of using else statements. Handle error cases, warn/throw, and then return. Your main case should be below, not in an if statement, just in the main code.
+- Use template strings for error messages, which include the exact value that triggered the error, and the exact expectation it failed.
+- Use functions to prevent code duplication only when something is actually duplicated.
+- Don't recreate collections or URL parameters, import them instead.
+- Do not redefine types. Import the types correctly.
+- Do not use types when they can be inferred.
+- Constants that are arbitrary and that we might to reconfigure should be near the top of the file under the imports, not buried within functions.
+- Never use environment variables. All configuration should be on the disk, or, if specific to a current run, passed as command line parameters.
+- Never use inline styles, always use the CSS helper.
+- Don't use `as any`.
+- When you're making fetch calls and you get a type of `any`, you need to cast it to the actual type, and not leave it as `any`. The same goes for when you're deserializing values.
+- DO NOT redeclare constants and copy their value. JUST IMPORT THEM!
+- DO NOT redeclare types. JUST IMPORT THEM!
+- Do not try catch for no reason. If you can't actually handle the exception, just let it throw.
+- For input events, always use `event.currentTarget`.
+- Use `ref={elem => }` callbacks. NEVER use `.createRef`.
+- NEVER render images with a fixed width+height. This will cause them to be stretched or cut off. This is terrible. Only set the width or height.
+- Callback held should be avoided by using async and `import { PromiseObj } from "socket-function/src/misc";`. Most of the time, if there's an event callback, you should wrap it with a promise obj so that you can wait for it asynchronously.
+- `import { keyBy, keyByArray } from "socket-function/src/misc";` Should be used when you need to create lookups from lists and you know what key you want. This can clobber values, or it can gather in an array.
+  ```typescript
+  let example: Map<number, { x: number }> = keyBy([{ x: 5 }, { x: 6 }]);
+  let example: Map<number, { x: number }[]> = keyByArray([{ x: 5 }, { x: 5, version: 2 }, { x: 6 }]);
+  ```
+- Never use `alert`. If there's an error, you should throw it.

package/.cursor/rules/components.mdc

@@ -0,0 +1,44 @@
+---
+description: Custom components and input handling
+alwaysApply: true
+---
+
+# Components
+
+## Anchor
+
+`Anchor` (`<a>` tag), for linking using `URLParam`:
+```tsx
+<Anchor
+    params={[[todolistURL, listKey]]}
+>
+    {list.name}
+</Anchor>
+```
+
+`URLParam`, Parameters which are stored in the URL. The second argument is the default, which can be a number, string, or an object. Set and get with `.value`.
+```typescript
+const todolistURL = new URLParam("todolist", "");
+```
+
+## InputLabel
+
+`InputLabel` and `InputLabelURL` should be used for inputs. For example:
+
+```tsx
+<InputLabelURL
+    label="Show Previous Video"
+    checkbox
+    persisted={showPreviousVideoURL}
+/>
+<InputLabel
+    label="Notes"
+    fillWidth
+    value={node.notes || ""}
+    onChangeValue={async (value) => {
+        const updatedNode = deepCloneJSON(node);
+        updatedNode.notes = value;
+        await VideoNode.set(node.id, updatedNode);
+    }}
+/>
+```

package/.cursor/rules/disk-collection.mdc

@@ -0,0 +1,31 @@
+---
+description: DiskCollection usage and patterns
+alwaysApply: true
+---
+
+# DiskCollection
+
+If you read an object from a collection, and then mutate it, and want to set it in the collection, you have to shallow copy it, so the `DiskCollection` picks up the change.
+
+```typescript
+let x = collection.get("x");
+x.y = Math.random();
+// Not asynchronous, as sets are synchronous
+collection.set("x", { ...x });
+```
+
+The non-async functions should be called in render functions, the async functions should be called in event handlers, etc. Except for `.set`, which should be called in both cases.
+
+```typescript
+get(key: string): T | undefined;
+async getPromise(key: string): Promise<T | undefined>;
+set(key: string, value: T): void;
+remove(key: string): void;
+getKeys(): string[];
+getKeysPromise(): Promise<string[]>;
+getEntries(): [string, T][];
+getValues(): T[];
+async getValuesPromise(): Promise<T[]>;
+getInfo(key: string);
+async reset();
+```

package/.cursor/rules/general-guidelines.mdc

@@ -0,0 +1,11 @@
+---
+description: General project guidelines and tool usage
+alwaysApply: true
+---
+
+# General Guidelines
+
+- The code automatically updates on save, so do not ever run commands to rerun the site.
+- Don't run shell commands when you need to create or move small code files. You should use tool calls to do this. You should also use tool calls to make files within folders. You don't need to make the folder, just make the file. The folder will automatically be created.
+- If you need to add a dependency, don't just change the package.json file. Properly use `yarn add` so you get the latest version, unless the user specifies a version or tells you otherwise.
+- Use tool calls to read files and directories where possible, instead of running "ls", "dir", etc.

package/.cursor/rules/mobx-state.mdc

@@ -0,0 +1,33 @@
+---
+description: MobX state management and component structure
+alwaysApply: true
+---
+
+# MobX State Management
+
+We use MobX for state management. Components should use a variable called `synced` that is an observable for their state, and never `Component.state`. All components need the `@observer` decorator.
+
+For example:
+
+```tsx
+import preact from "preact";
+import { observable } from "mobx";
+
+@observer
+class Example extends preact.Component {
+    synced = observable({
+        x: 0,
+    });
+
+    render() {
+        return <div>
+            <button onClick={() => this.synced.x++}>
+                Click me
+            </button>
+            <p>
+                {this.synced.x}
+            </p>
+        </div>;
+    }
+}
+```

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

@@ -0,0 +1,99 @@
+---
+description: CSS and Styling guidelines
+alwaysApply: true
+---
+
+# Styling and CSS
+
+- Never use `em` or `rem`. Only use `px` or `vw`/`vh`/`%`.
+- Don't add font colors unless asked to add styling. Don't add any aesthetics beyond `hbox`/`vbox`/`pad2` unless asked to add styling. Don't add `fontSize` unless asked to add styling. If you believe styling is possible, just tell the user, "I can add styling, but won't do it unless you ask me to."
+- Never use `h1`/`h2`/`h3` etc. These classes have extremely large built-in margins and paddings, instead set the font size explicitly.
+- Make sure to not use `fillWidth`, where `flexGrow(1)` would suffice.
+- Add very little styling, such as colours, rounding, etc, unless asked to add more styling.
+
+## CSS Helper
+
+CSS should be set using `className={css.cssPropertyName(cssPropertyValue).anotherPropertyName...}`. Always use the `css` helper for styling.
+
+For example:
+```tsx
+<div className={css.width(100).height(50)}>My width is 100px, my height is 50px</div>
+```
+
+All css fields can be set in this way, with the function being the field name and the argument being the value. Generally speaking, the CSS helpers are on two lines. Wrapping is fine.
+```tsx
+className={css.size(100, 100).hbox(4)
+    .hsl(0, 50, 50).borderRadius(4)
+}
+```
+
+Conditionals come after, and should use this style:
+```tsx
+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.
+
+## Aliases and Helpers
+
+If you want to make a NON-Button feel like a button, you can use `css.button`, which makes the background color change on hover, and make the cursor a pointer. Only use this if the background color is set, otherwise you need to message it's a button in another way. And never use it for `<Button>`/`<button>` which already does this.
+
+Generally use `hbox`/`vbox` to set the spacing between elements, instead of using margins.
+
+There are also some special aliases, some of which take parameters, some of which don't (which allows them to be chained like so: `css.vbox0.wrap`):
+```typescript
+let nonCallAliases = {
+    relative: (c: CSSHelperTypeBase) => c.position("relative"),
+    absolute: (c: CSSHelperTypeBase) => c.position("absolute"),
+    fixed: (c: CSSHelperTypeBase) => c.position("fixed"),
+    wrap: (c: CSSHelperTypeBase) => c.flexWrap("wrap").display("flex", "soft").alignItems("center", "soft"),
+    marginAuto: (c: CSSHelperTypeBase) => c.margin("auto"),
+    fillBoth: (c: CSSHelperTypeBase) => c.width("100%").height("100%"),
+    fillWidth: (c: CSSHelperTypeBase) => c.width("100%"),
+    fillHeight: (c: CSSHelperTypeBase) => c.height("100%"),
+    flexShrink0: (c: CSSHelperTypeBase) => c.flexShrink(0),
+    ellipsis: (c: CSSHelperTypeBase) => c.overflow("hidden").textOverflow("ellipsis").whiteSpace("nowrap").display("inline-block"),
+    overflowAuto: (c: CSSHelperTypeBase) => c.overflow("auto"),
+    overflowHidden: (c: CSSHelperTypeBase) => c.overflow("hidden"),
+};
+
+let callAliases = {
+    hbox: (c: CSSHelperTypeBase, gap: number, rowGap?: number) => c.display("flex").flexDirection("row").rowGap(rowGap ?? gap).columnGap(gap).alignItems("center", "soft"),
+    vbox: (c: CSSHelperTypeBase, gap: number, columnGap?: number) => c.display("flex").flexDirection("column").rowGap(gap).columnGap(columnGap ?? gap).alignItems("start", "soft"),
+    pad2: (c: CSSHelperTypeBase, value: number, verticalValue?: number): CSSHelperTypeBase => {
+        if (verticalValue !== undefined) return c.padding(`${verticalValue}px ${value}px` as any);
+        return c.padding(value);
+    },
+    hsl: (c: CSSHelperTypeBase, h: number, s: number, l: number): CSSHelperTypeBase => c.background(`hsl(${h}, ${s}%, ${l}%)`),
+    hslhover: (c: CSSHelperTypeBase, h: number, s: number, l: number): CSSHelperTypeBase => c.background(`hsl(${h}, ${s}%, ${l}%)`, "hover"),
+    hsla: (c: CSSHelperTypeBase, h: number, s: number, l: number, a: number): CSSHelperTypeBase => c.background(`hsla(${h}, ${s}%, ${l}%, ${a})`),
+    hslahover: (c: CSSHelperTypeBase, h: number, s: number, l: number, a: number): CSSHelperTypeBase => c.background(`hsla(${h}, ${s}%, ${l}%, ${a})`, "hover"),
+    bord: (c: CSSHelperTypeBase, width: number, color: string | { h: number; s: number; l: number; a?: number; }, style = "solid"): CSSHelperTypeBase => {
+        let colorStr = typeof color === "string" ? color : `hsla(${color.h}, ${color.s}%, ${color.l}%, ${color.a ?? 1})`;
+        return c.border(`${width}px ${style} ${colorStr}`);
+    },
+    bord2: (c: CSSHelperTypeBase, h: number, s: number, l: number, width = 1, style = "solid"): CSSHelperTypeBase => {
+        return c.border(`${width}px ${style} hsla(${h}, ${s}%, ${l}%, 1)`);
+    },
+    hslcolor: (c: CSSHelperTypeBase, h: number, s: number, l: number): CSSHelperTypeBase => c.color(`hsl(${h}, ${s}%, ${l}%)`),
+    colorhsl: (c: CSSHelperTypeBase, h: number, s: number, l: number): CSSHelperTypeBase => c.color(`hsl(${h}, ${s}%, ${l}%)`),
+    hslacolor: (c: CSSHelperTypeBase, h: number, s: number, l: number, a: number): CSSHelperTypeBase => c.color(`hsla(${h}, ${s}%, ${l}%, ${a})`),
+    colorhsla: (c: CSSHelperTypeBase, h: number, s: number, l: number, a: number): CSSHelperTypeBase => c.color(`hsla(${h}, ${s}%, ${l}%, ${a})`),
+    size: (c: CSSHelperTypeBase, width: LengthOrPercentage, height: LengthOrPercentage) => c.width(width).height(height),
+    pos: (c: CSSHelperTypeBase, x: LengthOrPercentage, y: LengthOrPercentage) => c.left(x).top(y),
+};
+```
+
+## Animations
+
+For animation keyframes, a style tag is required.
+```tsx
+<style>{`
+    @keyframes spinner-ring {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
+    }
+`}</style>
+```

package/builders/setup.ts

@@ -11,8 +11,8 @@ async function main() {
     console.log(`Target: ${targetDir}`);
 
     // Directories and files to copy
-    let directoriesToScan = ["electron", "extension", "web", "nodejs", "assets", ".vscode"];
-    let rootFiles = [".cursorrules", ".eslintrc.js", ".gitignore", "tsconfig.json"];
+    let directoriesToScan = ["electron", "extension", "web", "nodejs", "assets", ".vscode", ".cursor"];
+    let rootFiles = [".eslintrc.js", ".gitignore", "tsconfig.json"];
 
     // Import path mappings to convert relative imports to package imports
     let importMappings: { [key: string]: string } = {

package/index.d.ts

@@ -291,19 +291,8 @@ declare module "sliftutils/misc/yamlBase" {
 }
 
 declare module "sliftutils/misc/zip" {
-    /// <reference types="node" />
-    /// <reference types="node" />
-    import { MaybePromise } from "socket-function/src/types";
-    export declare class Zip {
-        static gzip(buffer: Buffer, level?: number): Promise<Buffer>;
-        static gzipSync(buffer: Buffer, level?: number): Buffer;
-        static gunzip(buffer: Buffer): MaybePromise<Buffer>;
-        static gunzipAsyncBase(buffer: Buffer): Promise<Buffer>;
-        static gunzipUntracked(buffer: Buffer): Promise<Buffer>;
-        static gunzipSync(buffer: Buffer): Buffer;
-        private static gunzipUntrackedSync;
-        static gunzipBatch(buffers: Buffer[]): Promise<Buffer[]>;
-    }
+    import { Zip } from "socket-function/src/Zip";
+    export { Zip };
 
 }
 
@@ -453,7 +442,7 @@ declare module "sliftutils/render-utils/Input" {
 
 declare module "sliftutils/render-utils/InputLabel" {
     import preact from "preact";
-    type InputProps = (preact.JSX.HTMLAttributes<HTMLInputElement> & {
+    export type InputProps = (preact.JSX.HTMLAttributes<HTMLInputElement> & {
         /** ONLY throttles onChangeValue */
         throttle?: number;
         flavor?: "large" | "small" | "none";
@@ -513,7 +502,6 @@ declare module "sliftutils/render-utils/InputLabel" {
     }> {
         render(): preact.JSX.Element;
     }
-    export {};
 
 }
 
@@ -1235,6 +1223,107 @@ declare module "sliftutils/storage/TransactionStorage" {
 
 }
 
+declare module "sliftutils/storage/backblaze" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    export declare class ArchivesBackblaze {
+        private config;
+        constructor(config: {
+            bucketName: string;
+            public?: boolean;
+            immutable?: boolean;
+            cacheTime?: number;
+        });
+        private bucketName;
+        private bucketId;
+        private logging;
+        enableLogging(): void;
+        private log;
+        getDebugName(): string;
+        private getBucketAPI;
+        private last503Reset;
+        private apiRetryLogic;
+        get(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+            retryCount?: number;
+        }): Promise<Buffer | undefined>;
+        set(fileName: string, data: Buffer): Promise<void>;
+        del(fileName: string): Promise<void>;
+        setLargeFile(config: {
+            path: string;
+            getNextData(): Promise<Buffer | undefined>;
+        }): Promise<void>;
+        getInfo(fileName: string): Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        find(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<string[]>;
+        findInfo(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<{
+            path: string;
+            createTime: number;
+            size: number;
+        }[]>;
+        assertPathValid(path: string): Promise<void>;
+        getURL(path: string): Promise<string>;
+        getDownloadAuthorization(config: {
+            fileNamePrefix?: string;
+            validDurationInSeconds: number;
+            b2ContentDisposition?: string;
+            b2ContentLanguage?: string;
+            b2Expires?: string;
+            b2CacheControl?: string;
+            b2ContentEncoding?: string;
+            b2ContentType?: string;
+        }): Promise<{
+            bucketId: string;
+            fileNamePrefix: string;
+            authorizationToken: string;
+        }>;
+    }
+    export declare const getArchivesBackblaze: {
+        (key: string): ArchivesBackblaze;
+        clear(key: string): void;
+        clearAll(): void;
+        forceSet(key: string, value: ArchivesBackblaze): void;
+        getAllKeys(): string[];
+        get(key: string): ArchivesBackblaze | undefined;
+    };
+    export declare const getArchivesBackblazePrivateImmutable: {
+        (key: string): ArchivesBackblaze;
+        clear(key: string): void;
+        clearAll(): void;
+        forceSet(key: string, value: ArchivesBackblaze): void;
+        getAllKeys(): string[];
+        get(key: string): ArchivesBackblaze | undefined;
+    };
+    export declare const getArchivesBackblazePublicImmutable: {
+        (key: string): ArchivesBackblaze;
+        clear(key: string): void;
+        clearAll(): void;
+        forceSet(key: string, value: ArchivesBackblaze): void;
+        getAllKeys(): string[];
+        get(key: string): ArchivesBackblaze | undefined;
+    };
+    export declare const getArchivesBackblazePublic: {
+        (key: string): ArchivesBackblaze;
+        clear(key: string): void;
+        clearAll(): void;
+        forceSet(key: string, value: ArchivesBackblaze): void;
+        getAllKeys(): string[];
+        get(key: string): ArchivesBackblaze | undefined;
+    };
+
+}
+
 declare module "sliftutils/storage/fileSystemPointer" {
     export type FileSystemPointer = string;
     export declare function storeFileSystemPointer(config: {

package/misc/zip.d.ts

@@ -1,13 +1,2 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { MaybePromise } from "socket-function/src/types";
-export declare class Zip {
-    static gzip(buffer: Buffer, level?: number): Promise<Buffer>;
-    static gzipSync(buffer: Buffer, level?: number): Buffer;
-    static gunzip(buffer: Buffer): MaybePromise<Buffer>;
-    static gunzipAsyncBase(buffer: Buffer): Promise<Buffer>;
-    static gunzipUntracked(buffer: Buffer): Promise<Buffer>;
-    static gunzipSync(buffer: Buffer): Buffer;
-    private static gunzipUntrackedSync;
-    static gunzipBatch(buffers: Buffer[]): Promise<Buffer[]>;
-}
+import { Zip } from "socket-function/src/Zip";
+export { Zip };

package/misc/zip.ts

@@ -5,109 +5,7 @@ import * as pako from "pako";
 
 import { setFlag } from "socket-function/require/compileFlags";
 import { MaybePromise } from "socket-function/src/types";
+import { Zip } from "socket-function/src/Zip";
 setFlag(require, "pako", "allowclient", true);
 
-const SYNC_THRESHOLD_BYTES = 100_000_000;
-
-export class Zip {
-    @measureFnc
-    public static async gzip(buffer: Buffer, level?: number): Promise<Buffer> {
-        if (isNode()) {
-            return new Promise((resolve, reject) => {
-                zlib.gzip(buffer, { level }, (err: any, result: Buffer) => {
-                    if (err) reject(err);
-                    else resolve(result);
-                });
-            });
-        } else {
-            // @ts-ignore
-            return await doStream(new CompressionStream("gzip"), buffer);
-        }
-    }
-    @measureFnc
-    public static gzipSync(buffer: Buffer, level?: number): Buffer {
-        if (isNode()) {
-            return Buffer.from(zlib.gzipSync(buffer, { level }));
-        }
-        return Buffer.from(pako.deflate(buffer));
-    }
-    public static gunzip(buffer: Buffer): MaybePromise<Buffer> {
-        // Switch to the synchronous version if the buffer is small. This is a lot faster in Node.js and clientside.
-        //  - On tests of random small amounts of data, this seems to be up to 7X faster (on node). However, on non-random data, on the actual data we're using, it seems to be almost 50 times faster. So... definitely worth it...
-        if (buffer.length < SYNC_THRESHOLD_BYTES) {
-            let time = Date.now();
-            let result = Zip.gunzipSync(buffer);
-            let duration = Date.now() - time;
-            if (duration > 50) {
-                // Wait, so we don't lock up the main thread. And if we already wait it 50ms, then waiting for one frame is marginal, even client-side. 
-                return ((async () => {
-                    await new Promise(resolve => setTimeout(resolve, 0));
-                    return result;
-                }))();
-            }
-            return result;
-        }
-        return Zip.gunzipAsyncBase(buffer);
-    }
-    @measureFnc
-    public static async gunzipAsyncBase(buffer: Buffer): Promise<Buffer> {
-        return Zip.gunzipUntracked(buffer);
-    }
-    // A base function, so we can avoid instrumentation for batch calls
-    public static async gunzipUntracked(buffer: Buffer): Promise<Buffer> {
-        if (isNode()) {
-            return await new Promise<Buffer>((resolve, reject) => {
-                zlib.gunzip(buffer, (err: any, result: Buffer) => {
-                    if (err) reject(err);
-                    else resolve(result);
-                });
-            });
-        }
-        return await doStream(new DecompressionStream("gzip"), buffer);
-    }
-
-    @measureFnc
-    public static gunzipSync(buffer: Buffer): Buffer {
-        return this.gunzipUntrackedSync(buffer);
-    }
-    private static gunzipUntrackedSync(buffer: Buffer): Buffer {
-        if (isNode()) {
-            return Buffer.from(zlib.gunzipSync(buffer));
-        }
-        return Buffer.from(pako.inflate(buffer));
-    }
-
-    @measureFnc
-    public static async gunzipBatch(buffers: Buffer[]): Promise<Buffer[]> {
-        let time = Date.now();
-        buffers = await Promise.all(buffers.map(x => {
-            if (x.length < SYNC_THRESHOLD_BYTES) {
-                return this.gunzipUntrackedSync(x);
-            }
-            return this.gunzipUntracked(x);
-        }));
-        time = Date.now() - time;
-        let totalSize = buffers.reduce((acc, buffer) => acc + buffer.length, 0);
-        //console.log(`Gunzip ${formatNumber(totalSize)}B at ${formatNumber(totalSize / time * 1000)}B/s`);
-        return buffers;
-    }
-}
-
-async function doStream(stream: GenericTransformStream, buffer: Buffer): Promise<Buffer> {
-    let reader = stream.readable.getReader();
-    let writer = stream.writable.getWriter();
-    let writePromise = writer.write(buffer);
-    let closePromise = writer.close();
-
-    let outputBuffers: Buffer[] = [];
-    while (true) {
-        let { value, done } = await reader.read();
-        if (done) {
-            await writePromise;
-            await closePromise;
-            return Buffer.concat(outputBuffers);
-        }
-        outputBuffers.push(Buffer.from(value));
-    }
-
-}
+export { Zip };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.2.1",
+    "version": "1.2.3",
     "main": "index.js",
     "license": "MIT",
     "files": [
@@ -50,7 +50,7 @@
         "mobx": "^6.13.3",
         "preact-old-types": "^10.28.1",
         "shell-quote": "^1.8.3",
-        "socket-function": "^1.0.1",
+        "socket-function": "^1.1.1",
         "typenode": "*",
         "typesafecss": "*",
         "ws": "^8.18.3",

package/render-utils/InputLabel.d.ts

@@ -1,5 +1,5 @@
 import preact from "preact";
-type InputProps = (preact.JSX.HTMLAttributes<HTMLInputElement> & {
+export type InputProps = (preact.JSX.HTMLAttributes<HTMLInputElement> & {
     /** ONLY throttles onChangeValue */
     throttle?: number;
     flavor?: "large" | "small" | "none";
@@ -59,4 +59,3 @@ export declare class InputLabelURL extends preact.Component<InputLabelProps & {
 }> {
     render(): preact.JSX.Element;
 }
-export {};

package/render-utils/InputLabel.tsx

@@ -6,7 +6,7 @@ import { observer } from "./observer";
 import { observable } from "mobx";
 
 // IMPORTANT! InputProps is in both InputLabel.tsx and Input.tsx, so the types export correctly
-type InputProps = (
+export type InputProps = (
     preact.JSX.HTMLAttributes<HTMLInputElement>
     & {
         /** ONLY throttles onChangeValue */