@calmdown/pyxis 1.0.0-rc.1

package/dist/core.d.ts

@@ -0,0 +1,737 @@
+//#region src/support/types.d.ts
+/**
+ * Puts `T` into a union with `null` and `undefined`.
+ */
+type Nil<T> = T | null | undefined;
+/**
+ * Converts the union `U` into an intersection type.
+ */
+type Intersection<U, TEmpty = {}> = [U] extends [never] ? TEmpty : (U extends any ? (u: U) => void : never) extends ((i: infer I) => void) ? I : never;
+/**
+ * A type describing any map of intrinsic elements and their props.
+ */
+type ElementsType = { readonly [_ in string]?: any; };
+/**
+ * A type describing any props of a Component.
+ */
+type PropsType = { readonly [_ in string]?: any; };
+/**
+ * A symbol to include in props typings containing the original Node type.
+ * @deprecated **Type only, does not exist at runtime!**
+ */
+declare const S_NODE_TYPE: unique symbol;
+/**
+ * Infers the specific Node type from its props typings.
+ */
+type NodeType<P> = P extends {
+  readonly [S_NODE_TYPE]?: infer N;
+} ? N : unknown;
+/**
+ * A tuple of up to 2 arguments.
+ */
+type ArgsMax2<A0 = any, A1 = any> = [a0?: A0, a1?: A1];
+/**
+ * Describes a callback with up to two stored arguments.
+ */
+interface Callback<TArgs extends ArgsMax2 = ArgsMax2, TReturn = void> {}
+//#endregion
+//#region src/data/Dependency.d.ts
+/**
+ * A dependency callback of an Atom. The callback will be run whenever the relevant Atom changes.
+ */
+interface Dependency<TArgs extends ArgsMax2 = ArgsMax2> extends Callback<TArgs> {}
+interface DependencyList<TArgs extends ArgsMax2 = ArgsMax2> {}
+declare function bind(lifecycle: Lifecycle, target: DependencyList, block: () => void): void;
+//#endregion
+//#region src/data/Lifecycle.d.ts
+interface Lifecycle extends DependencyList {
+  /** whether this Lifecycle is currently mounted or not */
+  mounted: boolean;
+}
+interface MountBlock {
+  (): (() => void) | void;
+}
+interface UnmountBlock {
+  (): void;
+}
+/**
+ * Registers a callback to run just after the current Component has mounted.
+ *
+ * If a teardown callback is returned, it will be run just before the Component unmounts (equivalent
+ * to adding a separate `unmounted` block).
+ * @see {@link unmounted}
+ */
+declare function mounted(block: MountBlock, lifecycle?: Lifecycle): void;
+/**
+ * Registers a callback to run once the current Component is just about to unmount.
+ * @see {@link mounted}
+ */
+declare function unmounted(block: UnmountBlock, lifecycle?: Lifecycle): void;
+/**
+ * Gets the Lifecycle of the calling component.
+ */
+declare function getLifecycle(): Lifecycle;
+/**
+ * Runs a block of code with the provided Lifecycle. Calls to `getLifecycle` within the block will
+ * return the specified object.
+ * @see {@link getLifecycle}
+ */
+declare function withLifecycle<TArgs extends [arg?: any], TReturn>(lifecycle: Lifecycle, block: (...args: TArgs) => TReturn, ...args: TArgs): TReturn;
+//#endregion
+//#region src/data/Atom.d.ts
+/**
+ * Pyxis Atom type guard marker.
+ */
+declare const S_ATOM: unique symbol;
+/** Contract for Atoms where they need to be read. */
+interface ReadonlyAtom<out T> extends DependencyList {
+  /** Pyxis Atom type guard marker. */
+  readonly [S_ATOM]: true;
+  /**
+   * Gets the value of this Atom. Only use this method when the target is guaranteed to be an
+   * Atom, otherwise it is recommended to use the `read` or `peek` functions.
+   *
+   * This method does *not* report access, thus within effects it is analogous to `peek`.
+   * @see {@link read}
+   * @see {@link peek}
+   */
+  get: () => T;
+}
+/**
+ * Holds any single value, managing reactions to its changes. Use the `read`, `write` functions to
+ * access its value.
+ * @see {@link read}
+ * @see {@link write}
+ */
+interface Atom<T = unknown> extends ReadonlyAtom<T> {
+  /**
+   * Sets the value of this Atom. Does nothing if this Atom is readonly. Only use this method when
+   * the target is guaranteed to be an Atom, otherwise it is recommended to use the `write` or
+   * `update` functions.
+   *
+   * This method does *not* send out any change notifications to observers!
+   * @returns Boolean indicating whether the value of this Atom changed.
+   * @see {@link write}
+   * @see {@link update}
+   */
+  set: (value: T) => boolean;
+}
+/**
+ * Union of the given type or an Atom of that type. Use the `read`, `peek`, `write`, `update` or
+ * `isAtom` functions to interact with such values.
+ * @see {@link read}
+ * @see {@link peek}
+ * @see {@link write}
+ * @see {@link update}
+ * @see {@link isAtom}
+ */
+type MaybeAtom<T> = Atom<T> | T;
+/**
+ * Union of the given type or the ReadAtom contract of that type. Use the `read`, `peek` or `isAtom`
+ * functions to interact with such values.
+ * @see {@link read}
+ * @see {@link peek}
+ * @see {@link isAtom}
+ */
+type MaybeReadonlyAtom<T> = ReadonlyAtom<T> | T;
+/**
+ * Creates an empty Atom; i.e. value set to `undefined`.
+ */
+declare function atomOf<T>(): Atom<T | undefined>;
+/**
+ * Creates an Atom initialized to the provided value. If the provided value is already an Atom, it
+ * is returned as-is.
+ * @see {@link isAtom}
+ */
+declare function atomOf<T>(initialValue: MaybeAtom<T>, lifecycle?: Lifecycle, devId?: string): Atom<T>;
+/**
+ * Atom type guard, checks if the provided input is an Atom.
+ */
+declare function isAtom<T = unknown>(input: Nil<MaybeAtom<T>>): input is Atom<T>;
+declare function isAtom<T = unknown>(input: Nil<MaybeReadonlyAtom<T>>): input is ReadonlyAtom<T>;
+declare function isAtom<T = unknown>(input: unknown): input is Atom<T>;
+/**
+ * Checks if the provided input is an Atom and reads its value. Non-atom inputs are returned as-is.
+ * Reports read access when inside an effect.
+ * @see {@link isAtom}
+ * @see {@link write}
+ * @see {@link peek}
+ * @see {@link update}
+ */
+declare function read<A>(input: A): A extends MaybeReadonlyAtom<infer T> ? T : never;
+/**
+ * Checks if the provided input is an Atom and reads its value. Non-atom inputs are returned as-is.
+ * Does NOT report read access when inside an effect.
+ * @see {@link isAtom}
+ * @see {@link read}
+ * @see {@link write}
+ * @see {@link update}
+ */
+declare function peek<A>(input: A): A extends MaybeReadonlyAtom<infer T> ? T : never;
+/**
+ * Checks if the provided input is an Atom, writes its value and returns the new value.
+ *
+ * Non-atom inputs are never modified in any way. Instead the provided new value is discarded and
+ * the input is returned as-is.
+ * @see {@link isAtom}
+ * @see {@link read}
+ * @see {@link write}
+ * @see {@link update}
+ */
+declare function write<A>(input: A, value: A extends Atom<infer T> ? T : never, force?: boolean): A extends MaybeAtom<infer T> ? T : never;
+/**
+ * Checks if the provided input is an Atom, updates its value using the provided transform function
+ * and returns the new value.
+ *
+ * Non-atom inputs are never modified in any way and the input is returned as-is.
+ * @see {@link isAtom}
+ * @see {@link read}
+ * @see {@link peek}
+ * @see {@link write}
+ */
+declare function update<A>(input: A, transform: A extends Atom<infer T> ? (value: T) => T : never, force?: boolean): A extends MaybeAtom<infer T> ? T : never;
+//#endregion
+//#region src/Component.d.ts
+/**
+ * Represents a Pyxis Component function responsible for setting up a view model and returning a
+ * chunk of JSX to be rendered.
+ */
+interface Component<TProps extends PropsType = {}> {
+  (props: TProps): JsxResult;
+}
+type PropsOf<T> = T extends Component<infer TProps> ? TProps : unknown;
+/**
+ * Represents a template function returning a chunk of JSX to be rendered with specific input data.
+ */
+interface DataTemplate<TData> {
+  (data: TData): JsxResult;
+}
+declare function component<TPropsArg extends [{}]>(block: (...args: TPropsArg) => JsxResult, devId?: string): (...args: [props: JsxProps<TPropsArg[0]>]) => JsxResult;
+/**
+ * Infers the props object for use with JSX. Because Pyxis always supplies components with child
+ * arrays (or tuples), the type needs to be adjusted to reflect the internal mechanics.
+ */
+type JsxProps<T> = { readonly [K in keyof T]: K extends "children" ? JsxChildrenProp<T[K]> : T[K]; } & ("children" extends keyof T ? {} : {
+  readonly children?: [];
+});
+/**
+ * When typing children as a single value tuple, it becomes unusable in 'react-jsx' mode. TS rejects
+ * valid uses of such components with the error: "This JSX tag's children prop expects type '[T]'
+ * which requires multiple children, but only a single child was provided."
+ *
+ * Likely related to the fact that single children are passed to jsx() factory without wrapping
+ * arrays.
+ *
+ * This utility type unwraps single value tuples, avoiding the problem.
+ */
+type JsxChildrenProp<T> = T extends readonly [any, any, ...any[]] ? T extends readonly [...infer C] ? readonly [...C] : T : T extends readonly [infer SC] ? SC : T extends readonly (infer C)[] ? readonly C[] | C : T;
+/**
+ * Primitive types accepted to render as text.
+ */
+type JsxText = MaybeReadonlyAtom<Nil<string | number | boolean | bigint>>;
+/**
+ * Describes the objects returned by JSX factories.
+ *
+ * Pyxis uses very lightweight factories returning the props object directly,
+ * adding a few extra props:
+ *
+ * - S_COMPONENT ... hidden, contains a reference to the ComponentHandler function
+ * - S_TAG_NAME ... hidden, specifies the tag name, only populated for native elements
+ * - children ... always present and always an array, empty array for childless components
+ */
+interface JsxObject {
+  [propName: string]: unknown;
+  readonly children: readonly unknown[];
+}
+/**
+ * Union of all admissible values within JSX.
+ */
+type JsxResult = JsxObject | JsxText;
+/**
+ * The type of JSX elements accepted as individual children by common components.
+ */
+type JsxChildren = JsxResult | readonly JsxChildren[];
+/**
+ * Utility type adding the standard `children` prop to the given props type.
+ */
+type WithChildren<T extends PropsType> = T & {
+  children?: JsxChildren;
+};
+//#endregion
+//#region src/component/Fragment.d.ts
+interface FragmentProps {
+  children?: Nil<JsxResult>[];
+}
+/**
+ * The built-in Fragment Component wrapping multiple Components.
+ */
+declare function Fragment(props: JsxProps<FragmentProps>): JsxResult;
+//#endregion
+//#region src/data/ListDelta.d.ts
+declare enum ChangeKind {
+  Change = 1,
+  Insert = 2,
+  Remove = 3,
+  Clear = 4
+}
+interface ListDelta<T> {
+  readonly changes: ListChange<T>[];
+  lengthChange: number;
+}
+type ListChange<T> = ListItemChanged<T> | ListItemInserted<T> | ListItemRemoved<T> | ListCleared;
+interface ListItemChanged<T> {
+  kind: ChangeKind.Change;
+  index: number;
+  oldItem: T;
+  newItem: T;
+}
+interface ListItemInserted<T> {
+  kind: ChangeKind.Insert;
+  index: number;
+  newItem: T;
+}
+interface ListItemRemoved<T> {
+  kind: ChangeKind.Remove;
+  index: number;
+  oldItem: T;
+}
+interface ListCleared {
+  kind: ChangeKind.Clear;
+  index: number;
+}
+interface Equals<T> {
+  (item0: T, item1: T): boolean;
+}
+//#endregion
+//#region src/data/List.d.ts
+interface ReadonlyList<T> extends Iterable<T>, DependencyList {
+  /**
+   * Gets the size of this List.
+   * Reactive in effects and derivations.
+   */
+  size(): number;
+  /**
+   * Gets the item at the specified index. Return undefined when outside of the List's bounds.
+   * Reactive in effects and derivations.
+   */
+  get(index: number): T | undefined;
+  /**
+   * Gets a set of changes made to this List within the current tick. Returns null when no changes
+   * were made.
+   * Reactive in effects and derivations.
+   */
+  delta(): ListDelta<T> | null;
+  /**
+   * Gets the underlying array of items. The array is read-only, attempts to mutate this array
+   * will cause observers to go out of sync.
+   * Reactive in effects and derivations.
+   */
+  raw(): readonly T[];
+  /**
+   * Runs the provided callback for each item of this List.
+   * Reactive in effects and derivations.
+   */
+  forEach(callback: (item: T, index: number) => void, thisArg?: any): void;
+}
+interface List<T> extends ReadonlyList<T> {
+  /**
+   * Sets the item at the specified index to a new value.
+   * Observers are notified of this mutation.
+   * @throws RangeError when index is out of bounds.
+   */
+  set(index: number, item: T): void;
+  /**
+   * Removes all items from this List.
+   * Observers are notified of this mutation.
+   */
+  clear(): void;
+  /**
+   * Inserts a new item at the specified index.
+   * Observers are notified of this mutation.
+   * @throws RangeError when index is out of bounds.
+   */
+  insertAt(index: number, item: T): void;
+  /**
+   * Inserts a new item at the start of this List.
+   * Observers are notified of this mutation.
+   */
+  insertFirst(item: T): void;
+  /**
+   * Inserts a new item at the end of this List.
+   * Observers are notified of this mutation.
+   */
+  insertLast(item: T): void;
+  /**
+   * Attempts to find and remove the first matching item from this List.
+   * Observers are notified of this mutation.
+   * @returns true if an item was found and removed, false otherwise.
+   */
+  remove(item: T): boolean;
+  /**
+   * Removes the item at the specified index.
+   * Observers are notified of this mutation.
+   * @returns the removed item.
+   * @throws RangeError when index is out of bounds.
+   */
+  removeAt(index: number): T;
+  /**
+   * Attempts to remove the first item of this List.
+   * Observers are notified of this mutation.
+   * @returns the removed item, or undefined if the List is empty.
+   */
+  removeFirst(): T | undefined;
+  /**
+   * Attempts to remove the last item of this List.
+   * Observers are notified of this mutation.
+   * @returns the removed item, or undefined if the List is empty.
+   */
+  removeLast(): T | undefined;
+}
+/**
+ * Creates an empty List. This List emits deltas with each mutation which can be observed by
+ * Components to efficiently update the rendered state.
+ */
+declare function listOf<T>(): List<T>;
+declare function listOf<T>(source: Nil<never>, lifecycle?: Lifecycle, devId?: string): List<T>;
+/**
+ * Creates a List initialized with items copied from the provided Iterable. This List emits deltas
+ * with each mutation which can be observed by Components to efficiently update the rendered state.
+ */
+declare function listOf<T>(source: Iterable<T>, lifecycle?: Lifecycle, devId?: string): List<T>;
+/**
+ * Synchronizes the provided List with the given data source. After this operation, the list will
+ * contain an exact copy of the source.
+ *
+ * Note: This function is separated instead of being a List method since the underlying diff
+ * algorithm (Myers) is a relatively large chunk of code which would otherwise always get included
+ * into bundled builds. This way, tools like Terser can eliminate the extra code when unused.
+ */
+declare function sync<T>(list: List<T>, source: readonly T[], eq?: Equals<T>): void;
+//#endregion
+//#region src/data/ProxyAtom.d.ts
+interface ProxyAtom<T> extends Atom<T> {
+  /**
+   * Binds this ProxyAtom to a new value. If it is an Atom, the proxy will mirror it, otherwise it
+   * will be a read-only atom with a static value until rebound.
+   */
+  use(value: MaybeAtom<T>): void;
+}
+/**
+ * Creates a ProxyAtom bound to the provided initial value. If it is an Atom, the proxy will mirror
+ * it, otherwise it will be a read-only atom with a static value until rebound.
+ */
+declare function proxyOf<T>(initialValue: MaybeAtom<T>, lifecycle?: Lifecycle): ProxyAtom<T>;
+type Proxied<T, P extends readonly (keyof T)[]> = {
+  readonly proxied: T;
+} & { readonly [K in P[number]]: ProxyAtom<T[K] extends MaybeAtom<infer V> ? V : T[K]>; };
+//#endregion
+//#region src/component/Iterator.d.ts
+interface RemountIteratorProps<T> {
+  source: ReadonlyList<T>;
+  proxy?: never;
+  children: [template: DataTemplate<T>];
+}
+interface ProxyIteratorProps<T, P extends readonly (keyof T)[]> {
+  source: ReadonlyList<T>;
+  proxy: P;
+  children: [template: DataTemplate<Proxied<T, P>>];
+}
+/**
+ * The built-in Iterator Component efficiently rendering collections of items
+ * based on updates from a Pyxis `list`.
+ */
+declare function Iterator<T>(props: JsxProps<RemountIteratorProps<T>>): JsxResult;
+declare function Iterator<T, P extends readonly (keyof T)[]>(props: JsxProps<ProxyIteratorProps<T, P>>): JsxResult;
+//#endregion
+//#region src/data/Scheduler.d.ts
+/**
+ * A function able to schedule a callback to be executed at a later time, e.g. `queueMicrotask`.
+ * The function must guarantee that the callback will be eventually executed.
+ */
+interface TickFn {
+  (onTick: () => void): void;
+}
+/**
+ * Runs a block of code on the next tick of the scheduler, synchronized with other updates. If a
+ * tick is not currently pending, a new one is scheduled.
+ */
+declare function tick(block: () => void, lifecycle?: Lifecycle): void;
+/**
+ * Runs a block of code after the next tick of the scheduler, once all regular updates finished.
+ * If a tick is not currently pending, a new one is scheduled.
+ */
+declare function tock(block: () => void, lifecycle?: Lifecycle): void;
+//#endregion
+//#region src/Adapter.d.ts
+interface Adapter<TNode, TIntrinsicElements extends ElementsType = ElementsType> {
+  /**
+   * Carries information about the available intrinsic elements when using this Adapter.
+   * @deprecated **Type only, does not exist at runtime!**
+   */
+  readonly $elements?: TIntrinsicElements;
+  /**
+   * A function able to schedule a callback to be executed at a later time, e.g. `queueMicrotask`.
+   * The function must guarantee that the callback will be eventually executed.
+   */
+  readonly tick: TickFn;
+  /**
+   * Creates a native (intrinsic) element node by its name.
+   */
+  readonly element: (name: string) => TNode;
+  /**
+   * Creates or updates a text node. In both cases the node is returned.
+   */
+  readonly text: (value: string, node: TNode | null) => TNode;
+  /**
+   * Creates a marker node used to preserve a position within the node tree.
+   */
+  readonly marker: (comment?: string) => TNode;
+  /**
+   * Creates a batch to which nodes can be inserted "offline," without causing any updates. The
+   * batch is later inserted all at once using the `insert` function, causing only a single
+   * update.
+   *
+   * Adapters may omit this function when batching is not supported.
+   */
+  readonly batch?: () => TNode;
+  /**
+   * Inserts the given `node` as a child of the `parent`. If `before` is provided, the child will
+   * be inserted just before the referenced node, otherwise the child is inserted as the new last
+   * child.
+   */
+  readonly insert: (node: TNode, parent: TNode, before: TNode | null) => void;
+  /**
+   * Removes a node from the hierarchy.
+   */
+  readonly remove: (node: TNode) => void;
+  /**
+   * Sets a named property of the given node.
+   */
+  readonly set: (node: TNode, prop: string, value: any) => void;
+}
+interface Extension<TNode, TExtensionKey extends string = string, TIntrinsicElements extends ElementsType = ElementsType, TExtendedIntrinsicElements extends ElementsType = ElementsType> {
+  /**
+   * Infers prop types to decorate existing types with extensions.
+   * Type only, this call signature does not exist at runtime!
+   */
+  (extensionKey: TExtensionKey, intrinsicElements: TIntrinsicElements): TExtendedIntrinsicElements;
+  /**
+   * Sets a named extension property of the given node.
+   */
+  readonly set: (node: TNode, prop: string, value: any, group: MountingGroup<TNode>) => void;
+}
+type ExtensionsType<TNode> = { [_ in string]?: Extension<TNode>; };
+type ExtensionProps<TExtensionKey extends string, TProps extends PropsType> = Intersection<{ [TPropKey in keyof TProps]-?: TPropKey extends string ? { readonly [_ in `${TExtensionKey}:${TPropKey}`]?: TProps[TPropKey]; } : never; }[keyof TProps]>;
+//#endregion
+//#region src/Renderer.d.ts
+interface Renderer<TNode, TIntrinsicElements extends ElementsType = ElementsType> {
+  /**
+   * Carries information about the available intrinsic elements when using this Renderer.
+   * @deprecated **Type only, does not exist at runtime!**
+   */
+  readonly $elements?: TIntrinsicElements;
+  mount: (root: TNode, jsx: JsxResult) => void;
+  unmount: () => void;
+}
+type ElementsOf<TRenderer> = TRenderer extends {
+  readonly $elements?: infer TElements;
+} ? TElements : {};
+interface MountingGroup<TNode> extends Lifecycle, Hierarchy<TNode> {
+  readonly $isGroup: true;
+  readonly $isNative?: never;
+  /** the Adapter rendering this MountingGroup */
+  readonly adapter: Adapter<TNode>;
+}
+interface NativeNode<TNode> extends Hierarchy<TNode> {
+  readonly $isNative: true;
+  readonly $isGroup?: never;
+  readonly $nn: TNode;
+}
+interface Hierarchy<TNode> {}
+type HNode<TNode> = MountingGroup<TNode> | NativeNode<TNode>;
+/**
+ * Creates a sub-group within the provided MountingGroup. Needed whenever a subtree needs to mount
+ * or unmount dynamically.
+ */
+declare function fork<TNode>(hParent: HNode<TNode>, hBefore?: HNode<TNode> | null): MountingGroup<TNode>;
+/**
+ * Adds a HNode to the hierarchy.
+ */
+declare function track<TNode>(hNode: HNode<TNode>, hParent: HNode<TNode>, hBefore?: HNode<TNode> | null): void;
+/**
+ * Removes a HNode from the tracking hierarchy.
+ */
+declare function untrack<TNode>(hNode: HNode<TNode>): void;
+/**
+ * Mounts a MountingGroup to the specified location in the node tree. If the group is already
+ * mounted (i.e. its native nodes are already rendered somewhere), it is moved to the new location
+ * without re-mounting Pyxis components.
+ *
+ * Note that for successfully moving a group within the tree, you should first `untrack` the group,
+ * then re-`track` it to the new location and only then call `mount` to commit the move.
+ * @see {@link track}
+ * @see {@link untrack}
+ */
+declare function mount<TNode>(jsx: any, hGroup: MountingGroup<TNode>, nUsedParent: TNode, nRealParent: TNode, nBefore: TNode | null, isBatch: boolean): void;
+/**
+ * Unmounts the contents of a MountingGroup from the node tree. The group itself, though empty,
+ * remains usable and can be remounted later.
+ */
+declare function unmount<TNode>(group: MountingGroup<TNode>): void;
+/**
+ * Mounts components described by the JsxResult to the specified location in the node tree.
+ */
+declare function mountJsx<TNode>(jsx: any, hParent: HNode<TNode>, nUsedParent: TNode, nRealParent: TNode, nBefore: TNode | null, isBatch: boolean): void;
+/**
+ * Inserts a native node and adds it to the tracking hierarchy. Necessary to preserve render order.
+ * Should only be called by component handlers!
+ */
+declare function insert<TNode>(nNode: TNode, children: any, hParent: HNode<TNode>, nUsedParent: TNode, nBefore: TNode | null, isBatch: boolean): void;
+//#endregion
+//#region src/component/Native.d.ts
+declare function Native<TNode>(jsx: JsxObject, hParent: HNode<TNode>, nUsedParent: TNode, _nRealParent: TNode, nBefore: TNode | null, isBatch: boolean): void;
+//#endregion
+//#region src/component/Show.d.ts
+interface ShowProps {
+  when?: MaybeAtom<boolean>;
+  children: JsxChildren;
+}
+interface ShowDataProps<T> {
+  when?: MaybeAtom<boolean>;
+  proxy?: never;
+  data: MaybeAtom<T>;
+  children: [template: DataTemplate<T> | ReadonlyAtom<Nil<DataTemplate<T>>>];
+}
+interface ShowProxyDataProps<T, P extends readonly (keyof T)[]> {
+  when?: MaybeAtom<boolean>;
+  proxy: P;
+  data: MaybeAtom<T>;
+  children: [template: DataTemplate<Proxied<T, P>> | ReadonlyAtom<Nil<DataTemplate<Proxied<T, P>>>>];
+}
+/**
+ * The built-in Show Component dynamically mounting and unmounting a Template
+ * based on a reactive condition result.
+ */
+declare function Show(props: JsxProps<ShowProps>): JsxResult;
+declare function Show<T>(props: JsxProps<ShowDataProps<T>>): JsxResult;
+declare function Show<T, P extends readonly (keyof T)[]>(props: JsxProps<ShowProxyDataProps<T, P>>): JsxResult;
+//#endregion
+//#region src/data/Context.d.ts
+/**
+ * Describes a Context distributing data throughout the Component hierarchy.
+ * @see {@link createContext}
+ */
+interface Context<T> {
+  /**
+   * A fake property kept for TypeScript to properly type-check Context compatibility.
+   * @deprecated **Type only, does not exist at runtime!**
+   */
+  readonly $contract?: (value: T) => void;
+}
+/**
+ * Creates a typed Context that can be used to propagate observable data throughout entire component
+ * trees without "prop drilling."
+ * @see {@link context}
+ */
+declare function createContext<T>(devId?: string): Context<T>;
+interface ContextAtom<T> extends Atom<T> {
+  $dep?: Nil<Dependency>;
+  $ancestor?: Nil<Atom<T>>;
+  $value?: T;
+}
+/**
+ * Gets a consumer Atom for the given Context. This atom will be read-only.
+ * @see {@link host}
+ */
+declare function consumerOf<T>(context: Context<T>): Atom<T> | null;
+/**
+ * Marks the current component as a host for the given context. Returns a mutable ContextAtom;
+ * Values written to it will be propagated to any descendant component that consumes the context via
+ * `consumerOf(context)`.
+ * @see {@link consumerOf}
+ */
+declare function host<T>(context: Context<T>, defaultValue?: T, devId?: string): ContextAtom<T>;
+//#endregion
+//#region src/data/Effect.d.ts
+interface EffectBlock {
+  (): (() => void) | void;
+}
+interface Effect<T> {}
+/**
+ * Creates an Effect - a block of logic executed each time any of the Atoms accessed within it
+ * change. The block is first synchronously executed when the Effect is created.
+ *
+ * If a teardown callback is returned, it will be run before the next effect re-run, or on component
+ * unmount.
+ */
+declare function effect(block: EffectBlock, lifecycle?: Lifecycle): void;
+//#endregion
+//#region src/data/Derivation.d.ts
+/**
+ * Holds a value derived from values of other Atoms, managing reactions to their changes.
+ * Derivations are read-only. Use the `read` function to access its value.
+ * @see {@link read}
+ */
+interface Derivation<T = unknown> extends Atom<T>, Effect<T> {}
+/**
+ * Creates a Derivation - an Atom with its value computed from other Atoms. The block runs once
+ * eagerly to compute the initial value, then re-runs within scheduler ticks whenever its source
+ * Atoms change. Observers are only notified if the new value differs from the previous.
+ */
+declare function derived<T>(block: () => T, lifecycle?: Lifecycle): Derivation<T>;
+//#endregion
+//#region src/extension/RefExtension.d.ts
+interface RefExtensionType {
+  <TExtensionKey extends string, TElements extends ElementsType>(extensionKey: TExtensionKey, elements: TElements): { [TElementName in keyof TElements]: TElements[TElementName] & ExtensionProps<TExtensionKey, {
+    readonly atom?: Atom<NodeType<TElements[TElementName]> | null>;
+    readonly call?: RefFn<NodeType<TElements[TElementName]>>;
+  }>; };
+  set: (node: any, prop: string, value: any, group?: MountingGroup<any>) => void;
+}
+interface RefFn<TNode> {
+  (node: TNode | null): void;
+}
+/**
+ * Extension adding direct reference access to any element. Recommended prefix:
+ * `"ref"`
+ *
+ * References can be stored into atoms:
+ * ```tsx
+ * const wrapperRef = atomOf<HTMLDivElement>();
+ * <div ref:atom={wrapperRef} />
+ * ```
+ * or handled with a custom callback:
+ * ```tsx
+ * const onWrapperRef = (node: HTMLDivElement) => { ... };
+ * <div ref:call={onWrapperRef} />
+ * ```
+ */
+declare const RefExtension: RefExtensionType;
+//#endregion
+//#region src/support/text.d.ts
+/**
+ * A template literal tag that automatically wraps each substitution in a `read` call.
+ * @see {@link read}
+ */
+declare function reads(strings: TemplateStringsArray, ...values: JsxText[]): string;
+/**
+ * A template literal tag that automatically wraps each substitution in a `peek` call.
+ * @see {@link peek}
+ */
+declare function peeks(strings: TemplateStringsArray, ...values: JsxText[]): string;
+//#endregion
+//#region src/Builder.d.ts
+interface PyxisBuilder<TNode, TIntrinsicElements extends ElementsType> {
+  build: () => Renderer<TNode, TIntrinsicElements>;
+  extend: <TExtensionKey extends string, TExtendedIntrinsicElements extends ElementsType>(extensionKey: TExtensionKey, extension: (extensionKey: TExtensionKey, intrinsicElements: TIntrinsicElements) => TExtendedIntrinsicElements) => PyxisBuilder<TNode, TExtendedIntrinsicElements>;
+}
+declare function pyxis<TNode, TIntrinsicElements extends ElementsType>(adapter: Adapter<TNode, TIntrinsicElements>): PyxisBuilder<TNode, TIntrinsicElements>;
+//#endregion
+//#region src/jsx.d.ts
+declare function jsx(tagName: string, props: PropsType, key?: any): JsxResult;
+declare function jsx<TProps extends PropsType>(component: Component<TProps>, props: TProps, key?: any): JsxResult;
+declare function jsxs(tagName: string, props: PropsType, key?: any): JsxResult;
+declare function jsxs<TProps extends PropsType>(component: Component<TProps>, props: TProps, key?: any): JsxResult;
+//#endregion
+export { type Adapter, type Atom, ChangeKind, type Component, type Context, type DataTemplate, type Derivation, type EffectBlock, type ElementsOf, type ElementsType, type Equals, type Extension, type ExtensionProps, type ExtensionsType, Fragment, type FragmentProps, type HNode, type Intersection, Iterator, type JsxChildren, type JsxChildrenProp, type JsxObject, type JsxProps, type JsxResult, type JsxText, type Lifecycle, type List, type ListChange, type ListCleared, type ListDelta, type ListItemChanged, type ListItemInserted, type ListItemRemoved, type MaybeAtom, type MaybeReadonlyAtom, type MountBlock, type MountingGroup, Native, type Nil, type NodeType, type PropsOf, type PropsType, type Proxied, type ProxyAtom, type ProxyIteratorProps, type PyxisBuilder, type ReadonlyAtom, type ReadonlyList, RefExtension, type RefExtensionType, type RefFn, type RemountIteratorProps, type Renderer, type S_ATOM, type S_NODE_TYPE, Show, type ShowProps, type TickFn, type UnmountBlock, type WithChildren, atomOf, bind, component, consumerOf, createContext, derived, effect, fork, getLifecycle, host, insert, isAtom, jsx, jsxs, listOf, mount, mountJsx, mounted, peek, peeks, proxyOf, pyxis, read, reads, sync, tick, tock, track, unmount, unmounted, untrack, update, withLifecycle, write };
+//# sourceMappingURL=core.d.ts.map