@manyducks.co/dolla 2.0.0-alpha.53 → 2.0.0-alpha.55

package/README.md

@@ -73,22 +73,11 @@ function Counter(props, ctx) {
         $(() => $count() > 10),
         <span>That's a lot of clicks!</span>,
       )}
-
-      {/* ALT: Or slot a getter function into the DOM and have it conditionally render an element */}
-      {() => {
-        // DEV NOTE
-        // If we get Dynamic to track its rendered elements and diff them by keys
-        // then we may be able to do away with repeat and when and just do things like:
-        //    <ul>{() => items().map(item => <li>{item}</li>)}</ul>
-        if ($count() > 10) {
-          return <span>That's a lot of clicks!</span>;
-        }
-      }}
     </div>
   );
 }
 
-mount(document.body, Counter);
+mount(Counter, document.body);
 ```
 
 > TODO: Show small examples for routing and stores.

package/dist/core/context.d.ts

@@ -1,69 +1,95 @@
-import type { View } from "./nodes/view";
-import type { Source } from "./signals";
-import type { Store, StoreFunction } from "./store";
-export interface ElementContext {
-    /**
-     * The root Dolla instance this element belongs to.
-     */
-    /**
-     * Stores attached to this context.
-     */
-    stores: Map<StoreFunction<any, any>, Store<any, any>>;
-    /**
-     * The nearest view.
-     */
-    view?: View<any>;
-    /**
-     * A reference to the parent context.
-     */
-    parent?: ElementContext;
-    /**
-     * Whether to create DOM nodes in the SVG namespace. An `<svg>` element will set this to true and pass it down to children.
-     */
-    isSVG?: boolean;
-    /**
-     * The name of the nearest parent view.
-     */
+import { Logger, LoggerOptions } from "./logger";
+import { type EffectFn, type MaybeSignal, type UnsubscribeFn } from "./signals";
+/**
+ *
+ */
+export type Store<Options, Value> = (this: Context, options: Options, context: Context) => Value;
+type StoreMap = Map<Store<any, any>, any>;
+export declare const globalStores: StoreMap;
+type LifecycleListener = () => void;
+type ContextLifecycleListeners = {
+    willMount?: LifecycleListener[];
+    didMount?: LifecycleListener[];
+    willUnmount?: LifecycleListener[];
+    didUnmount?: LifecycleListener[];
+};
+declare enum LifecycleState {
+    Unmounted = 0,
+    WillMount = 1,
+    WillMountByDependent = 2,
+    DidMount = 3,
+    DidMountByDependent = 4,
+    WillUnmount = 5,
+    WillUnmountByDependent = 6,
+    DidUnmount = 7
+}
+/**
+ * Manages lifecycle events for a Context.
+ */
+declare class ContextLifecycle {
+    #private;
+    state: LifecycleState;
+    dependents: number;
+    on<E extends keyof ContextLifecycleListeners>(event: E, listener: LifecycleListener): void;
+    off<E extends keyof ContextLifecycleListeners>(event: E, listener: LifecycleListener): void;
+    willMount(dependent?: boolean): void;
+    didMount(dependent?: boolean): void;
+    willUnmount(dependent?: boolean): void;
+    didUnmount(dependent?: boolean): void;
+    dispose(): void;
+}
+export interface ContextOptions {
+    logger?: LoggerOptions;
+}
+export interface InheritedContextOptions extends ContextOptions {
+    bindLifecycleToParent?: boolean;
+}
+export interface Context extends Logger {
+}
+export declare class Context implements Logger {
+    #private;
+    _name: string;
+    _parent?: Context;
+    _lifecycle: ContextLifecycle;
+    _stores: StoreMap;
+    _state: Map<any, any>;
+    get isMounted(): boolean;
     /**
-     * The context of the nearest parent view.
+     * Returns a new Context with this one as its parent.
      */
+    static inherit(parent: Context, name: MaybeSignal<string>, options?: InheritedContextOptions): Context;
+    constructor(name: MaybeSignal<string>, options?: ContextOptions);
     /**
-     * Current route layer of the nearest view.
+     * Returns the current name of this context.
      */
-    route?: Source<View<{}> | undefined>;
-}
-export interface ComponentContext {
+    getName(): string;
     /**
-     * A name for debugging purposes. Prepended to log messages.
+     * Sets a new name for this context.
      */
-    name: string;
-}
-/**
- * A context capable of providing stores.
- */
-export interface StoreProviderContext {
+    setName(name: MaybeSignal<string>): void;
+    addStore<T>(store: Store<any, T>, options?: any): this;
+    getStore<T>(store: Store<any, T>): T;
+    beforeMount(listener: LifecycleListener): () => void;
+    onMount(listener: LifecycleListener): () => void;
+    beforeUnmount(listener: LifecycleListener): () => void;
+    onUnmount(listener: LifecycleListener): () => void;
+    effect(callback: EffectFn): UnsubscribeFn;
     /**
-     * Attaches a new store to this context and returns it.
+     * Gets the value stored at `key`, or returns the `defaultValue` if none is set.
      */
-    provide<Value>(store: StoreFunction<{}, Value>): Value;
+    getState<T>(key: any, defaultValue: T): T;
     /**
-     * Attaches a new store to this context and returns it.
+     * Gets the value stored at `key`, or throws an error if none is set.
      */
-    provide<Value>(store: StoreFunction<undefined, Value>): Value;
+    getState<T>(key: any): T;
     /**
-     * Attaches a new store to this context and returns it.
+     * Gets all values available to this context.
      */
-    provide<Options, Value>(store: StoreFunction<Options, Value>, options: Options): Value;
+    getState(): Map<any, any>;
+    setState<T>(key: any, value: T): void;
+    setState(entries: [any, any][]): void;
 }
-export interface StoreConsumerContext {
-    /**
-     * Gets the closest instance of a store. Throws an error if the store isn't provided higher in the tree.
-     */
-    get<Value>(store: StoreFunction<any, Value>): Value;
+export declare function createContext(name: MaybeSignal<string>, options?: ContextOptions): Context;
+export declare class StoreError extends Error {
 }
-type StoreMap = Map<any, any>;
-export declare const globalStores: StoreMap;
-export declare const rootElementContext: {
-    stores: StoreMap;
-};
 export {};

package/dist/core/index.d.ts

@@ -1,19 +1,20 @@
 export { $, effect, get, peek } from "./signals.js";
 export type { MaybeSignal, Signal, Source } from "./signals.js";
+export { createContext } from "./context.js";
+export type { Context, Store } from "./context.js";
+export { m, portal, render, repeat, unless, when } from "./markup.js";
+export type { Markup, MarkupElement } from "./markup.js";
+export { type Mixin } from "./nodes/html.js";
 export { ref, type Ref } from "./ref.js";
-export { constructView } from "./nodes/view.js";
+export { mount, type UnmountFn } from "./mount.js";
 export { deepEqual, shallowEqual, strictEqual } from "../utils.js";
-export { Stores, type StoreContext, type StoreFunction } from "./store.js";
-export { markup, portal, repeat, unless, when, constructMarkup } from "./markup.js";
-export type { Markup, MarkupElement } from "./markup.js";
 export { getEnv, setEnv } from "./env.js";
 export type { Env } from "./env.js";
 export { createLogger, setLogFilter, setLogLevels } from "./logger.js";
 export type { Logger, LoggerErrorContext, LoggerOptions, LogLevels } from "./logger.js";
-export { mount, type UnmountFn } from "./mount.js";
-export type { ViewContext, ViewElement, ViewFunction } from "./nodes/view.js";
-export type { CrashViewProps } from "./views/default-crash-view.js";
 export type { InputType, Renderable } from "../types.js";
+export type { View } from "./nodes/view.js";
+export type { CrashViewProps } from "./views/default-crash-view.js";
 import type { IntrinsicElements as Elements } from "../types.js";
 declare global {
     namespace JSX {

package/dist/core/logger.d.ts

@@ -11,13 +11,17 @@ export interface Logger {
     log(...args: any[]): void;
     warn(...args: any[]): void;
     error(...args: any[]): void;
-    crash(error: Error): void;
+    crash(error: Error): Error;
 }
 export interface LoggerOptions {
     /**
-     * Unique ID to print with logs. Makes it easier to track down messages from specific view instances.
+     * Tag value to print with logs.
      */
-    uid?: string;
+    tag?: string;
+    /**
+     * Label for tag value. Will be printed without a label if not specified.
+     */
+    tagName?: string;
     /**
      * Console object to use for logging (mostly for testing). Uses window.console by default.
      */
@@ -26,7 +30,8 @@ export interface LoggerOptions {
 export interface LoggerErrorContext {
     error: Error;
     loggerName: string;
-    uid?: string;
+    tag?: string;
+    tagName?: string;
 }
 export declare function onLoggerCrash(listener: (context: LoggerErrorContext) => void): () => void;
 export declare function createLogger(name: MaybeSignal<string>, options?: LoggerOptions): Logger;

package/dist/core/markup.d.ts

@@ -1,6 +1,6 @@
 import type { Mountable, Renderable } from "../types.js";
-import { type ElementContext } from "./context.js";
-import { View, type ViewContext, type ViewFunction, type ViewResult } from "./nodes/view.js";
+import { Context } from "./context.js";
+import { ViewInstance, type View, type ViewResult } from "./nodes/view.js";
 import { type MaybeSignal, type Signal } from "./signals.js";
 /**
  * Markup is a set of element metadata that hasn't been constructed into a MarkupElement yet.
@@ -10,7 +10,7 @@ export interface Markup {
      * In the case of a view, type will be the View function itself. It can also hold an identifier for special nodes like "$cond", "$repeat", etc.
      * DOM nodes can be created by name, such as HTML elements like "div", "ul" or "span", SVG elements like ""
      */
-    type: string | ViewFunction<any>;
+    type: string | View<any>;
     /**
      * Data that will be passed to a new MarkupElement instance when it is constructed.
      */
@@ -30,7 +30,6 @@ export interface MarkupElement extends Mountable {
 export declare function isMarkup(value: any): value is Markup;
 export declare function isMarkupElement(value: any): value is MarkupElement;
 export declare function toMarkup(renderables: Renderable | Renderable[]): Markup[];
-export declare function constructMarkup(markup: Markup | Markup[]): MarkupElement;
 export declare enum MarkupType {
     Text = "$text",
     Repeat = "$repeat",
@@ -47,13 +46,13 @@ export interface MarkupAttributes {
     [MarkupType.Repeat]: {
         items: Signal<any[]>;
         keyFn: (value: any, index: number) => string | number | symbol;
-        renderFn: (item: Signal<any>, index: Signal<number>, ctx: ViewContext) => ViewResult;
+        renderFn: (item: Signal<any>, index: Signal<number>, ctx: Context) => ViewResult;
     };
     [MarkupType.Dynamic]: {
         source: Signal<Renderable>;
     };
     [MarkupType.Outlet]: {
-        view: Signal<View<{}> | undefined>;
+        view: Signal<ViewInstance<{}> | undefined>;
     };
     [MarkupType.Fragment]: {
         children: MaybeSignal<MarkupElement[]>;
@@ -67,8 +66,8 @@ export interface MarkupAttributes {
     };
     [tag: string]: Record<string, any>;
 }
-export declare function markup<T extends keyof MarkupAttributes>(type: T, attributes: MarkupAttributes[T], ...children: Renderable[]): Markup;
-export declare function markup<I>(type: ViewFunction<I>, attributes?: I, ...children: any[]): Markup;
+export declare function m<T extends keyof MarkupAttributes>(type: T, attributes: MarkupAttributes[T], ...children: Renderable[]): Markup;
+export declare function m<I>(type: View<I>, attributes?: I, ...children: any[]): Markup;
 /**
  * Displays `thenContent` when `condition` is truthy and `elseContent` when falsy.
  */
@@ -81,15 +80,16 @@ export declare function unless(condition: MaybeSignal<any>, thenContent?: Render
  * Calls `renderFn` for each item in `items`. Dynamically adds and removes views as items change.
  * The result of `keyFn` is used to compare items and decide if item was added, removed or updated.
  */
-export declare function repeat<T>(items: MaybeSignal<T[]>, keyFn: (value: T, index: number) => string | number | symbol, renderFn: (item: Signal<T>, index: Signal<number>, ctx: ViewContext) => ViewResult): Markup;
+export declare function repeat<T>(items: MaybeSignal<T[]>, keyFn: (value: T, index: number) => string | number | symbol, renderFn: (item: Signal<T>, index: Signal<number>, ctx: Context) => ViewResult): Markup;
 /**
  * Renders `content` into a `parent` node anywhere in the page, rather than its usual position in the view.
  */
 export declare function portal(parent: Node, content: Renderable): Markup;
+export declare function render(content: Renderable, context?: Context): MarkupElement;
 /**
  * Construct Markup metadata into a set of MarkupElements.
  */
-export declare function toMarkupElements(elementContext: ElementContext, markup: Markup | Markup[]): MarkupElement[];
+export declare function toMarkupElements(context: Context, markup: Markup | Markup[]): MarkupElement[];
 /**
  * Combines one or more MarkupElements into a single MarkupElement.
  */

package/dist/core/mount.d.ts

@@ -1,10 +1,15 @@
+import { Router } from "../router/router";
+import { Context } from "./context";
 import { type LoggerErrorContext } from "./logger";
-import { type ViewFunction } from "./nodes/view";
+import { type View } from "./nodes/view";
 export type UnmountFn = () => Promise<void>;
 export interface MountOptions {
-    crashView?: ViewFunction<LoggerErrorContext>;
+    crashView?: View<LoggerErrorContext>;
+    /**
+     * An existing Context to use as the root, otherwise a new one will be created.
+     * Use this to provide top-level stores and state to the whole app.
+     */
+    context?: Context;
 }
-export declare function mount(parent: Element, view: any, options?: MountOptions): Promise<UnmountFn>;
-export declare function mount(parent: Element, router: any, options?: MountOptions): Promise<UnmountFn>;
-export declare function mount(parent: string, view: any, options?: MountOptions): Promise<UnmountFn>;
-export declare function mount(parent: string, router: any, options?: MountOptions): Promise<UnmountFn>;
+export declare function mount(view: View<{}>, domNode: Element, options?: MountOptions): Promise<UnmountFn>;
+export declare function mount(router: Router, domNode: Element, options?: MountOptions): Promise<UnmountFn>;

package/dist/core/nodes/dynamic.d.ts

@@ -1,11 +1,11 @@
 import type { Renderable } from "../../types.js";
-import type { ElementContext } from "../context.js";
+import type { Context } from "../context.js";
 import { type MarkupElement } from "../markup.js";
 import { Signal } from "../signals.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
 interface DynamicOptions {
     source: Signal<Renderable>;
-    elementContext: ElementContext;
+    context: Context;
 }
 /**
  * Displays dynamic children without a parent element.
@@ -17,7 +17,7 @@ export declare class Dynamic implements MarkupElement {
     [IS_MARKUP_ELEMENT]: boolean;
     domNode: Text;
     private children;
-    private elementContext;
+    private context;
     private source;
     private unsubscribe?;
     get isMounted(): boolean;

package/dist/core/nodes/html.d.ts

@@ -1,25 +1,26 @@
-import { type ElementContext } from "../context.js";
+import { Context } from "../context.js";
 import { type MarkupElement } from "../markup.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
+export type Mixin<E extends Element = Element> = (element: E, context: Context) => void;
 type HTMLOptions = {
-    elementContext: ElementContext;
+    context: Context;
     tag: string;
     props: Record<string, any>;
     children?: any[];
 };
 export declare class HTML implements MarkupElement {
     [IS_MARKUP_ELEMENT]: boolean;
-    domNode: HTMLElement | SVGElement;
+    domNode: SVGElement | HTMLElement;
+    context: Context;
     private props;
     private childMarkup;
     private children;
     private unsubscribers;
-    private elementContext;
     private logger;
     private ref?;
     private canClickAway;
     get isMounted(): boolean;
-    constructor({ tag, props, children, elementContext }: HTMLOptions);
+    constructor({ tag, props, children, context }: HTMLOptions);
     mount(parent: Node, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
     private attachProp;

package/dist/core/nodes/outlet.d.ts

@@ -1,7 +1,6 @@
 import { type MarkupElement } from "../markup.js";
 import { type Signal } from "../signals.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
-import { View } from "./view.js";
 /**
  * Renders the subroute of the nearest view.
  */
@@ -9,10 +8,10 @@ export declare class Outlet implements MarkupElement {
     [IS_MARKUP_ELEMENT]: boolean;
     domNode: Text;
     isMounted: boolean;
-    private view;
-    private mountedView?;
+    private $slot;
+    private mounted?;
     private unsubscribe?;
-    constructor(view: Signal<View<{}> | undefined>);
+    constructor($slot: Signal<MarkupElement | undefined>);
     mount(parent: Node, after?: Node | undefined): void;
     unmount(parentIsUnmounting?: boolean): void;
     private cleanup;

package/dist/core/nodes/portal.d.ts

@@ -1,11 +1,11 @@
 import type { Renderable } from "../../types.js";
-import type { ElementContext } from "../context.js";
+import { Context } from "../context.js";
 import { type MarkupElement } from "../markup.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
 interface PortalConfig {
     content: Renderable;
     parent: Node;
-    elementContext: ElementContext;
+    context: Context;
 }
 /**
  * Renders content into a specified parent node.

package/dist/core/nodes/repeat.d.ts

@@ -1,13 +1,13 @@
-import { type ElementContext } from "../context.js";
+import { type Context } from "../context.js";
 import { type MarkupElement } from "../markup.js";
 import { type Signal } from "../signals.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
-import { type ViewContext, type ViewResult } from "./view.js";
+import { type ViewResult } from "./view.js";
 interface RepeatOptions<T> {
-    elementContext: ElementContext;
+    context: Context;
     items: Signal<T[]>;
     keyFn: (item: T, index: number) => string | number | symbol;
-    renderFn: (item: Signal<T>, index: Signal<number>, ctx: ViewContext) => ViewResult;
+    renderFn: (item: Signal<T>, index: Signal<number>, ctx: Context) => ViewResult;
 }
 export declare class Repeat<T> implements MarkupElement {
     [IS_MARKUP_ELEMENT]: boolean;
@@ -15,11 +15,11 @@ export declare class Repeat<T> implements MarkupElement {
     private items;
     private unsubscribe;
     private connectedItems;
-    private elementContext;
+    private context;
     private renderFn;
     private keyFn;
     get isMounted(): boolean;
-    constructor({ elementContext, items, renderFn, keyFn }: RepeatOptions<T>);
+    constructor({ context, items, renderFn, keyFn }: RepeatOptions<T>);
     mount(parent: Node, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
     private _cleanup;

package/dist/core/nodes/view.d.ts

@@ -1,102 +1,34 @@
-import { Renderable } from "../../types.js";
-import { type ComponentContext, type ElementContext, type StoreConsumerContext, type StoreProviderContext } from "../context.js";
-import { type Logger } from "../logger.js";
+import { Context } from "../context.js";
 import { type Markup, type MarkupElement } from "../markup.js";
-import { type EffectFn, type Signal, type UnsubscribeFn } from "../signals.js";
-import { StoreFunction } from "../store.js";
+import { type Signal } from "../signals.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
+export declare const ROUTE: unique symbol;
+export declare const VIEW: unique symbol;
 /**
  * Any valid value that a View can return.
  */
 export type ViewResult = Node | Signal<any> | Markup | Markup[] | null;
-export type ViewFunction<P> = (this: ViewContext, props: P, context: ViewContext) => ViewResult;
+/**
+ *
+ */
+export type View<P> = (this: Context, props: P, context: Context) => ViewResult;
 /**
  * A view that has been constructed into DOM nodes.
  */
-export interface ViewElement extends MarkupElement {
-    setRouteView(view: ViewFunction<{}>): ViewElement;
-}
-export interface ViewContext extends Omit<Logger, "setName">, ComponentContext, StoreProviderContext, StoreConsumerContext {
-    /**
-     * An ID unique to this view.
-     */
-    readonly uid: string;
-    /**
-     * True while this view is connected to the DOM.
-     */
-    readonly isMounted: boolean;
-    /**
-     * Registers a callback to run just before this view is mounted. DOM nodes are not yet attached to the page.
-     */
-    beforeMount(callback: () => void): void;
-    /**
-     * Registers a callback to run just after this view is mounted.
-     */
-    onMount(callback: () => void): void;
-    /**
-     * Registers a callback to run just before this view is unmounted. DOM nodes are still attached to the page.
-     */
-    beforeUnmount(callback: () => void): void;
-    /**
-     * Registers a callback to run just after this view is unmounted.
-     */
-    onUnmount(callback: () => void): void;
-    /**
-     * Passes a getter function to `callback` that will track reactive states and return their current values.
-     * Callback will be run each time a tracked state gets a new value.
-     */
-    effect(callback: EffectFn): UnsubscribeFn;
-    /**
-     * Displays this view's subroutes if mounted as a router view.
-     */
-    outlet(): Markup;
-}
-interface Context extends Omit<Logger, "setName"> {
-}
-declare class Context implements ViewContext {
-    private view;
-    constructor(view: View<any>);
-    get uid(): string;
-    get isMounted(): boolean;
-    get name(): string;
-    set name(value: string);
-    provide<Value>(store: StoreFunction<any, Value>, options?: any): Value;
-    get<Value>(store: StoreFunction<any, Value>): Value;
-    beforeMount(callback: () => void): void;
-    onMount(callback: () => void): void;
-    beforeUnmount(callback: () => void): void;
-    onUnmount(callback: () => void): void;
-    effect(callback: EffectFn): UnsubscribeFn;
-    outlet(): Markup;
-}
-export declare class View<P> implements ViewElement {
+export declare class ViewInstance<P> implements MarkupElement {
     [IS_MARKUP_ELEMENT]: boolean;
     uniqueId: string;
-    elementContext: ElementContext;
-    logger: Logger;
+    context: Context;
     props: P & {
         children: Markup[] | undefined;
     };
-    fn: ViewFunction<P>;
+    fn: View<P>;
     element?: MarkupElement;
-    name: import("../signals.js").Source<string>;
-    context: Context;
-    lifecycleListeners: {
-        beforeMount: (() => any)[];
-        mount: (() => any)[];
-        beforeUnmount: (() => any)[];
-        unmount: (() => any)[];
-    };
-    constructor(elementContext: ElementContext, fn: ViewFunction<P>, props: P, children?: Markup[]);
+    $name: import("../signals.js").Source<string>;
+    constructor(context: Context, fn: View<P>, props: P, children?: Markup[]);
     get domNode(): Node;
     isMounted: boolean;
     mount(parent: Node, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
-    setRouteView(fn: ViewFunction<{}>): View<{}>;
     private _initialize;
 }
-export declare function constructView<P>(view: ViewFunction<P>, props: P, children?: Renderable[]): ViewElement;
-export declare function constructView(view: ViewFunction<{}>, children?: Renderable[]): ViewElement;
-export declare function constructView<P>(context: ElementContext, view: ViewFunction<P>, props: P, children?: Renderable[]): ViewElement;
-export declare function constructView(context: ElementContext, view: ViewFunction<{}>, children?: Renderable[]): ViewElement;
-export {};

package/dist/core/symbols.d.ts

@@ -1,4 +1,2 @@
 export declare const IS_MARKUP: unique symbol;
 export declare const IS_MARKUP_ELEMENT: unique symbol;
-export declare const IS_STORE: unique symbol;
-export declare const IS_ROUTER: unique symbol;

package/dist/core/views/default-crash-view.d.ts

@@ -13,6 +13,10 @@ export type CrashViewProps = {
     /**
      * Unique identifier to pinpoint the specific view that reported the crash.
      */
-    uid?: string;
+    tag?: string;
+    /**
+     * Label for the tag.
+     */
+    tagName?: string;
 };
 export declare function DefaultCrashView(props: CrashViewProps): import("../markup.js").Markup;

package/dist/core/views/fragment.d.ts

@@ -1,8 +1,8 @@
 import type { Renderable } from "../../types.js";
-import { type ViewContext } from "../nodes/view.js";
+import { Context } from "../context.js";
 /**
  * A utility view that displays its children.
  */
 export declare function Fragment(props: {
     children?: Renderable;
-}, ctx: ViewContext): import("../markup.js").Markup;
+}, ctx: Context): string | number | false | import("../signals.js").Signal<any> | import("../markup.js").Markup | (string | number | false | import("../signals.js").Signal<any> | import("../markup.js").Markup | null | undefined)[] | null;

package/dist/fragment-VXM-P2tT.js

@@ -0,0 +1,7 @@
+function t(n, r) {
+  return n.children ?? null;
+}
+export {
+  t as F
+};
+//# sourceMappingURL=fragment-VXM-P2tT.js.map

package/dist/fragment-VXM-P2tT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fragment-VXM-P2tT.js","sources":["../src/core/views/fragment.ts"],"sourcesContent":["import type { Renderable } from \"../../types.js\";\nimport { Context } from \"../context.js\";\nimport { m } from \"../markup.js\";\n\n/**\n * A utility view that displays its children.\n */\nexport function Fragment(props: { children?: Renderable }, ctx: Context) {\n  return props.children ?? null;\n  // return m(\"$dynamic\", { source: () => props.children });\n}\n"],"names":["Fragment","props","ctx"],"mappings":"AAOgB,SAAAA,EAASC,GAAkCC,GAAc;AACvE,SAAOD,EAAM,YAAY;AAE3B;"}

package/dist/http.js

@@ -6,7 +6,7 @@ var g = (r, e, t) => e in r ? b(r, e, { enumerable: !0, configurable: !0, writab
 var a = (r, e, t) => g(r, typeof e != "symbol" ? e + "" : e, t), m = (r, e, t) => e.has(r) || f("Cannot " + t);
 var d = (r, e, t) => (m(r, e, "read from private field"), t ? t.call(r) : e.get(r)), c = (r, e, t) => e.has(r) ? f("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(r) : e.set(r, t);
 var o = (r, e, t) => (m(r, e, "access private method"), t);
-import { b as w } from "./typeChecking-EAVNeFyB.js";
+import { i as w } from "./typeChecking-lgllKIVq.js";
 var l, p, i, h;
 class O {
   constructor() {