@tempots/dom 20.0.0 → 20.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tempots/dom",
-  "version": "20.0.0",
+  "version": "20.1.0",
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",

package/renderable/ensure.d.ts

@@ -1,13 +1,13 @@
-import { TNode, Renderable } from '../types/domain';
+import { TNode, Renderable, Value } from '../types/domain';
 import { Signal } from '../std/signal';
 /**
  * Represents a function that ensures a signal has a value before rendering a TNode.
  *
  * @typeParam T - The type of the signal value.
- * @param signal - The signal to ensure has a value.
+ * @param value - The signal or literal that may hold a value of type T or null or undefined.
  * @param then - The function that returns a TNode when the signal has a value. It takes a signal of the non-nullable type of T.
  * @param otherwise - The function that returns a TNode when the signal does not have a value.
  * @returns A renderable function that ensures the signal has a value before rendering a TNode.
  * @public
  */
-export declare const Ensure: <T>(signal: Signal<T | null> | Signal<T | undefined> | Signal<T | null | undefined>, then: (value: Signal<NonNullable<T>>) => TNode, otherwise?: () => TNode) => Renderable;
+export declare const Ensure: <T>(value: Value<T | null> | Value<T | undefined> | Value<T | null | undefined>, then: (value: Signal<NonNullable<T>>) => TNode, otherwise?: () => TNode) => Renderable;

package/renderable/foreach.d.ts

@@ -1,14 +1,14 @@
-import { TNode, Renderable } from '../types/domain';
+import { TNode, Renderable, Value } from '../types/domain';
 import { Signal } from '../std/signal';
 import { ElementPosition } from '../std/position';
 /**
  * Renders a list of items based on a signal of arrays.
  *
  * @typeParam T - The type of items in the array.
- * @param signal - The signal of arrays to iterate over.
+ * @param value - The signal of arrays to iterate over.
  * @param item - The function that renders each item in the array.
  * @param separator - The function that renders the separator between items.
  * @returns - The renderable function that renders the list of items.
  * @public
  */
-export declare const ForEach: <T>(signal: Signal<T[]>, item: (value: Signal<T>, position: Signal<ElementPosition>) => TNode, separator?: (pos: Signal<ElementPosition>) => TNode) => Renderable;
+export declare const ForEach: <T>(value: Value<T[]>, item: (value: Signal<T>, position: Signal<ElementPosition>) => TNode, separator?: (pos: Signal<ElementPosition>) => TNode) => Renderable;

package/renderable/map-signal.d.ts

@@ -1,5 +1,4 @@
-import { Renderable } from '../types/domain';
-import { Signal } from '../std/signal';
+import { Renderable, Value } from '../types/domain';
 /**
  * Maps the values emitted by a signal to a renderable function and returns a new renderable function.
  *
@@ -10,9 +9,9 @@ import { Signal } from '../std/signal';
  * changes to a state that requires a different renderable function.
  *
  * @typeParam T - The type of values emitted by the signal.
- * @param signal - The signal to map.
+ * @param vlaue - The signal or value to map.
  * @param fn - The function to map the signal values to renderable functions.
  * @returns - A new renderable function that represents the mapped signal.
  * @public
  */
-export declare const MapSignal: <T>(signal: Signal<T>, fn: (value: T) => Renderable) => Renderable;
+export declare const MapSignal: <T>(value: Value<T>, fn: (value: T) => Renderable) => Renderable;

package/renderable/not-empty.d.ts

@@ -1,15 +1,14 @@
-import { Signal } from '../std/signal';
-import { Renderable } from '../types/domain';
+import { Renderable, Value } from '../types/domain';
 /**
  * Returns a renderable component that displays the given `display` component
  * when the `signal` contains a non-empty array, and the `whenEmpty` component
  * otherwise.
  *
  * @typeParam T - The type of elements in the array.
- * @param signal - The signal containing the array.
+ * @param value - The signal or literal containing the array.
  * @param display - The component to display when the array is non-empty.
  * @param whenEmpty- The component to display when the array is empty.
  * @returns - The renderable component.
  * @public
  */
-export declare const NotEmpty: <T>(signal: Signal<T[]>, display: Renderable, whenEmpty?: Renderable) => Renderable;
+export declare const NotEmpty: <T>(value: Value<T[]>, display: Renderable, whenEmpty?: Renderable) => Renderable;

package/renderable/oneof.d.ts

@@ -1,5 +1,5 @@
 import { Signal } from '../std/signal';
-import { Renderable, TNode } from '../types/domain';
+import { Renderable, TNode, Value } from '../types/domain';
 /**
  * Represents a set of options for a one-of type.
  * @typeParam T - The type of the options.
@@ -14,12 +14,12 @@ export type OneOfOptions<T extends Record<string, unknown>> = {
  * The signal value should be an object with a single key that matches one of the keys in the `cases` object.
  *
  * @typeParam T - The type of the signal value.
- * @param match - The signal to match against.
+ * @param match - The signal or value to match against.
  * @param cases - An object containing the different cases to render based on the signal value.
  * @returns A renderable function that renders the appropriate component based on the signal value.
  * @public
  */
-export declare const OneOf: <T extends Record<string, unknown>>(match: Signal<T>, cases: OneOfOptions<T>) => Renderable;
+export declare const OneOf: <T extends Record<string, unknown>>(match: Value<T>, cases: OneOfOptions<T>) => Renderable;
 /**
  * Represents the options for a one-of field.
  *
@@ -39,13 +39,13 @@ export type OneOfFieldOptions<T extends {
  *
  * @typeParam T - The type containing the one-of field.
  * @typeParam K - The type of the one-of field key.
- * @param match - The signal that emits the object containing the one-of field.
+ * @param match - The signal or value that emits the object containing the one-of field.
  * @param field - The key of the one-of field.
  * @param cases - The options for the different cases of rendering based on the one-of field value.
  * @returns - The renderable field representing the one-of field.
  * @public
  */
-export declare const OneOfField: <T extends { [_ in K]: string; }, K extends string>(match: Signal<T>, field: K, cases: OneOfFieldOptions<T, K>) => Renderable;
+export declare const OneOfField: <T extends { [_ in K]: string; }, K extends string>(match: Value<T>, field: K, cases: OneOfFieldOptions<T, K>) => Renderable;
 /**
  * The options for a one-of kind field.
  *
@@ -72,7 +72,7 @@ export type OneOfKindOptions<T extends {
  */
 export declare const OneOfKind: <T extends {
     kind: string;
-}>(match: Signal<T>, cases: OneOfKindOptions<T>) => Renderable;
+}>(match: Value<T>, cases: OneOfKindOptions<T>) => Renderable;
 /**
  * Represents a mapping of keys to functions that accept a value of type `Signal<V>`
  * and return a `TNode`.
@@ -94,7 +94,7 @@ export type OneOfTupleOptions<T extends string, V> = {
  * @returns The result of matching the signal value with the cases.
  * @public
  */
-export declare const OneOfTuple: <T extends string, V>(match: Signal<[T, V]>, cases: OneOfTupleOptions<T, V>) => Renderable;
+export declare const OneOfTuple: <T extends string, V>(match: Value<[T, V]>, cases: OneOfTupleOptions<T, V>) => Renderable;
 /**
  * Represents a mapping of types to rendering functions.
  * @typeParam T - The type that contains a `type` property.
@@ -120,7 +120,7 @@ export type OneOfTypeOptions<T extends {
  */
 export declare const OneOfType: <T extends {
     type: string;
-}>(match: Signal<T>, cases: OneOfTypeOptions<T>) => Renderable;
+}>(match: Value<T>, cases: OneOfTypeOptions<T>) => Renderable;
 /**
  * Represents a set of options for a one-of value.
  * @typeParam T - The type of the one-of value.
@@ -140,4 +140,4 @@ export type OneOfValueOptions<T extends symbol | number | string> = {
  * @returns - The renderable value representing one of the cases.
  * @public
  */
-export declare const OneOfValue: <T extends symbol | number | string>(match: Signal<T>, cases: OneOfValueOptions<T>) => Renderable;
+export declare const OneOfValue: <T extends symbol | number | string>(match: Value<T>, cases: OneOfValueOptions<T>) => Renderable;

package/renderable/repeat.d.ts

@@ -1,6 +1,6 @@
 import { ElementPosition } from '../std/position';
 import { Signal } from '../std/signal';
-import { TNode, Renderable } from '../types/domain';
+import { TNode, Renderable, Value } from '../types/domain';
 /**
  * Creates a renderable function that repeats a given element a specified number of times.
  *
@@ -10,4 +10,4 @@ import { TNode, Renderable } from '../types/domain';
  * @returns A renderable function that renders the repeated elements.
  * @public
  */
-export declare const Repeat: (times: Signal<number>, element: (index: Signal<ElementPosition>) => TNode, separator?: (pos: Signal<ElementPosition>) => TNode) => Renderable;
+export declare const Repeat: (times: Value<number>, element: (index: Signal<ElementPosition>) => TNode, separator?: (pos: Signal<ElementPosition>) => TNode) => Renderable;

package/renderable/when.d.ts

@@ -1,5 +1,4 @@
-import { Renderable, TNode } from '../types/domain';
-import { Signal } from '../std/signal';
+import { Renderable, TNode, Value } from '../types/domain';
 /**
  * Renders the `then` node if the `condition` is true, otherwise renders the `otherwise` node.
  *
@@ -9,7 +8,7 @@ import { Signal } from '../std/signal';
  * @returns The rendered node.
  * @public
  */
-export declare const When: (condition: Signal<boolean>, then: TNode, otherwise?: TNode) => Renderable;
+export declare const When: (condition: Value<boolean>, then: TNode, otherwise?: TNode) => Renderable;
 /**
  * Executes the `then` TNode if the `condition` Signal evaluates to `false`, otherwise executes the `otherwise` TNode.
  *
@@ -19,4 +18,4 @@ export declare const When: (condition: Signal<boolean>, then: TNode, otherwise?:
  * @returns The result of executing the `then` or `otherwise` TNode based on the condition.
  * @public
  */
-export declare const Unless: (condition: Signal<boolean>, then: TNode, otherwise?: TNode) => Renderable;
+export declare const Unless: (condition: Value<boolean>, then: TNode, otherwise?: TNode) => Renderable;

package/std/position.d.ts

@@ -41,13 +41,13 @@ export declare class ElementPosition {
      */
     get isLast(): boolean;
     /**
-     * Checks if the index of the element is even.
-     * @returns `true` if the index is even, `false` otherwise.
+     * Checks if the counter of the element is even.
+     * @returns `true` if the counter is even, `false` otherwise.
      */
     get isEven(): boolean;
     /**
-     * Checks if the index of the element is odd.
-     * @returns `true` if the index is odd, `false` otherwise.
+     * Checks if the counter of the element is odd.
+     * @returns `true` if the counter is odd, `false` otherwise.
      */
     get isOdd(): boolean;
 }

package/std/signal.d.ts

@@ -1,4 +1,4 @@
-import { Value } from '../types/domain';
+import { GetValueTypes, Value } from '../types/domain';
 /**
  * Represents any type of signal.
  * It can be a Signal, Prop, or Computed.
@@ -39,7 +39,7 @@ export declare class Signal<T> {
      * @param value - The value to check.
      * @returns `true` if the value is a Signal, `false` otherwise.
      */
-    static readonly is: <O = unknown>(value: unknown) => value is Signal<O>;
+    static readonly is: <O>(value: O | Signal<O>) => value is Signal<O>;
     /**
      * Wraps a value or a Signal instance into a Signal.
      * If the value is already a Signal, it returns the value itself.
@@ -363,7 +363,7 @@ export declare class Prop<T> extends Signal<T> {
      * @param value - The value to check.
      * @returns `true` if the value is a Prop, `false` otherwise.
      */
-    static is: <T_1 = unknown>(value: unknown) => value is Prop<T_1>;
+    static is: <T_1>(value: T_1 | Prop<T_1> | Signal<T_1> | Computed<T_1>) => value is Prop<T_1>;
     /**
      * @internal
      */
@@ -422,6 +422,16 @@ export declare class Prop<T> extends Signal<T> {
  * @public
  */
 export declare const makeComputed: <T>(fn: () => T, dependencies: Array<AnySignal>, equals?: (a: T, b: T) => boolean) => Computed<T>;
+/**
+ * Creates a computed signal that depends on other signals or literal values and updates when any of the dependencies change.
+ *
+ * @typeParam T - The type of the argument values.
+ * @param fn - The function that computes the value.
+ * @param equals - The equality function used to compare the previous and current computed values.
+ * @returns - The computed signal.
+ * @public
+ */
+export declare const makeComputedOf: <T extends Value<unknown>[]>(...args: T) => <O>(fn: (...args: GetValueTypes<T>) => O, equals?: (a: O, b: O) => boolean) => Computed<O>;
 /**
  * Executes the provided function `fn` whenever any of the signals in the `signals` array change.
  * Returns a disposable object that can be used to stop the effect.
@@ -432,6 +442,14 @@ export declare const makeComputed: <T>(fn: () => T, dependencies: Array<AnySigna
  * @public
  */
 export declare const makeEffect: (fn: () => void, signals: Array<AnySignal>) => () => void;
+/**
+ * Creates an effect that depends on other signals or literal values and updates when any of the dependencies change.
+ *
+ * @param args - The array of signals or literal values that the effect depends on.
+ * @returns A disposable object that can be used to stop the effect.
+ * @public
+ */
+export declare const makeEffectOf: <T extends Value<unknown>[]>(...args: T) => (fn: (...args: GetValueTypes<T>) => void) => void;
 /**
  * Creates a new Prop object with the specified value and equality function.
  *

package/types/domain.d.ts

@@ -66,6 +66,13 @@ export type NValue<T> = Value<T> | Value<T | null> | Value<T | undefined> | Valu
  * @public
  */
 export type GetValueType<T> = T extends Signal<infer V> ? V : T;
+/**
+ * Gets the value types of a given array of Value types.
+ * @public
+ */
+export type GetValueTypes<T extends Value<unknown>[]> = {
+    [K in keyof T]: GetValueType<T[K]>;
+};
 /**
  * Removes signals from a given object type and returns a new object type
  * with only the non-signal properties.