@tempots/dom 25.1.3 → 26.1.0

package/package.json

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

package/renderable/on.d.ts

@@ -121,6 +121,13 @@ export declare const emitValueAsNumber: (fn: (num: number) => void) => (event: E
  * @public
  */
 export declare const emitValueAsDate: (fn: (date: Date) => void) => (event: Event) => void;
+/**
+ * Converts the value of an HTML input element to a Date object or null and emits it using the provided callback function.
+ * @param fn - The callback function to be called with the converted Date object or null.
+ * @returns A function that can be used as an event handler for input events.
+ * @public
+ */
+export declare const emitValueAsNullableDate: (fn: (date: Date | null) => void) => (event: Event) => void;
 /**
  * Emits the value of an HTMLInputElement as a Date object.
  * @param fn - The callback function to be called with the emitted Date object.
@@ -128,6 +135,13 @@ export declare const emitValueAsDate: (fn: (date: Date) => void) => (event: Even
  * @public
  */
 export declare const emitValueAsDateTime: (fn: (date: Date) => void) => (event: Event) => void;
+/**
+ * Emits the value of an HTMLInputElement as a Date object or null.
+ * @param fn - The callback function to be called with the emitted Date object or null.
+ * @returns The event handler function.
+ * @public
+ */
+export declare const emitValueAsNullableDateTime: (fn: (date: Date | null) => void) => (event: Event) => void;
 /**
  * Calls the provided function with the checked value of the event target.
  * @param fn - The function to be called with the checked value.

package/renderable/{on-browser-ctx.d.ts → with-browser-ctx.d.ts}

@@ -11,4 +11,4 @@ import { Renderable, TNode } from '../types/domain';
  * @returns A Clear function that can be used to clean up any resources associated with the execution.
  * @public
  */
-export declare const OnBrowserCtx: (fn: (ctx: BrowserContext) => TNode | void) => Renderable;
+export declare const WithBrowserCtx: (fn: (ctx: BrowserContext) => TNode | void) => Renderable;

package/renderable/{on-ctx.d.ts → with-ctx.d.ts}

@@ -11,4 +11,4 @@ import { Renderable, TNode } from '../types/domain';
  * @returns A Clear function that can be used to clean up any resources associated with the execution.
  * @public
  */
-export declare const OnCtx: (fn: (ctx: DOMContext) => TNode | void) => Renderable;
+export declare const WithCtx: (fn: (ctx: DOMContext) => TNode | void) => Renderable;

package/renderable/{on-element.d.ts → with-element.d.ts}

@@ -11,4 +11,4 @@ import { Renderable, TNode } from '../types/domain';
  * @returns - The renderable function.
  * @public
  */
-export declare const OnElement: <T extends HTMLElement>(fn: (element: T) => TNode | void) => Renderable;
+export declare const WithElement: <T extends HTMLElement>(fn: (element: T) => TNode | void) => Renderable;

package/renderable/{on-headless-ctx.d.ts → with-headless-ctx.d.ts}

@@ -7,4 +7,4 @@ import { Renderable, TNode } from '../types/domain';
  * @returns A Clear function that can be used to clean up any resources associated with the execution.
  * @public
  */
-export declare const OnHeadlessCtx: (fn: (ctx: HeadlessContext) => TNode | void) => Renderable;
+export declare const WithHeadlessCtx: (fn: (ctx: HeadlessContext) => TNode | void) => Renderable;

package/renderable/with-provider.d.ts

@@ -0,0 +1,54 @@
+import { ProviderMark, Renderable, TNode } from '../types/domain';
+/**
+ * Converts a tuple type `T` into an array of `ProviderMark` types.
+ * If `T` is an empty tuple, returns an empty array.
+ * If `T` has only one element, returns an array with a single `ProviderMark`.
+ * If `T` has more than one element, recursively converts each element into a `ProviderMark` and returns an array.
+ * @public
+ */
+export type ToArrayOfMarks<T extends unknown[]> = T extends [] ? [] : T extends [infer K] ? [ProviderMark<K>] : T extends [infer K, ...infer R] ? [ProviderMark<K>, ...ToArrayOfMarks<R>] : never;
+/**
+ * Represents a type that transforms a tuple of values into an object where each value is associated with a provider mark.
+ * @typeParam T - The tuple of values.
+ * @returns An object where each value is associated with a provider mark.
+ * @public
+ */
+export type ToProviders<T extends unknown[]> = T extends [] ? [] : T extends [ProviderMark<infer K>] ? [K] : T extends [ProviderMark<infer K>, ...infer R] ? [K, ...ToProviders<R>] : never;
+export type ProviderOptions = {
+    use: <T>(mark: ProviderMark<T>) => T;
+    set: <T>(mark: ProviderMark<T>, value: T) => void;
+};
+/**
+ * Returns a renderable function that executes the given function with the
+ * current DOMContext as argument.
+ * The given function can return a TNode or void. If you need to perform some
+ * actions when the Renderable is disposed, you can use `OnDispose` as the
+ * return value.
+ *
+ * @param fn - The function to be executed with the DOMContext argument.
+ * @returns A Clear function that can be used to clean up any resources associated with the execution.
+ * @public
+ */
+export declare const WithProvider: (fn: (ctx: ProviderOptions) => TNode | void) => Renderable;
+/**
+ * Returns a renderable function that sets a provider for the given provider mark and returns a child renderable.
+ *
+ * @param mark - The provider mark to set the provider for.
+ * @param value - The provider to set for the given mark.
+ * @param child - The child renderable to return.
+ */
+export declare const SetProvider: <T>(mark: ProviderMark<T>, value: T, child: (provider: T) => TNode) => Renderable;
+/**
+ * Returns a renderable function that uses a provider for the given provider mark and returns a child renderable.
+ *
+ * @param mark - The provider mark to use the provider for.
+ * @param child - The child renderable to return.
+ */
+export declare const UseProvider: <T>(mark: ProviderMark<T>, child: (provider: T) => TNode) => Renderable;
+/**
+ * Returns a renderable function that uses a provider for the given provider marks and returns a child renderable.
+ *
+ * @param marks - The provider marks to use the providers for.
+ * @param child - The child renderable to return.
+ */
+export declare const UseProviders: <T extends unknown[]>(...marks: ToArrayOfMarks<T>) => (child: (...providers: ToProviders<T>) => TNode) => Renderable;

package/std/signal-utils.d.ts

@@ -223,4 +223,4 @@ export declare const animateSignal: <T>(signal: Signal<T>, options?: AnimateSign
  * @returns - The computed value as a signal.
  * @public
  */
-export declare const makeComputedRecord: <T extends Record<string, Value<unknown>>, O>(record: T, fn: (value: RemoveSignals<T>) => O) => Computed<O>;
+export declare const computedRecord: <T extends Record<string, Value<unknown>>, O>(record: T, fn: (value: RemoveSignals<T>) => O) => Computed<O>;

package/std/signal.d.ts

@@ -397,7 +397,7 @@ export declare class Prop<T> extends Signal<T> {
  * @returns - The computed signal.
  * @public
  */
-export declare const makeComputed: <T>(fn: () => T, dependencies: Array<AnySignal>, equals?: (a: T, b: T) => boolean) => Computed<T>;
+export declare const computed: <T>(fn: () => T, dependencies: Array<AnySignal>, equals?: (a: T, b: T) => boolean) => Computed<T>;
 /**
  * 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.
@@ -407,7 +407,7 @@ export declare const makeComputed: <T>(fn: () => T, dependencies: Array<AnySigna
  * @returns A disposable object that can be used to stop the effect.
  * @public
  */
-export declare const makeEffect: (fn: () => void, signals: Array<AnySignal>, options?: ListenerOptions) => () => void;
+export declare const effect: (fn: () => void, signals: Array<AnySignal>, options?: ListenerOptions) => () => void;
 /**
  * Creates a new Prop object with the specified value and equality function.
  *
@@ -417,7 +417,7 @@ export declare const makeEffect: (fn: () => void, signals: Array<AnySignal>, opt
  * @returns A new Prop object.
  * @public
  */
-export declare const makeProp: <T>(value: T, equals?: (a: T, b: T) => boolean) => Prop<T>;
+export declare const prop: <T>(value: T, equals?: (a: T, b: T) => boolean) => Prop<T>;
 /**
  * Creates a signal with the specified initial value and equality function.
  *
@@ -427,4 +427,4 @@ export declare const makeProp: <T>(value: T, equals?: (a: T, b: T) => boolean) =
  * @returns A new Signal instance.
  * @public
  */
-export declare const makeSignal: <T>(value: T, equals?: (a: T, b: T) => boolean) => Signal<T>;
+export declare const signal: <T>(value: T, equals?: (a: T, b: T) => boolean) => Signal<T>;

package/std/value.d.ts

@@ -81,7 +81,14 @@ export declare const Value: {
  * @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) => import('./signal').Computed<O>;
+export declare const computedOf: <T extends Value<unknown>[]>(...args: T) => <O>(fn: (...args: GetValueTypes<T>) => O, equals?: (a: O, b: O) => boolean) => import('./signal').Computed<O>;
+/**
+ * Joins a set of signals into a single signal that emits a record of the values.
+ * @param values - The set of signals to join as a record of `Value`s.
+ * @returns A signal that emits a record of the values.
+ * @public
+ */
+export declare const joinSignals: <T extends Record<string, Value<unknown>>>(values: T) => Signal<{ [K in keyof T]: T[K]; }>;
 /**
  * Creates an effect that depends on other signals or literal values and updates when any of the dependencies change.
  *
@@ -89,4 +96,4 @@ export declare const makeComputedOf: <T extends Value<unknown>[]>(...args: T) =>
  * @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, options?: ListenerOptions) => () => void;
+export declare const effectOf: <T extends Value<unknown>[]>(...args: T) => (fn: (...args: GetValueTypes<T>) => void, options?: ListenerOptions) => () => void;

package/renderable/consumers.d.ts

@@ -1,64 +0,0 @@
-import { TNode, Renderable, ProviderMark } from '../types/domain';
-/**
- * Converts a tuple type `T` into an array of `ProviderMark` types.
- * If `T` is an empty tuple, returns an empty array.
- * If `T` has only one element, returns an array with a single `ProviderMark`.
- * If `T` has more than one element, recursively converts each element into a `ProviderMark` and returns an array.
- * @public
- */
-export type ToArrayOfMarks<T extends unknown[]> = T extends [] ? [] : T extends [infer K] ? [ProviderMark<K>] : T extends [infer K, ...infer R] ? [ProviderMark<K>, ...ToArrayOfMarks<R>] : never;
-/**
- * Represents a type that transforms a tuple of values into an object where each value is associated with a provider mark.
- * @typeParam T - The tuple of values.
- * @returns An object where each value is associated with a provider mark.
- * @public
- */
-export type ToProviders<T extends unknown[]> = T extends [] ? object : T extends [infer K] ? {
-    [_ in ProviderMark<K>]: K;
-} : T extends [infer K, ...infer R] ? {
-    [_ in ProviderMark<K>]: K;
-} & ToProviders<R> : never;
-/**
- * Represents a consumer function that takes a callback function and returns a renderable object.
- * The callback function takes a value of type T and returns a TNode.
- *
- * @typeParam T - The type of the value passed to the callback function.
- * @public
- */
-export type Consumer<T> = (fn: (value: T) => TNode) => Renderable;
-/**
- * Represents a type that extracts the value types from a record of `Consumer` types.
- * @typeParam C - The record of `Consumer` types.
- * @public
- */
-export type UseMany<C extends Record<string, Consumer<unknown>>> = {
-    [K in keyof C]: C[K] extends Consumer<infer V> ? V : never;
-};
-/**
- * Creates a renderable function that consumes data from multiple consumers and renders the result.
- *
- * @param providers - An object containing consumer functions.
- * @param fn - A function that receives the data from the consumers and returns a renderable function.
- * @returns A renderable function that can be called with a DOMContext and returns a cleanup function.
- * @public
- */
-export declare const Use: <C extends Record<string, Consumer<unknown>>>(providers: C, fn: (data: UseMany<C>) => TNode) => Renderable;
-/**
- * Creates a renderable function that consumes a provider value and renders a `TNode`.
- *
- * @typeParam T - The type of the provider value.
- * @param mark - The provider mark.
- * @param fn - The function that takes the provider value and returns a `TNode`.
- * @returns A renderable function that consumes the provider value and renders a `TNode`.
- * @public
- */
-export declare const UseProvider: <T>(mark: ProviderMark<T>, fn: (value: T) => TNode) => Renderable;
-/**
- * Creates a renderable function that consumes providers and renders a TNode.
- *
- * @param marks - The marks to be converted to an array of marks.
- * @param fn - The function that takes providers and returns a TNode.
- * @returns A renderable function that consumes providers and renders a TNode.
- * @public
- */
-export declare const UseProviders: <T extends unknown[]>(marks: ToArrayOfMarks<T>, fn: (providers: ToProviders<T>) => TNode) => Renderable;

package/renderable/providers.d.ts

@@ -1,48 +0,0 @@
-import { TNode, Renderable, ProviderMark } from '../types/domain';
-/**
- * Represents a provider function that takes a `TNode` and returns a `Renderable`.
- * @param node - The node to be rendered.
- * @returns The rendered output.
- * @public
- */
-export type Provider = (node: TNode) => Renderable;
-/**
- * Creates a unique symbol that can be used as a provider mark for a specific type `T`.
- * The provider mark is used to identify the provider of a value of type `T` in a dependency injection system.
- *
- * @param identifier - A string that uniquely identifies the provider.
- * @returns A unique symbol that can be used as a provider mark.
- * @public
- */
-export declare const makeProviderMark: <T>(identifier: string) => ProviderMark<T>;
-/**
- * Higher-order function that composes multiple provider functions into a single provider function.
- *
- * @param providerFns - The provider functions to be composed.
- * @returns A new provider function that applies the composed providers in reverse order.
- * @public
- */
-export declare const Provide: <T extends Provider[]>(...providerFns: T) => Provider;
-/**
- * Creates a renderable with a provider mark and value.
- *
- * The value will be available to any consumers that request the provider mark.
- *
- * @typeParam T - The type of the provider value.
- * @param mark - The provider mark.
- * @param value - The provider value.
- * @param child - The child TNode.
- * @returns - The renderable with the provider.
- * @public
- */
-export declare const WithProvider: <T>(mark: ProviderMark<T>, value: T, child: TNode) => Renderable;
-/**
- * Renders the given child with the specified providers.
- *
- * @typeParam T - The types of the provider values.
- * @param providers - An object containing the providers.
- * @param child - The child to render.
- * @returns The rendered result.
- * @public
- */
-export declare const WithProviders: <T extends unknown[]>(providers: { [K in ProviderMark<T[number]>]: T[number]; }, child: TNode) => Renderable;