@tempots/dom 35.0.4 → 36.0.0

package/renderable/provider.d.ts

@@ -1,235 +1,14 @@
 import { DOMContext } from '../dom/dom-context';
-import { ProviderMark, Renderable, TNode } from '../types/domain';
+import { Provider as BaseProvider, ProviderOptions as BaseProviderOptions } from '@tempots/render';
+export { WithProvider, Provide, Use, UseMany } from './shared';
 /**
- * Converts an array of `Provider` types `T` into an array of their corresponding types.
+ * Represents a provider for a specific type `T`, specialized for DOMContext.
  * @public
  */
-export type ToProviderTypes<T extends unknown[]> = T extends [] ? [] : T extends [Provider<infer K>] ? [K] : T extends [Provider<infer K>, ...infer R] ? [K, ...ToProviderTypes<R>] : never;
+export type Provider<T, O = any> = BaseProvider<T, O, DOMContext>;
 /**
- * Represents a provider for a specific type `T`.
+ * Represents an object with provider options, specialized for DOMContext.
  * @public
  */
-export type Provider<T, O = any> = {
-    /** The provider mark. */
-    mark: ProviderMark<T>;
-    /** The function to create the provider. */
-    create: (options: O | undefined, ctx: DOMContext) => {
-        value: T;
-        dispose: () => void;
-        onUse?: () => void;
-    };
-};
-/**
- * Represents an object with provider options.
- * @public
- */
-export type ProviderOptions = {
-    /** The function to use a provider. */
-    use: <T, O = any>(provider: Provider<T, O>) => T;
-    /** The function to set a provider. */
-    set: <T, O = any>(provider: Provider<T, O>, options?: O) => void;
-};
-/**
- * Returns a renderable object 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: (opts: ProviderOptions) => TNode | void) => Renderable;
-/**
- * Makes a provider available to all child components in the component tree.
- *
- * This function creates a provider context that child components can access using `Use`.
- * The provider is automatically disposed when the component is unmounted.
- *
- * @example
- * ```typescript
- * // Create a theme provider
- * const ThemeProvider: Provider<Signal<string>> = {
- *   mark: makeProviderMark<Signal<string>>('Theme'),
- *   create: () => {
- *     const theme = prop('light')
- *     return {
- *       value: theme,
- *       dispose: () => theme.dispose()
- *     }
- *   }
- * }
- *
- * // Provide the theme to child components
- * const App = () =>
- *   Provide(
- *     ThemeProvider,
- *     {}, // options
- *     () => html.div(
- *       html.h1('My App'),
- *       ThemeToggle(), // Can access the theme
- *       MainContent()  // Can also access the theme
- *     )
- *   )
- * ```
- *
- * @example
- * ```typescript
- * // Provider with options
- * const ConfigProvider: Provider<Config, { apiUrl: string }> = {
- *   mark: makeProviderMark<Config>('Config'),
- *   create: (options) => {
- *     const config = new Config(options.apiUrl)
- *     return {
- *       value: config,
- *       dispose: () => config.cleanup()
- *     }
- *   }
- * }
- *
- * // Provide with specific options
- * Provide(
- *   ConfigProvider,
- *   { apiUrl: 'https://api.example.com' },
- *   () => AppContent()
- * )
- * ```
- *
- * @typeParam T - The type of value provided by the provider
- * @typeParam O - The type of options passed to the provider
- * @param provider - The provider definition containing mark and create function
- * @param options - Options to pass to the provider's create function
- * @param child - Function that returns the child components that can access the provider
- * @returns A renderable that provides the value to its children
- * @public
- */
-export declare const Provide: <T, O>(provider: Provider<T, O>, options: O, child: () => TNode) => Renderable;
-/**
- * Consumes a provider value and makes it available to a child component.
- *
- * This function looks up a provider in the component tree and passes its value
- * to the child function. The provider must have been made available by a parent
- * component using `Provide`.
- *
- * @example
- * ```typescript
- * // Use a theme provider
- * const ThemeToggle = () =>
- *   Use(
- *     ThemeProvider,
- *     (theme) => html.button(
- *       on.click(() => {
- *         theme.value = theme.value === 'light' ? 'dark' : 'light'
- *       }),
- *       'Current theme: ', theme
- *     )
- *   )
- * ```
- *
- * @example
- * ```typescript
- * // Use multiple properties from a provider
- * const UserProfile = () =>
- *   Use(
- *     UserProvider,
- *     (user) => html.div(
- *       html.h2('Welcome, ', user.map(u => u.name)),
- *       html.p('Email: ', user.map(u => u.email)),
- *       html.p('Role: ', user.map(u => u.role))
- *     )
- *   )
- * ```
- *
- * @example
- * ```typescript
- * // Use provider in conditional rendering
- * const ConditionalContent = () =>
- *   Use(
- *     AuthProvider,
- *     (auth) => auth.map(a => a.isLoggedIn)
- *       ? html.div('Welcome back!')
- *       : html.div('Please log in')
- *   )
- * ```
- *
- * @typeParam T - The type of value provided by the provider
- * @param provider - The provider to consume (must be available in parent components)
- * @param child - Function that receives the provider value and returns content to render
- * @returns A renderable that consumes the provider and renders the child content
- * @throws {ProviderNotFoundError} When the provider is not found in the component tree
- * @public
- */
-export declare const Use: <T>(provider: Provider<T>, child: (provider: T) => TNode) => Renderable;
-/**
- * Consumes multiple providers and makes their values available to a child component.
- *
- * This function is a convenience wrapper for consuming multiple providers at once.
- * It's equivalent to nesting multiple `Use` calls but provides a cleaner API when
- * you need access to several providers simultaneously.
- *
- * @example
- * ```typescript
- * // Use multiple providers together
- * const Dashboard = () =>
- *   UseMany(
- *     UserProvider,
- *     ThemeProvider,
- *     ConfigProvider
- *   )(
- *     (user, theme, config) => html.div(
- *       attr.class(theme.map(t => `theme-${t}`)),
- *       html.h1('Dashboard for ', user.map(u => u.name)),
- *       html.p('API URL: ', config.map(c => c.apiUrl)),
- *       html.p('Current theme: ', theme)
- *     )
- *   )
- * ```
- *
- * @example
- * ```typescript
- * // Equivalent to nested Use calls
- * const Dashboard = () =>
- *   Use(UserProvider, user =>
- *     Use(ThemeProvider, theme =>
- *       Use(ConfigProvider, config =>
- *         html.div(
- *           // Same content as above
- *         )
- *       )
- *     )
- *   )
- * ```
- *
- * @example
- * ```typescript
- * // Type-safe access to multiple providers
- * const SettingsPanel = () =>
- *   UseMany(
- *     PreferencesProvider,
- *     UserProvider
- *   )(
- *     (preferences, user) => html.div(
- *       html.h2('Settings for ', user.map(u => u.name)),
- *       html.label(
- *         'Theme: ',
- *         html.select(
- *           attr.value(preferences.map(p => p.theme)),
- *           on.change(emitValue(value => {
- *             preferences.update(p => ({ ...p, theme: value }))
- *           })),
- *           html.option(attr.value('light'), 'Light'),
- *           html.option(attr.value('dark'), 'Dark')
- *         )
- *       )
- *     )
- *   )
- * ```
- *
- * @typeParam T - Tuple type representing the types of all providers
- * @param providers - Variable number of providers to consume
- * @returns Function that takes a child function and returns a renderable
- * @throws {ProviderNotFoundError} When any of the providers is not found in the component tree
- * @public
- */
-export declare const UseMany: <T extends Provider<unknown>[]>(...providers: T) => (child: (...values: ToProviderTypes<T>) => TNode) => Renderable;
+export type ProviderOptions = BaseProviderOptions<DOMContext>;
+export type { ToProviderTypes } from '@tempots/render';

package/renderable/repeat.d.ts

@@ -1,70 +1 @@
-import { ElementPosition, Value } from '@tempots/core';
-import { TNode, Renderable } from '../types/domain';
-/**
- * Renders content a specified number of times, with each iteration receiving position information.
- *
- * This function is useful for generating repeated UI elements based on a count rather than an array.
- * Each iteration receives an `ElementPosition` object that provides the current index and position
- * information relative to the total count.
- *
- * @example
- * ```typescript
- * // Create a simple numbered list
- * const count = prop(5)
- *
- * Repeat(count,
- *   (position) => html.div(
- *     `Item ${position.index + 1} of ${position.total.value}`,
- *     position.isFirst ? ' (first)' : '',
- *     position.isLast ? ' (last)' : ''
- *   )
- * )
- * ```
- *
- * @example
- * ```typescript
- * // Create a star rating component
- * const rating = prop(3)
- * const maxStars = 5
- *
- * Repeat(maxStars,
- *   (position) => html.span(
- *     attr.class(position.index < rating.value ? 'star-filled' : 'star-empty'),
- *     '★'
- *   )
- * )
- * ```
- *
- * @example
- * ```typescript
- * // With separators between items
- * Repeat(3,
- *   (position) => html.span(`Item ${position.index}`),
- *   () => html.span(' | ') // Separator
- * )
- * // Renders: Item 0 | Item 1 | Item 2
- * ```
- *
- * @example
- * ```typescript
- * // Dynamic count that updates the UI
- * const itemCount = prop(2)
- *
- * html.div(
- *   html.button(
- *     on.click(() => itemCount.value++),
- *     'Add Item'
- *   ),
- *   Repeat(itemCount,
- *     (position) => html.div(`Dynamic item ${position.index + 1}`)
- *   )
- * )
- * ```
- *
- * @param times - A signal or number representing how many times to repeat the content
- * @param element - Function that returns content for each iteration, receives position information
- * @param separator - Optional function that returns content to place between iterations
- * @returns A renderable that displays the repeated content
- * @public
- */
-export declare const Repeat: (times: Value<number>, element: (index: ElementPosition) => TNode, separator?: (pos: ElementPosition) => TNode) => Renderable;
+export { Repeat } from './shared';

package/renderable/shared.d.ts

@@ -0,0 +1,8 @@
+import { DOMContext } from '../dom/dom-context';
+import { DOM_RENDERABLE_TYPE } from '../types/domain';
+export declare const domKit: import('@tempots/render').RenderKit<DOMContext, typeof DOM_RENDERABLE_TYPE>;
+export declare const Empty: import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, Fragment: (...children: import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>[]) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, When: (condition: import('@tempots/core').Value<boolean>, then: () => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>, otherwise?: (() => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) | undefined) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, Unless: (condition: import('@tempots/core').Value<boolean>, then: () => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>, otherwise?: (() => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) | undefined) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, ForEach: <T>(value: import('@tempots/core').Value<T[]>, item: (value: import('@tempots/core').Signal<T>, position: import('@tempots/core').ElementPosition) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>, separator?: ((pos: import('@tempots/core').ElementPosition) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) | undefined) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, Repeat: (times: import('@tempots/core').Value<number>, element: (index: import('@tempots/core').ElementPosition) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>, separator?: ((pos: import('@tempots/core').ElementPosition) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) | undefined) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, OneOf: <T extends Record<string, unknown>>(match: import('@tempots/core').Value<T>, cases: import('@tempots/render').OneOfOptions<T, DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, OneOfField: <T extends { [_ in K]: string; }, K extends string>(match: import('@tempots/core').Value<T>, field: K, cases: import('@tempots/render').OneOfFieldOptions<T, K, DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, OneOfKind: <T extends {
+    kind: string;
+}>(match: import('@tempots/core').Value<T>, cases: import('@tempots/render').OneOfKindOptions<T, DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, OneOfType: <T extends {
+    type: string;
+}>(match: import('@tempots/core').Value<T>, cases: import('@tempots/render').OneOfTypeOptions<T, DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, OneOfValue: <T extends symbol | number | string>(match: import('@tempots/core').Value<T>, cases: import('@tempots/render').OneOfValueOptions<T, DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, OneOfTuple: <T extends string, V>(match: import('@tempots/core').Value<[T, V]>, cases: import('@tempots/render').OneOfTupleOptions<T, V, DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, MapSignal: <T>(value: import('@tempots/core').Value<T>, fn: (value: T) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, Ensure: <T>(value: import('@tempots/render').NillifyValue<T>, then: (value: import('@tempots/core').Signal<T & {} extends infer T_1 ? { [P in keyof T_1]: T_1[P]; } : never>) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>, otherwise?: (() => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) | undefined) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, EnsureAll: <T extends readonly import('@tempots/core').Value<unknown>[]>(...signals: { [K in keyof T]: import('@tempots/render').NillifyValue<T[K]>; }) => (callback: (...values: { [K_1 in keyof T]: import('@tempots/core').Signal<(T[K_1] extends import('@tempots/core').Value<infer U> ? U : never) & {} extends infer T_1 ? { [P in keyof T_1]: T_1[P]; } : never>; }) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>, otherwise?: (() => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) | undefined) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, NotEmpty: <T>(value: import('@tempots/core').Value<T[]>, display: (value: import('@tempots/core').Signal<T[]>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, whenEmpty?: (() => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>) | undefined) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, Task: <T>(task: () => Promise<T>, options: import('@tempots/render').TaskOptions<T, DOMContext, typeof DOM_RENDERABLE_TYPE> | ((value: T) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>)) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, Async: <T>(promise: Promise<T>, options: import('@tempots/render').AsyncOptions<T, DOMContext, typeof DOM_RENDERABLE_TYPE> | ((value: T) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>)) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, OnDispose: (...fns: (import('@tempots/render').DisposeCallback<DOMContext> | import('@tempots/render').WithDispose<DOMContext>)[]) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, Conjunction: (separator: () => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>, options?: import('@tempots/render').ConjunctionOptions<DOMContext, typeof DOM_RENDERABLE_TYPE> | undefined) => (pos: import('@tempots/core').Signal<import('@tempots/core').ElementPosition>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, WithScope: (fn: (scope: import('@tempots/core').DisposalScope) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, WithProvider: (fn: (opts: import('@tempots/render').ProviderOptions<DOMContext>) => void | import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, Provide: <T, O>(provider: import('@tempots/render').Provider<T, O, DOMContext>, options: O, child: () => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, Use: <T>(provider: import('@tempots/render').Provider<T, unknown, DOMContext>, child: (provider: T) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, UseMany: <P extends import('@tempots/render').Provider<unknown, unknown, DOMContext>[]>(...providers: P) => (child: (...values: import('@tempots/render').ToProviderTypes<P>) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>, handleValueOrSignal: <T, R>(value: import('@tempots/core').Value<T>, onSignal: (signal: import('@tempots/core').Signal<T>) => R, onStatic: (literal: T) => R) => R, createReactiveRenderable: <T>(ctx: DOMContext, signal: import('@tempots/core').Signal<T>, render: (value: T) => import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Clear, renderableOfTNode: (child: import('@tempots/core').TNode<DOMContext, typeof DOM_RENDERABLE_TYPE>) => import('@tempots/core').Renderable<DOMContext, typeof DOM_RENDERABLE_TYPE>;

package/renderable/task.d.ts

@@ -1,22 +1,2 @@
-import { TNode, Renderable } from '../types/domain';
-/**
- * Represents the options for a task.
- *
- * @typeParam T - The type of the task value.
- * @public
- */
-export type TaskOptions<T> = {
-    pending?: () => TNode;
-    then: (value: T) => TNode;
-    error?: (error: unknown) => TNode;
-};
-/**
- * Represents a renderable task that can be executed asynchronously.
- *
- * @typeParam T - The type of the value returned by the task.
- * @param task - The asynchronous task to be executed.
- * @param options - The options for the task or a function that transforms the task result into a renderable node.
- * @returns - A renderable object that renders the task and returns a cleanup function.
- * @public
- */
-export declare const Task: <T>(task: () => Promise<T>, options: TaskOptions<T> | ((value: T) => TNode)) => Renderable;
+export { Task } from './shared';
+export type { TaskOptions } from '@tempots/render';

package/renderable/utils.d.ts

@@ -1,30 +1 @@
-import { Clear, TNode } from '../types/domain';
-import { DOMContext } from '../dom/dom-context';
-import { Signal, Value } from '@tempots/core';
-/**
- * Helper function to handle a value that could be either a Signal or a static value.
- * Delegates to the appropriate handler based on whether the value is a Signal.
- *
- * @param value - The value to check (could be Signal<T> or T)
- * @param onSignal - Handler function to call if value is a Signal
- * @param onStatic - Handler function to call if value is static
- * @returns The result from the appropriate handler
- * @internal
- */
-export declare const handleValueOrSignal: <T, R>(value: Value<T>, onSignal: (signal: Signal<T>) => R, onStatic: (literal: T) => R) => R;
-/**
- * Creates a reactive renderable that updates when a signal changes.
- * This helper consolidates the common pattern of:
- * - Creating a new context reference
- * - Setting up a signal listener that re-renders on changes
- * - Properly cleaning up the old render before creating a new one
- * - Disposing the signal listener and context on cleanup
- * - Creating a disposal scope for each branch to track signals
- *
- * @param ctx - The parent DOM context
- * @param signal - The signal to watch for changes
- * @param render - Function that takes the signal value and returns content to render
- * @returns A Clear function that cleans up the reactive renderable
- * @internal
- */
-export declare const createReactiveRenderable: <T>(ctx: DOMContext, signal: Signal<T>, render: (value: T) => TNode) => Clear;
+export { handleValueOrSignal, createReactiveRenderable } from './shared';

package/renderable/when.d.ts

@@ -1,20 +1 @@
-import { Renderable, TNode } from '../types/domain';
-import { Value } from '@tempots/core';
-/**
- * Lazily renders content based on a boolean condition.
- * @param condition - The condition to evaluate
- * @param then - Function returning content to render if condition is true
- * @param otherwise - Optional function returning content to render if condition is false
- * @returns Renderable content
- * @public
- */
-export declare const When: (condition: Value<boolean>, then: () => TNode, otherwise?: () => TNode) => Renderable;
-/**
- * Lazily renders content when a condition is false.
- * @param condition - The condition to evaluate
- * @param then - Function returning content to render if condition is false
- * @param otherwise - Optional function returning content to render if condition is true
- * @returns Renderable content
- * @public
- */
-export declare const Unless: (condition: Value<boolean>, then: () => TNode, otherwise?: () => TNode) => Renderable;
+export { When, Unless } from './shared';

package/renderable/with-scope.d.ts

@@ -1,39 +1 @@
-import { DisposalScope } from '@tempots/core';
-import { Renderable, TNode } from '../types/domain';
-/**
- * Creates a renderable that provides explicit access to a DisposalScope.
- *
- * This is useful when you need to create signals in async contexts (like setTimeout,
- * fetch callbacks, event handlers) where automatic scope tracking doesn't work.
- *
- * @example
- * ```typescript
- * // Using scope in async context
- * WithScope(scope => {
- *   setTimeout(() => {
- *     const signal = scope.prop(42)
- *     // signal will be disposed when component unmounts
- *   }, 1000)
- *
- *   return html.div('Loading...')
- * })
- * ```
- *
- * @example
- * ```typescript
- * // Using scope with fetch
- * WithScope(scope => {
- *   fetch('/api/data').then(response => {
- *     const data = scope.prop(response.data)
- *     // data will be disposed when component unmounts
- *   })
- *
- *   return html.div('Fetching...')
- * })
- * ```
- *
- * @param fn - Function that receives the scope and returns content to render
- * @returns A renderable that manages the scope lifecycle
- * @public
- */
-export declare const WithScope: (fn: (scope: DisposalScope) => TNode) => Renderable;
+export { WithScope } from './shared';

package/types/domain.d.ts

@@ -1,4 +1,3 @@
-import { ReadSignal } from '../../../tempots-core/dist/signal';
 import { DOMContext } from '../dom/dom-context';
 import { AnySignal, Computed, Prop, Signal, Value, ValueType, BaseValueType, ValueTypes, Values, RemoveSignals, Nil, Clear, ProviderMark, makeProviderMark, Renderable as CoreRenderable } from '@tempots/core';
 export type { Clear, ProviderMark, ValueType, BaseValueType, ValueTypes, Values, RemoveSignals, Nil, AnySignal, };
@@ -128,16 +127,8 @@ export declare const domRenderable: <CTX extends DOMContext = DOMContext>(render
  * @typeParam CTX - The type of DOMContext (defaults to DOMContext)
  * @public
  */
-export type TNode<CTX extends DOMContext = DOMContext> = Renderable<CTX> | string | ReadSignal<string> | undefined | null | Renderable<CTX>[];
-/**
- * Represents a collection of providers.
- * The keys of the record are ProviderMark types, and the values are of unknown type.
- * @public
- */
-export type Providers = Record<ProviderMark<unknown>, [
-    unknown,
-    undefined | (() => void)
-]>;
+export type TNode<CTX extends DOMContext = DOMContext> = Renderable<CTX> | string | Signal<string> | undefined | null | Renderable<CTX>[];
+export type { Providers } from '@tempots/render';
 /**
  * Represents the size of an object with width and height.
  * @public
@@ -157,7 +148,7 @@ export type Size = {
  * @typeParam T - The type of the value.
  * @public
  */
-export type NValue<T> = Value<NonNullable<T>> | ReadSignal<T> | ReadSignal<T | null> | ReadSignal<T | undefined> | ReadSignal<T | null | undefined> | null | undefined;
+export type NValue<T> = Value<NonNullable<T>> | Signal<T> | Signal<T | null> | Signal<T | undefined> | Signal<T | null | undefined> | null | undefined;
 type TupleToUnion<T extends unknown[]> = T[number];
 export type SplitNValue<T> = (T extends unknown ? TupleToUnion<NValue<T>[]> : never) | NValue<T>;
 export type SplitValue<T> = (T extends unknown ? TupleToUnion<Value<T>[]> : never) | Value<T>;