ctrl-fx 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,41 +1,2 @@
-import { type NodeGroup } from './dom/views';
-import type { Node } from './dom';
-import { type Effect } from './effects';
-import type { Component } from './dom/components';
-/** Type guard that returns true when `effectOrState` is a plain state value rather than an `Effect`. */
-export declare function isState<State>(effectOrState: Effect<State, never, State> | State): effectOrState is State;
-/** Converts a plain view function and initial state into a `Component`. Used internally by `manageApplication`; prefer `component()` from `ctrl-fx/dom` in application code. */
-export declare function toComponent<State>(app: (state: State) => Node<State, never> | NodeGroup<State, never>, initialState: State | Effect<State, never, State>): Component<State, void, never>;
-/**
- * Mounts a ctrl-fx application into the DOM element with id `mountId` and starts the runtime.
- * Returns a `dispatchEffect` handle for triggering effects from outside the framework
- * (e.g. from a service worker message).
- * @param mountId The id of the mount element. Defaults to `'app'`.
- */
-export declare function manageApplication<State>(app: (state: State) => Node<State, never> | NodeGroup<State, never>, initialState: State | Effect<State, never, State>, mountId?: string): {
-    dispatchEffect: (effect: Effect<State, never, void>) => void;
-};
-/** Width and height in pixels, as reported by a resize observer. */
-export type Dimensions = {
-    width: number;
-    height: number;
-};
-/** The browser permission state for a feature such as notifications. */
-export interface Permission {
-    value: 'default' | 'granted' | 'denied';
-    /** Returns true when the permission has been explicitly granted. */
-    isGranted(): boolean;
-    /** Returns true when the user has not yet been prompted. */
-    isDefault(): boolean;
-    /** Returns true when the permission has been explicitly denied. */
-    isDenied(): boolean;
-}
-/** Constructs a `Permission` value from a raw browser permission string. */
-export declare function permission(value: 'default' | 'granted' | 'denied'): Permission;
-/** A branded string containing a UUID v4. */
-export type Uuid = string & {
-    __brand: 'Uuid';
-};
-/** Deterministically derives a UUID-shaped string from `input` by hashing it. Useful for generating stable node identifiers from content. */
-export declare function uuidFromString(input: string): Uuid;
-//# sourceMappingURL=index.d.ts.map
+export { D as Dimensions, P as Permission, U as Uuid, i as isState, m as manageApplication, p as permission, t as toComponent, u as uuidFromString } from './index-fpCmXVEu.js';
+import './db/index.js';

package/dist/index.js

@@ -1,78 +1,18 @@
-//import type { Component } from "./components";
-//import { type NodeGroup } from "./dom/views";
-import { isNodeGroup, nodeGroup } from './dom/views';
-import { 
-/*isEffect, makeEffects,*/ isEffect, makeEffects, } from './effects';
-import { domInterpreter } from './internal/dominterpreter';
-import { manageComponent } from './internal/cmpmgr';
-import { realStyleRegistry } from './internal/styleregistry';
-//import { ComponentManager } from "./internal/cmpmgr";
-/** Type guard that returns true when `effectOrState` is a plain state value rather than an `Effect`. */
-export function isState(effectOrState) {
-    return !isEffect(effectOrState);
-}
-/** Converts a plain view function and initial state into a `Component`. Used internally by `manageApplication`; prefer `component()` from `ctrl-fx/dom` in application code. */
-export function toComponent(app, initialState) {
-    const { pure } = makeEffects();
-    const initialStateEffect = isState(initialState)
-        ? pure(initialState)
-        : initialState;
-    const adjustedApp = (state) => {
-        const nodeOrNodeGroup = app(state);
-        if (isNodeGroup(nodeOrNodeGroup)) {
-            return nodeOrNodeGroup;
-        }
-        else {
-            return nodeGroup(nodeOrNodeGroup);
-        }
-    };
-    return {
-        _type: 'Component',
-        params: undefined,
-        view: adjustedApp,
-        initialState() {
-            return initialStateEffect;
-        },
-    };
-}
-/**
- * Mounts a ctrl-fx application into the DOM element with id `mountId` and starts the runtime.
- * Returns a `dispatchEffect` handle for triggering effects from outside the framework
- * (e.g. from a service worker message).
- * @param mountId The id of the mount element. Defaults to `'app'`.
- */
-export function manageApplication(app, initialState, mountId = 'app') {
-    const component = toComponent(app, initialState);
-    return manageComponent(component, mountId, globalThis.window, domInterpreter, realStyleRegistry());
-}
-/** Constructs a `Permission` value from a raw browser permission string. */
-export function permission(value) {
-    return {
-        value,
-        isGranted() {
-            return value === 'granted';
-        },
-        isDefault() {
-            return value === 'default';
-        },
-        isDenied() {
-            return value === 'denied';
-        },
-    };
-}
-/** Deterministically derives a UUID-shaped string from `input` by hashing it. Useful for generating stable node identifiers from content. */
-export function uuidFromString(input) {
-    let hash = 0;
-    for (let i = 0; i < input.length; i++) {
-        hash = ((hash << 5) - hash + input.charCodeAt(i)) | 0;
-    }
-    const hex = (hash >>> 0).toString(16).padStart(8, '0');
-    const repeated = hex.repeat(4);
-    return [
-        repeated.slice(0, 8),
-        repeated.slice(8, 12),
-        repeated.slice(12, 16),
-        repeated.slice(16, 20),
-        repeated.slice(20, 32),
-    ].join('-');
-}
+import {
+  isState,
+  manageApplication,
+  permission,
+  toComponent,
+  uuidFromString
+} from "./chunk-DZAR6PTR.js";
+import "./chunk-NSWOTCDU.js";
+import "./chunk-KNHJPAIU.js";
+import "./chunk-XICUXW4T.js";
+import "./chunk-PKBMQBKP.js";
+export {
+  isState,
+  manageApplication,
+  permission,
+  toComponent,
+  uuidFromString
+};

package/dist/router.d.ts

@@ -1,12 +1,10 @@
-import type { EventActions } from './dom/events';
-import { type Effect } from './effects';
-import type { InternalLocation } from './net/location';
-export type { EventActions } from './dom/events';
-export type { InternalLocation } from './net/location';
+import { I as InternalLocation, E as Effect, a as EventActions } from './index-fpCmXVEu.js';
+import './db/index.js';
+
 /** Named path-segment parameters extracted from a matched route. */
-export type Params = Record<string, string>;
+type Params = Record<string, string>;
 /** A map of URL patterns to handler functions. Pattern keys use `:param` syntax for named path segments. */
-export type RouteMap<Route> = {
+type RouteMap<Route> = {
     [pattern: string]: (params: Params) => Route;
 };
 /**
@@ -17,24 +15,25 @@ export type RouteMap<Route> = {
  * const match = router({ '/': () => 'home', '/users/:id': ({ id }) => `user-${id}` })
  * ```
  */
-export declare function router<Route>(routes: RouteMap<Route>): (location: InternalLocation) => Route | null;
+declare function router<Route>(routes: RouteMap<Route>): (location: InternalLocation) => Route | null;
 /**
  * An effect describing a `history.pushState` to `path`, suitable for use as an `onClick` handler on an `<a>` element.
  * Produces `{ preventDefault: true }` to suppress the default browser navigation.
  */
-export declare function link<State, Event>(path: string): Effect<State, Event, EventActions>;
+declare function link<State, Event>(path: string): Effect<State, Event, EventActions>;
 /** An effect describing a `history.pushState` to `path`. Use in effect chains or button handlers. */
-export declare function navigate<State, Event>(path: string): Effect<State, Event, void>;
+declare function navigate<State, Event>(path: string): Effect<State, Event, void>;
 /**
  * Bundled router that strips `options.basePath` before matching and prepends it before navigating.
  * Use when your app is mounted at a sub-path (e.g. a GitHub Pages subdirectory).
  * Returns a `{ match, link, navigate }` object.
  */
-export declare function createRouter<Route>(routes: RouteMap<Route>, options?: {
+declare function createRouter<Route>(routes: RouteMap<Route>, options?: {
     basePath?: string;
 }): {
     match(location: InternalLocation): Route | null;
     link<State, Event>(path: string): Effect<State, Event, EventActions>;
     navigate<State, Event>(path: string): Effect<State, Event, void>;
 };
-//# sourceMappingURL=router.d.ts.map
+
+export { EventActions, InternalLocation, type Params, type RouteMap, createRouter, link, navigate, router };

package/dist/router.js

@@ -1,77 +1,66 @@
-import { async, pushState } from './effects';
-import { parseInternalLocation } from './net/location';
+import {
+  async,
+  parseInternalLocation,
+  pushState
+} from "./chunk-KNHJPAIU.js";
+import "./chunk-PKBMQBKP.js";
+
+// src/router.ts
 function compile(routes) {
-    return Object.entries(routes).map(([pattern, handler]) => ({
-        segments: pattern.split('/'),
-        handler,
-    }));
+  return Object.entries(routes).map(([pattern, handler]) => ({
+    segments: pattern.split("/"),
+    handler
+  }));
 }
 function matchRoute(compiled, location) {
-    const pathSegs = location.path.elems;
-    for (const { segments, handler } of compiled) {
-        if (segments.length !== pathSegs.length)
-            continue;
-        const params = {};
-        let matched = true;
-        for (let i = 0; i < segments.length; i++) {
-            const seg = segments[i];
-            if (seg.startsWith(':')) {
-                params[seg.slice(1)] = pathSegs[i];
-            }
-            else if (seg.toLowerCase() !== pathSegs[i].toLowerCase()) {
-                matched = false;
-                break;
-            }
-        }
-        if (matched)
-            return handler(params);
+  const pathSegs = location.path.elems;
+  for (const { segments, handler } of compiled) {
+    if (segments.length !== pathSegs.length) continue;
+    const params = {};
+    let matched = true;
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      if (seg.startsWith(":")) {
+        params[seg.slice(1)] = pathSegs[i];
+      } else if (seg.toLowerCase() !== pathSegs[i].toLowerCase()) {
+        matched = false;
+        break;
+      }
     }
-    return null;
+    if (matched) return handler(params);
+  }
+  return null;
 }
-/**
- * Creates a route-matching function from a pattern map. Pattern keys use `:param` syntax for
- * named path segments. Returns `null` when no pattern matches.
- *
- * ```ts
- * const match = router({ '/': () => 'home', '/users/:id': ({ id }) => `user-${id}` })
- * ```
- */
-export function router(routes) {
-    const compiled = compile(routes);
-    return location => matchRoute(compiled, location);
+function router(routes) {
+  const compiled = compile(routes);
+  return (location) => matchRoute(compiled, location);
 }
-/**
- * An effect describing a `history.pushState` to `path`, suitable for use as an `onClick` handler on an `<a>` element.
- * Produces `{ preventDefault: true }` to suppress the default browser navigation.
- */
-export function link(path) {
-    return async(pushState(parseInternalLocation(path)), 0).as({
-        preventDefault: true,
-    });
+function link(path) {
+  return async(pushState(parseInternalLocation(path)), 0).as({
+    preventDefault: true
+  });
 }
-/** An effect describing a `history.pushState` to `path`. Use in effect chains or button handlers. */
-export function navigate(path) {
-    return pushState(parseInternalLocation(path));
+function navigate(path) {
+  return pushState(parseInternalLocation(path));
 }
-/**
- * Bundled router that strips `options.basePath` before matching and prepends it before navigating.
- * Use when your app is mounted at a sub-path (e.g. a GitHub Pages subdirectory).
- * Returns a `{ match, link, navigate }` object.
- */
-export function createRouter(routes, options) {
-    const compiled = compile(routes);
-    const base = options?.basePath ?? '';
-    return {
-        match(location) {
-            if (!base)
-                return matchRoute(compiled, location);
-            const fullPath = location.path.elems.join('/');
-            if (!fullPath.startsWith(base))
-                return null;
-            const relative = fullPath.slice(base.length) || '/';
-            return matchRoute(compiled, parseInternalLocation(relative));
-        },
-        link: (path) => link(base + path),
-        navigate: (path) => navigate(base + path),
-    };
+function createRouter(routes, options) {
+  const compiled = compile(routes);
+  const base = options?.basePath ?? "";
+  return {
+    match(location) {
+      if (!base) return matchRoute(compiled, location);
+      const fullPath = location.path.elems.join("/");
+      if (!fullPath.startsWith(base)) return null;
+      const relative = fullPath.slice(base.length) || "/";
+      return matchRoute(compiled, parseInternalLocation(relative));
+    },
+    link: (path) => link(base + path),
+    navigate: (path) => navigate(base + path)
+  };
 }
+export {
+  createRouter,
+  link,
+  navigate,
+  router
+};

package/dist/testing.d.ts

@@ -1,45 +1,50 @@
-import { type NonEmptyArray } from './utils';
-import { type Attr } from './dom/attrs';
-import type { Node } from './dom';
-import type { Component } from './dom/components';
-import { type NodeGroup } from './dom/views';
-import { type Effect, type ScrollOptions } from './effects';
-import { type HttpError, type HttpRequest, type HttpResponse, type RequestError } from './net';
-import { type Result } from './utils/result';
-import { TestDatabaseData } from './db/testdb';
-import type { DbStoreSnapshot } from './db/testdb';
-import type { InternalLocation } from './net/location';
-export { TestDatabaseData };
-export type { DbStoreSnapshot };
-export type { InternalLocation };
-export type { HttpRequest, HttpResponse, HttpError, RequestError };
-export type DownloadRecord = {
+import { A as Attr, H as HttpRequest, R as Result, b as HttpResponse, c as RequestError, d as HttpError, I as InternalLocation, S as ScrollOptions, N as NodeGroup, e as Node, E as Effect, C as Component } from './index-fpCmXVEu.js';
+import { KeyPath, JsonValue, DbName, ObjectStore } from './db/index.js';
+
+type NonEmptyArray<A> = [A, ...A[]];
+
+type DbStoreSnapshot = {
+    readonly keyPath: KeyPath;
+    readonly records: ReadonlyMap<string, JsonValue>;
+    readonly autoIncrementCounter: number;
+};
+declare class TestDatabaseData {
+    readonly _databases: ReadonlyMap<string, ReadonlyMap<string, DbStoreSnapshot>>;
+    constructor(databases: ReadonlyMap<string, ReadonlyMap<string, DbStoreSnapshot>>);
+    records(db: DbName, store: ObjectStore): readonly JsonValue[];
+    getByKey(db: DbName, store: ObjectStore, key: IDBValidKey): JsonValue | undefined;
+    size(db: DbName, store: ObjectStore): number;
+    hasDatabase(db: DbName): boolean;
+    hasStore(db: DbName, store: ObjectStore): boolean;
+}
+
+type DownloadRecord = {
     readonly filename: string;
     readonly content: string;
     readonly contentType: string;
 };
-export type BroadcastSentRecord = {
+type BroadcastSentRecord = {
     readonly channel: string;
     readonly message: unknown;
 };
-export type SetAppBadge = {
+type SetAppBadge = {
     _type: 'SetAppBadge';
     count: number;
 };
-export type ClearAppBadge = {
+type ClearAppBadge = {
     _type: 'ClearAppBadge';
 };
-export type AppBadgeOperation = SetAppBadge | ClearAppBadge;
-export declare const clearAppBadge: ClearAppBadge;
-export declare function setAppBadge(count: number): SetAppBadge;
-export declare function appBadgeCount(operations: readonly AppBadgeOperation[]): number;
-export type HttpInteraction = {
+type AppBadgeOperation = SetAppBadge | ClearAppBadge;
+declare const clearAppBadge: ClearAppBadge;
+declare function setAppBadge(count: number): SetAppBadge;
+declare function appBadgeCount(operations: readonly AppBadgeOperation[]): number;
+type HttpInteraction = {
     readonly request: HttpRequest;
     readonly response: Result<HttpResponse, RequestError | HttpError>;
 };
-export type HttpHandler = (request: HttpRequest, prior: readonly HttpInteraction[]) => Result<HttpResponse, RequestError | HttpError>;
+type HttpHandler = (request: HttpRequest, prior: readonly HttpInteraction[]) => Result<HttpResponse, RequestError | HttpError>;
 /** Configuration passed to `testApplication`/`testComponent` to control how side effects behave during tests. */
-export type TestConfig = {
+type TestConfig = {
     readonly http: {
         /** Called for each HTTP request. Throw or return a failure Result to simulate errors. */
         readonly handler: HttpHandler;
@@ -54,18 +59,18 @@ export type TestConfig = {
     };
 };
 /** Creates a TestConfig that throws on any HTTP request. */
-export declare function defaultTestConfig(): TestConfig;
-export type ConfirmInteraction = {
+declare function defaultTestConfig(): TestConfig;
+type ConfirmInteraction = {
     message: string;
     response: boolean;
 };
-export type PromptInteraction = {
+type PromptInteraction = {
     message: string;
     default: string | undefined;
     response: string | null;
 };
 /** Snapshot of every observable side effect that occurred during a test run. */
-export type TestData<Custom = {}> = {
+type TestData<Custom = {}> = {
     readonly window: {
         readonly alerts: readonly any[];
         readonly confirms: readonly ConfirmInteraction[];
@@ -119,66 +124,66 @@ export type TestData<Custom = {}> = {
     readonly custom: Custom;
 };
 /** Creates an empty TestData, optionally initialising the `custom` field. */
-export declare function newTestData<Custom = {}>(custom?: Custom): TestData<Custom>;
-export type TestInput<State, Params, Custom = {}> = {
+declare function newTestData<Custom = {}>(custom?: Custom): TestData<Custom>;
+type TestInput<State, Params, Custom = {}> = {
     state?: State;
     params?: Params;
     testData?: TestData<Custom>;
 };
-export type Click = {
+type Click = {
     type: 'Click';
     selector: QuerySelector;
 };
 /** Simulates a click on the element(s) matching `selector`. */
-export declare function click(selector: QuerySelector): Click;
-export type AdvanceTime = {
+declare function click(selector: QuerySelector): Click;
+type AdvanceTime = {
     _type: 'AdvanceTime';
     milliseconds: number;
 };
 /** Advances the test scheduler clock by `milliseconds`, firing any scheduled tasks that come due. */
-export declare function advanceTime(milliseconds: number): AdvanceTime;
-export type ReceiveBroadcast = {
+declare function advanceTime(milliseconds: number): AdvanceTime;
+type ReceiveBroadcast = {
     _type: 'ReceiveBroadcast';
     channel: string;
     message: unknown;
 };
 /** Delivers a BroadcastChannel message to any active subscriber on `channel`. */
-export declare function receiveBroadcast(channel: string, message: unknown): ReceiveBroadcast;
-export type FireCustomEvent = {
+declare function receiveBroadcast(channel: string, message: unknown): ReceiveBroadcast;
+type FireCustomEvent = {
     _type: 'FireCustomEvent';
     selector: QuerySelector;
     eventName: string;
     detail: unknown;
 };
 /** Dispatches a custom DOM event on the element matching `selector`, invoking any `onEvent` handler. */
-export declare function fireCustomEvent(selector: QuerySelector, eventName: string, detail?: unknown): FireCustomEvent;
-export type Submit = {
+declare function fireCustomEvent(selector: QuerySelector, eventName: string, detail?: unknown): FireCustomEvent;
+type Submit = {
     _type: 'Submit';
     selector: QuerySelector;
 };
 /** Simulates a form submit event on the element(s) matching `selector`. */
-export declare function submit(selector: QuerySelector): Submit;
-export type TextInput = {
+declare function submit(selector: QuerySelector): Submit;
+type TextInput = {
     _type: 'TextInput';
     selector: QuerySelector;
     value: string;
 };
 /** Simulates an `input` event on the element(s) matching `selector`. */
-export declare function textInput(selector: QuerySelector, value: string): TextInput;
+declare function textInput(selector: QuerySelector, value: string): TextInput;
 /** Creates an attribute object `{ name, value }` for use with `findOne(...).attrs.toContainEqual(attr(...))`. */
-export declare function attr(name: string, value: string): {
+declare function attr(name: string, value: string): {
     name: string;
     value: string;
 };
-export type Interaction = Click | AdvanceTime | ReceiveBroadcast | FireCustomEvent | Submit | TextInput;
-export type { NonEmptyArray };
-export type DomElement = {
+type Interaction = Click | AdvanceTime | ReceiveBroadcast | FireCustomEvent | Submit | TextInput;
+
+type DomElement = {
     readonly tag: string;
     readonly attrs: readonly Attr[];
     readonly childNodes: readonly DomNode[];
 };
-export type DomNode = DomElement | string;
-export type TestableDom = {
+type DomNode = DomElement | string;
+type TestableDom = {
     head: DomElement;
     body: DomElement;
 };
@@ -188,7 +193,7 @@ export type TestableDom = {
  * `TestableComponent` reflecting the state after those interactions, so tests
  * can chain calls to build up complex scenarios step by step.
  */
-export type TestableComponent<State, Params, Event, Custom = {}> = {
+type TestableComponent<State, Params, Event, Custom = {}> = {
     readonly config: TestConfig;
     readonly state: State;
     readonly data: TestData<Custom>;
@@ -218,31 +223,32 @@ export type TestableComponent<State, Params, Event, Custom = {}> = {
  * component that was created with `component()`. For testing a top-level view
  * function directly, use `testApplication` instead.
  */
-export declare function testComponent<State, Params, Event, Custom = {}>(component: Component<State, Params, Event>, config?: TestConfig, data?: TestData<Custom>): TestableComponent<State, Params, Event, Custom>;
+declare function testComponent<State, Params, Event, Custom = {}>(component: Component<State, Params, Event>, config?: TestConfig, data?: TestData<Custom>): TestableComponent<State, Params, Event, Custom>;
 /**
  * The main entry point for testing a ctrl-fx application. Wraps a view
  * function and initial state into a `TestableComponent`. Call `.run(...)`
  * with interactions to simulate user actions, then inspect `.state`, `.data`,
  * and the `findOne`/`find` DOM query methods on the result.
  */
-export declare function testApplication<State, Custom = {}>(app: (state: State) => NodeGroup<State, never> | Node<State, never>, initialState: State | Effect<State, never, State>, config?: TestConfig, data?: TestData<Custom>): TestableComponent<State, void, never, Custom>;
-export type ExactlyOne = {
+declare function testApplication<State, Custom = {}>(app: (state: State) => NodeGroup<State, never> | Node<State, never>, initialState: State | Effect<State, never, State>, config?: TestConfig, data?: TestData<Custom>): TestableComponent<State, void, never, Custom>;
+type ExactlyOne = {
     _type: 'ExactlyOne';
     selector: string;
 };
-export type ZeroOrMore = {
+type ZeroOrMore = {
     _type: 'ZeroOrMore';
     selector: string;
 };
-export type ZeroOrOne = {
+type ZeroOrOne = {
     _type: 'ZeroOrOne';
     selector: string;
 };
-export type OneOrMore = {
+type OneOrMore = {
     _type: 'OneOrMore';
     selector: string;
 };
 /** Selects elements matching `selector`; throws during `run` if none are found. */
-export declare function one(selector: string): OneOrMore;
-export type QuerySelector = ExactlyOne | OneOrMore | ZeroOrMore | ZeroOrOne;
-//# sourceMappingURL=testing.d.ts.map
+declare function one(selector: string): OneOrMore;
+type QuerySelector = ExactlyOne | OneOrMore | ZeroOrMore | ZeroOrOne;
+
+export { type AdvanceTime, type AppBadgeOperation, type BroadcastSentRecord, type ClearAppBadge, type Click, type ConfirmInteraction, type DbStoreSnapshot, type DomElement, type DomNode, type DownloadRecord, type ExactlyOne, type FireCustomEvent, HttpError, type HttpHandler, type HttpInteraction, HttpRequest, HttpResponse, type Interaction, InternalLocation, type NonEmptyArray, type OneOrMore, type PromptInteraction, type QuerySelector, type ReceiveBroadcast, RequestError, type SetAppBadge, type Submit, type TestConfig, type TestData, TestDatabaseData, type TestInput, type TestableComponent, type TestableDom, type TextInput, type ZeroOrMore, type ZeroOrOne, advanceTime, appBadgeCount, attr, clearAppBadge, click, defaultTestConfig, fireCustomEvent, newTestData, one, receiveBroadcast, setAppBadge, submit, testApplication, testComponent, textInput };