solid-tiny-utils 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 g-mero
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# solid-tiny-utils
+
+Tiny utilities for SolidJS applications.
+
+## Installation
+
+```bash
+pnpm add solid-tiny-utils
+```
+
+## Usage
+
+```typescript
+import { access, createWatch, CreateLoopExec, isFn, isArray } from 'solid-tiny-utils';
+```
+
+## API
+
+### Reactive
+
+#### `access(value)`
+Safely access a value that might be an accessor function.
+
+```typescript
+const value = access(maybeAccessor); // Returns the value directly or calls the accessor
+```
+
+#### `createWatch(targets, fn, options?)`
+Create a watcher that runs when dependencies change.
+
+```typescript
+createWatch(() => signal(), (value) => {
+  console.log('Value changed:', value);
+});
+```
+
+### Functions
+
+#### `CreateLoopExec(fn, delay)`
+Execute a function in a loop with cleanup support.
+
+```typescript
+CreateLoopExec(
+  async () => {
+    // Your async work here
+  },
+  1000 // Delay in milliseconds
+);
+```
+
+### Type Guards
+
+#### `isFn(value)`
+Check if a value is a function.
+
+```typescript
+if (isFn(value)) {
+  value(); // TypeScript knows it's a function
+}
+```
+
+#### `isArray(value)`
+Check if a value is an array.
+
+```typescript
+if (isArray(value)) {
+  value.forEach(...); // TypeScript knows it's an array
+}
+```
+
+### Types
+
+```typescript
+type MaybeArray<T> = T | T[];
+type MaybePromise<T> = T | Promise<T>;
+type MaybeAccessor<T> = T | Accessor<T>;
+```

package/dist/chunk-4L6FK7MF.js

@@ -0,0 +1,9 @@
+// src/reactive/create-watch.ts
+import { createEffect, on } from "solid-js";
+function createWatch(targets, fn, opt) {
+  createEffect(on(targets, fn, opt));
+}
+
+export {
+  createWatch
+};

package/dist/chunk-7K22IJFO.js

@@ -0,0 +1,12 @@
+import {
+  isFn
+} from "./chunk-PEWQLY2D.js";
+
+// src/reactive/access.ts
+function access(value) {
+  return isFn(value) ? value() : value;
+}
+
+export {
+  access
+};

package/dist/chunk-PEWQLY2D.js

@@ -0,0 +1,12 @@
+// src/is/index.ts
+function isFn(value) {
+  return typeof value === "function";
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+
+export {
+  isFn,
+  isArray
+};

package/dist/chunk-WAZBT4BV.js

@@ -0,0 +1,23 @@
+import {
+  access
+} from "./chunk-7K22IJFO.js";
+
+// src/fn/create-debounce.ts
+import { onCleanup } from "solid-js";
+function createDebounce(callback, delay) {
+  let timeoutId;
+  onCleanup(() => {
+    clearTimeout(timeoutId);
+  });
+  const run = (...args) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => {
+      callback(...args);
+    }, access(delay));
+  };
+  return run;
+}
+
+export {
+  createDebounce
+};

package/dist/chunk-ZHWDHAF3.js

@@ -0,0 +1,56 @@
+import {
+  access
+} from "./chunk-7K22IJFO.js";
+import {
+  createWatch
+} from "./chunk-4L6FK7MF.js";
+
+// src/fn/create-loop-exec.ts
+import { onCleanup } from "solid-js";
+function createLoopExec(fn, delay) {
+  let shouldStop = false;
+  let isCleanedUp = false;
+  let timer;
+  const execFn = async () => {
+    clearTimeout(timer);
+    if (shouldStop) {
+      return;
+    }
+    try {
+      await fn();
+    } finally {
+      timer = setTimeout(() => {
+        execFn();
+      }, access(delay));
+    }
+  };
+  createWatch(
+    () => access(delay),
+    () => {
+      execFn();
+    }
+  );
+  const stop = () => {
+    shouldStop = true;
+    clearTimeout(timer);
+  };
+  const start = () => {
+    if (isCleanedUp) {
+      return;
+    }
+    shouldStop = false;
+    execFn();
+  };
+  onCleanup(() => {
+    isCleanedUp = true;
+    stop();
+  });
+  return {
+    stop,
+    start
+  };
+}
+
+export {
+  createLoopExec
+};

package/dist/fn/create-debounce.d.ts

@@ -0,0 +1,6 @@
+import { MaybeAccessor } from '../types/maybe.js';
+import 'solid-js';
+
+declare function createDebounce<Args extends unknown[]>(callback: (...args: Args) => void, delay: MaybeAccessor<number>): (...args: Args) => void;
+
+export { createDebounce };

package/dist/fn/create-debounce.js

@@ -0,0 +1,10 @@
+import {
+  createDebounce
+} from "../chunk-WAZBT4BV.js";
+import "../chunk-ZZNAXGNU.js";
+import "../chunk-7K22IJFO.js";
+import "../chunk-PEWQLY2D.js";
+import "../chunk-4L6FK7MF.js";
+export {
+  createDebounce
+};

package/dist/fn/create-loop-exec.d.ts

@@ -0,0 +1,21 @@
+import { MaybePromise, MaybeAccessor } from '../types/maybe.js';
+import 'solid-js';
+
+/**
+ * Repeatedly executes an asynchronous function with a specified delay between each execution.
+ * The loop continues until the surrounding SolidJS effect is cleaned up.
+ *
+ * @param fn - The asynchronous function to execute in a loop. Can return a promise or void.
+ * @param delay - The delay (in milliseconds) between each execution. Can be a number or a reactive accessor.
+ *
+ * @remarks
+ * - The loop is automatically stopped when cleanup.
+ * - `fn`'s error will not stop scheduling.
+ * - Uses `setTimeout` for scheduling and `onCleanup` for resource management.
+ */
+declare function createLoopExec(fn: () => MaybePromise<void>, delay: MaybeAccessor<number>): {
+    stop: () => void;
+    start: () => void;
+};
+
+export { createLoopExec };

package/dist/fn/create-loop-exec.js

@@ -0,0 +1,10 @@
+import {
+  createLoopExec
+} from "../chunk-ZHWDHAF3.js";
+import "../chunk-ZZNAXGNU.js";
+import "../chunk-7K22IJFO.js";
+import "../chunk-PEWQLY2D.js";
+import "../chunk-4L6FK7MF.js";
+export {
+  createLoopExec
+};

package/dist/fn/index.d.ts

@@ -0,0 +1,4 @@
+export { createDebounce } from './create-debounce.js';
+export { createLoopExec } from './create-loop-exec.js';
+import '../types/maybe.js';
+import 'solid-js';

package/dist/fn/index.js

@@ -0,0 +1,15 @@
+import "../chunk-QKJKTJQE.js";
+import {
+  createDebounce
+} from "../chunk-WAZBT4BV.js";
+import {
+  createLoopExec
+} from "../chunk-ZHWDHAF3.js";
+import "../chunk-ZZNAXGNU.js";
+import "../chunk-7K22IJFO.js";
+import "../chunk-PEWQLY2D.js";
+import "../chunk-4L6FK7MF.js";
+export {
+  createDebounce,
+  createLoopExec
+};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { createDebounce } from './fn/create-debounce.js';
+export { createLoopExec } from './fn/create-loop-exec.js';
+export { isArray, isFn } from './is/index.js';
+export { access } from './reactive/access.js';
+export { createWatch } from './reactive/create-watch.js';
+export { MaybeAccessor, MaybeArray, MaybePromise } from './types/maybe.js';
+import 'solid-js';

package/dist/index.js

@@ -0,0 +1,28 @@
+import "./chunk-2BUPSB7O.js";
+import "./chunk-EZML2DEC.js";
+import "./chunk-QKJKTJQE.js";
+import {
+  createDebounce
+} from "./chunk-WAZBT4BV.js";
+import {
+  createLoopExec
+} from "./chunk-ZHWDHAF3.js";
+import "./chunk-ZZNAXGNU.js";
+import {
+  access
+} from "./chunk-7K22IJFO.js";
+import {
+  isArray,
+  isFn
+} from "./chunk-PEWQLY2D.js";
+import {
+  createWatch
+} from "./chunk-4L6FK7MF.js";
+export {
+  access,
+  createDebounce,
+  createLoopExec,
+  createWatch,
+  isArray,
+  isFn
+};

package/dist/is/index.d.ts

@@ -0,0 +1,4 @@
+declare function isFn(value: unknown): value is Function;
+declare function isArray<T>(value: unknown): value is T[];
+
+export { isArray, isFn };

package/dist/is/index.js

@@ -0,0 +1,8 @@
+import {
+  isArray,
+  isFn
+} from "../chunk-PEWQLY2D.js";
+export {
+  isArray,
+  isFn
+};

package/dist/reactive/access.d.ts

@@ -0,0 +1,6 @@
+import { MaybeAccessor } from '../types/maybe.js';
+import 'solid-js';
+
+declare function access<T>(value: MaybeAccessor<T>): T;
+
+export { access };

package/dist/reactive/access.js

@@ -0,0 +1,7 @@
+import {
+  access
+} from "../chunk-7K22IJFO.js";
+import "../chunk-PEWQLY2D.js";
+export {
+  access
+};

package/dist/reactive/create-watch.d.ts

@@ -0,0 +1,5 @@
+import { AccessorArray, Accessor, OnEffectFunction, OnOptions } from 'solid-js';
+
+declare function createWatch<S, Next extends Prev, Prev = Next>(targets: AccessorArray<S> | Accessor<S>, fn: OnEffectFunction<S, undefined | NoInfer<Prev>, Next>, opt?: OnOptions): void;
+
+export { createWatch };

package/dist/reactive/create-watch.js

@@ -0,0 +1,6 @@
+import {
+  createWatch
+} from "../chunk-4L6FK7MF.js";
+export {
+  createWatch
+};

package/dist/reactive/index.d.ts

@@ -0,0 +1,4 @@
+export { access } from './access.js';
+export { createWatch } from './create-watch.js';
+import '../types/maybe.js';
+import 'solid-js';

package/dist/reactive/index.js

@@ -0,0 +1,12 @@
+import "../chunk-ZZNAXGNU.js";
+import {
+  access
+} from "../chunk-7K22IJFO.js";
+import "../chunk-PEWQLY2D.js";
+import {
+  createWatch
+} from "../chunk-4L6FK7MF.js";
+export {
+  access,
+  createWatch
+};

package/dist/types/fn.d.ts

@@ -0,0 +1,3 @@
+type AnyFn<R = any> = (...args: any[]) => R;
+
+export type { AnyFn };

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export { MaybeAccessor, MaybeArray, MaybePromise } from './maybe.js';
+import 'solid-js';

package/dist/types/index.js

@@ -0,0 +1,2 @@
+import "../chunk-2BUPSB7O.js";
+import "../chunk-EZML2DEC.js";

package/dist/types/maybe.d.ts

@@ -0,0 +1,7 @@
+import { Accessor } from 'solid-js';
+
+type MaybeArray<T> = T | T[];
+type MaybePromise<T> = T | Promise<T>;
+type MaybeAccessor<T> = T | Accessor<T>;
+
+export type { MaybeAccessor, MaybeArray, MaybePromise };

package/dist/types/maybe.js

@@ -0,0 +1 @@
+import "../chunk-EZML2DEC.js";

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "solid-tiny-utils",
+  "version": "0.0.1",
+  "description": "A collection of tiny utilities for SolidJS applications",
+  "main": "./dist/index.js",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "peerDependencies": {
+    "solid-js": "^1.9.7"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.1.2",
+    "@vitest/ui": "^3.2.4",
+    "commit-and-tag-version": "^12.5.1",
+    "husky": "^9.1.7",
+    "jsdom": "^26.1.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "ultracite": "5.1.2",
+    "unocss": "^66.3.3",
+    "vite": "^6.2.1",
+    "vite-plugin-solid": "^2.11.0",
+    "vitest": "^3.2.4"
+  },
+  "keywords": [
+    "solidjs",
+    "solid",
+    "utilities",
+    "reactive",
+    "typescript",
+    "utils"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "solid-tiny-context": "0.1.2"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "vite",
+    "test": "vitest",
+    "test:run": "vitest --run",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
+    "lint": "npx ultracite lint",
+    "lint:fix": "npx ultracite format",
+    "type-check": "tsc --noEmit --skipLibCheck",
+    "release": "pnpm lint:fix && pnpm test:run &&commit-and-tag-version -i CHANGELOG.md --same-file",
+    "pub": "pnpm build && pnpm publish"
+  }
+}