optikos 0.0.0-stage → 0.2.0

package/dist/types/components/overlays/commandpalette/commandpalette.d.ts

@@ -0,0 +1,80 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+export interface Command {
+    id: string;
+    title: string;
+    /** Groups the command and gives it a filter chip. */
+    category?: string;
+    icon?: string;
+    description?: string;
+    /** Extra words that find the command. */
+    keywords?: string[];
+    /** Only displayed (the app binds the key itself). */
+    shortcut?: string;
+    disabled?: boolean;
+    hidden?: () => boolean;
+    /** Runs after the palette closed. Errors become the palette's `error` event. */
+    handler?: (ctx: {
+        palette: CommandPalette;
+        command: Command;
+    }) => unknown;
+    /** A second level: choosing this command shows these (Backspace on an empty field goes back). */
+    children?: Command[] | (() => Command[] | Promise<Command[]>);
+}
+export interface CommandPaletteConfig extends ComponentConfig {
+    commands?: Command[];
+    /** `mod` is Ctrl on Windows/Linux and ⌘ on macOS. `false` turns the global key off. Default `'mod+k'`. */
+    hotkey?: string | false;
+    placeholder?: string;
+    emptyText?: string;
+    maxResults?: number;
+    /** Order of the category groups; the others follow. */
+    categories?: string[];
+    /** Category chips under the field. Default true. */
+    filters?: boolean;
+}
+/**
+ * Command palette: Ctrl/⌘+K opens a searchable, categorized list of the actions the app registered. Choosing one closes
+ * the palette and runs it; a command with `children` opens a second level instead.
+ */
+export declare class CommandPalette extends Component<CommandPaletteConfig> {
+    protected baseCls: string;
+    private commands;
+    private levels;
+    private query;
+    private cat;
+    private shown;
+    private active;
+    private opened;
+    private opener;
+    private release;
+    private panel;
+    private input;
+    private filtersEl;
+    private listEl;
+    private live;
+    private crumb;
+    constructor(config?: CommandPaletteConfig);
+    protected build(): HTMLDivElement;
+    getCommands(): Command[];
+    setCommands(list: Command[]): void;
+    /** Adds commands; returns the function that removes them again. */
+    register(cmd: Command | Command[]): () => void;
+    /** Runs a command by id (searching every level that is not a submenu), without opening the palette. */
+    run(id: string): Promise<void>;
+    isOpen(): boolean;
+    toggle(): void;
+    open(): void;
+    close(): void;
+    protected onDestroy(): void;
+    private level;
+    /** Commands for the current query/filter, in display order. */
+    private results;
+    private paint;
+    private paintFilters;
+    private indexOf;
+    private setActive;
+    private onKey;
+    private back;
+    private choose;
+    private exec;
+}

package/dist/types/components/overlays/dropdown/dropdown.d.ts

@@ -0,0 +1,41 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+import { type AnyConfig } from '../../../core/registry.js';
+import { type Placement } from '../../../core/position.js';
+export interface DropdownConfig extends ComponentConfig {
+    anchor?: HTMLElement | Component | {
+        x: number;
+        y: number;
+    };
+    content?: HTMLElement | Component | AnyConfig;
+    placement?: Placement;
+    offset?: number;
+    flip?: boolean;
+    matchWidth?: boolean;
+    closeOnOutside?: boolean;
+    closeOnEsc?: boolean;
+    role?: string;
+    /** Move focus to the first focusable element of the content on open. */
+    autoFocus?: boolean;
+}
+/** Floating panel anchored to an element. Lives in the global layer; closes on outside click and Esc. */
+export declare class Dropdown extends Component<DropdownConfig> {
+    protected baseCls: string;
+    private content?;
+    private open_;
+    private release;
+    private leaving;
+    protected build(): HTMLDivElement;
+    getAnchor(): HTMLElement | undefined;
+    isOpen(): boolean;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    reposition(): void;
+    setAnchor(anchor: HTMLElement | Component | {
+        x: number;
+        y: number;
+    }): void;
+    setPlacement(placement: Placement): void;
+    setContent(content: HTMLElement | Component): void;
+    protected onDestroy(): void;
+}

package/dist/types/components/overlays/menu/menu.d.ts

@@ -0,0 +1,56 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+import type { Placement } from '../../../core/position.js';
+export interface MenuItem {
+    text?: string;
+    icon?: string;
+    handler?: (item: MenuItem) => void;
+    disabled?: boolean;
+    /** Present (true/false) makes it a checkable item. */
+    checked?: boolean;
+    items?: MenuEntry[];
+    /** Items with the same group sit together under its name (ungrouped items come first). */
+    group?: string;
+}
+export type MenuEntry = MenuItem | '-';
+export interface MenuConfig extends ComponentConfig {
+    items?: MenuEntry[];
+    /** A search field over the items: filters as you type; a search that names a group shows the whole group. */
+    search?: boolean;
+}
+/** Floating menu with submenus. Use `showBy(button)` for button menus and `showAt(x, y)` for context menus. */
+export declare class Menu extends Component<MenuConfig> {
+    protected baseCls: string;
+    parentMenu?: Menu;
+    private dd?;
+    private sub?;
+    private subOwner?;
+    private opener;
+    private hoverCancel?;
+    /** The `role=menu` element: the root itself, or a list under the search field. */
+    private list;
+    private searchEl?;
+    private emptyEl?;
+    protected build(): HTMLDivElement;
+    /** Without search the root is the menu; with it, the root holds the field, the menu and the "no results" line. */
+    private shell;
+    private first;
+    /** Hides the items that do not match the search (a group whose name matches keeps all of them); empty groups hide in CSS. */
+    private filter;
+    protected onRender(): void;
+    private entries;
+    private renderItems;
+    setItems(items: MenuEntry[]): void;
+    /** Turns the search field on or off. */
+    setSearch(search: boolean): void;
+    private activate;
+    private root;
+    private openSub;
+    isOpen(): boolean;
+    private focusFirst;
+    showBy(anchor: HTMLElement | Component, placement?: Placement, focus?: boolean): void;
+    showAt(x: number, y: number): void;
+    private open;
+    hide(): void;
+    closeAll(): void;
+    protected onDestroy(): void;
+}

package/dist/types/components/overlays/messagebox/messagebox.d.ts

@@ -0,0 +1,61 @@
+import { Window } from '../window/window.js';
+import { TextField } from '../../fields/textfield/textfield.js';
+import type { Validator } from '../../../core/validators.js';
+export interface MessageBoxButton {
+    id: string;
+    text: string;
+    variant?: 'default' | 'primary' | 'danger';
+}
+export interface MessageBoxConfig {
+    text: string;
+    title?: string;
+    icon?: string;
+    buttons: MessageBoxButton[];
+    /** Resolved when closed with Esc or the close button. */
+    cancelId?: string;
+    /** Adds a text input; `show` then resolves with the button id and the input is read by `prompt`. */
+    input?: {
+        value?: string;
+        placeholder?: string;
+        validators?: Validator<string>[];
+        autoFocus?: boolean;
+    };
+    /** Called with the pressed button id before closing; return `false` to keep the dialog open. */
+    beforeClose?: (id: string, win: Window, input?: TextField) => boolean | void;
+    /** Dim the page behind. Default false: a message is still modal, but it does not darken the screen. */
+    mask?: boolean;
+}
+declare function open(cfg: MessageBoxConfig): Promise<string>;
+export interface AlertOptions {
+    title?: string;
+    mask?: boolean;
+    okText?: string;
+    icon?: string;
+}
+export interface ConfirmOptions {
+    title?: string;
+    mask?: boolean;
+    okText?: string;
+    cancelText?: string;
+    danger?: boolean;
+    icon?: string;
+}
+export interface PromptOptions {
+    title?: string;
+    mask?: boolean;
+    value?: string;
+    placeholder?: string;
+    okText?: string;
+    cancelText?: string;
+    validators?: Validator<string>[];
+    /** Focus the text field on open (a phone keyboard pops up). Default false: the dialog gets the focus. */
+    autoFocus?: boolean;
+}
+export declare const MessageBox: {
+    show: typeof open;
+    alert(text: string, o?: AlertOptions): Promise<void>;
+    confirm(text: string, o?: ConfirmOptions): Promise<boolean>;
+    /** Resolves with the text, or `null` when cancelled. The dialog stays open while the validators fail. */
+    prompt(text: string, o?: PromptOptions): Promise<string | null>;
+};
+export {};

package/dist/types/components/overlays/toast/toast.d.ts

@@ -0,0 +1,45 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+export type ToastPosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top' | 'bottom';
+export interface ToastConfig extends ComponentConfig {
+    text?: string;
+    title?: string;
+    type?: 'info' | 'success' | 'warning' | 'error';
+    /** ms before it closes by itself; 0 keeps it until closed. Default 4000. */
+    duration?: number;
+    closable?: boolean;
+    position?: ToastPosition;
+}
+declare const defaults: {
+    duration: number;
+    position: ToastPosition;
+    max: number;
+};
+export declare class Toast extends Component<ToastConfig> {
+    protected baseCls: string;
+    private cancelTimer?;
+    private remaining;
+    private started;
+    protected build(): HTMLDivElement;
+    /** Puts the toast on screen and starts the timer. */
+    show(): void;
+    private pause;
+    private resume;
+    close(): void;
+}
+export interface ToastHandle {
+    close(): void;
+}
+/** `toast('Saved')` or `toast({ text, title, type, duration, closable, position })`. */
+export declare function toast(opts: string | ToastConfig): ToastHandle;
+export declare namespace toast {
+    var configure: (o: Partial<typeof defaults>) => {
+        duration: number;
+        position: ToastPosition;
+        max: number;
+    } & Partial<{
+        duration: number;
+        position: ToastPosition;
+        max: number;
+    }>;
+}
+export {};

package/dist/types/components/overlays/tooltip/tooltip.d.ts

@@ -0,0 +1,13 @@
+declare function show(t: HTMLElement): void;
+declare function hide(): void;
+export declare const Tooltip: {
+    /** Default delay (ms) before a hover tooltip shows. */
+    configure(o: {
+        delay?: number;
+    }): void;
+    show: typeof show;
+    hide: typeof hide;
+};
+/** Gives any element a tooltip (same as the `tooltip` config on components). */
+export declare function attachTooltip(target: HTMLElement, text: string): void;
+export {};

package/dist/types/components/overlays/widget/widget.d.ts

@@ -0,0 +1,61 @@
+import { Panel, type PanelConfig } from '../../layout/panel/panel.js';
+export type WidgetSide = 'right' | 'left' | 'top' | 'bottom';
+export interface WidgetConfig extends PanelConfig {
+    side?: WidgetSide;
+    /** Float above the page (default). `false`: an ordinary panel where the layout puts it. */
+    floating?: boolean;
+    /** Width on the sides, height on top/bottom (CSS length or px). */
+    size?: number | string;
+    /** Header buttons that let the user pick the side. */
+    sideSwitcher?: boolean;
+    /** Which sides the switcher offers. Default left, right, bottom. */
+    sides?: WidgetSide[];
+    closeOnEsc?: boolean;
+    /** On open the focus goes to the widget itself; `true` focuses its first field instead. Default false. */
+    autoFocus?: boolean;
+    /** The user can move it by its header (pointer drag, or Alt+arrow keys). A move frees it from the side; `setSide` docks it again. */
+    draggable?: boolean;
+    /** The user can resize it: the inner edge while docked, a corner grip once moved; arrow keys on the handle. */
+    resizable?: boolean;
+}
+/** A panel that floats over the page, attached to one edge. Not modal: the page behind stays usable. */
+export declare class Widget extends Panel<WidgetConfig> {
+    protected baseCls: string;
+    private opened;
+    private opener;
+    private cancelHide?;
+    private userTools;
+    private pos?;
+    private grip?;
+    constructor(config?: WidgetConfig);
+    protected onRender(): void;
+    getSide(): WidgetSide;
+    setSide(side: WidgetSide): void;
+    private paintSide;
+    /** Where the user left it (viewport px), or undefined while it sits on its side. */
+    getPosition(): {
+        x: number;
+        y: number;
+    } | undefined;
+    /** Puts a dragged widget back on its side. */
+    resetPosition(): void;
+    private moveTo;
+    private initDrag;
+    setSize(size: number | string): void;
+    /** Adds or removes the resize handle (only for a floating widget). */
+    setResizable(resizable: boolean): void;
+    /**
+     * Resizes from rect `r` by a pointer (or key) delta. Moved: the corner grip sets width and height. Docked: the inner edge
+     * sets the size, so pulling it away from the docked edge makes the widget bigger.
+     */
+    private resizeBy;
+    /** The handle's orientation and value follow the dimension it changes. */
+    private paintGrip;
+    isOpen(): boolean;
+    open(): void;
+    /** Opens or closes (with no argument: the other one). `toggle()` stays the Panel's collapse. */
+    setOpen(open?: boolean): void;
+    show(): void;
+    hide(): void;
+    protected onDestroy(): void;
+}

package/dist/types/components/overlays/window/window.d.ts

@@ -0,0 +1,38 @@
+import { Panel, type PanelConfig } from '../../layout/panel/panel.js';
+export interface WindowConfig extends PanelConfig {
+    modal?: boolean;
+    /** Dims the page behind a modal window. `false` keeps it modal (inert page, trapped focus) but clear. Default true. */
+    mask?: boolean;
+    draggable?: boolean;
+    closeOnEsc?: boolean;
+    closeOnBackdrop?: boolean;
+    /**
+     * On show the focus goes to the dialog itself (it is modal: the focus must be inside), so a phone keyboard does not
+     * pop up. `true` focuses its first field instead. Default false.
+     */
+    autoFocus?: boolean;
+}
+/** Floating dialog. Modal by default: the page behind becomes inert and Tab stays inside. */
+export declare class Window extends Panel<WindowConfig> {
+    protected baseCls: string;
+    private backdrop?;
+    private visible;
+    private cleanup;
+    private opener;
+    private moved;
+    private leaving;
+    constructor(config?: WindowConfig);
+    protected onRender(): void;
+    private initDrag;
+    /** Dims (true) or not (false) the page behind the modal window. */
+    setMask(mask: boolean): void;
+    isVisible(): boolean;
+    /** Centers in the viewport (also done on show and on resize until the user drags it). */
+    center(): void;
+    show(): void;
+    private focusFirst;
+    hide(): void;
+    /** Cleans up at once (the page is usable again) and takes the window off the screen: shrinking toward its opener, 20 % faster than it came. */
+    private release;
+    protected onDestroy(): void;
+}

package/dist/types/components/pagination.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/pagination/pagination.js';

package/dist/types/components/panel.d.ts

@@ -0,0 +1 @@
+export * from '../components/layout/panel/panel.js';

package/dist/types/components/pickerfield.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/pickerfield/pickerfield.js';

package/dist/types/components/radiogroup.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/radiogroup/radiogroup.js';

package/dist/types/components/searchgrid.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/searchgrid/searchgrid.js';

package/dist/types/components/secretfield.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/secretfield/secretfield.js';

package/dist/types/components/select.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/select/select.js';

package/dist/types/components/slider.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/slider/slider.js';

package/dist/types/components/spacer.d.ts

@@ -0,0 +1 @@
+export * from '../components/layout/spacer/spacer.js';

package/dist/types/components/spinner.d.ts

@@ -0,0 +1 @@
+export * from '../components/feedback/spinner/spinner.js';

package/dist/types/components/stepform.d.ts

@@ -0,0 +1 @@
+export * from '../components/form/stepform/stepform.js';

package/dist/types/components/stepper.d.ts

@@ -0,0 +1 @@
+export * from '../components/navigation/stepper/stepper.js';

package/dist/types/components/suggestfield.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/suggestfield/suggestfield.js';

package/dist/types/components/table.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/table/table.js';

package/dist/types/components/tabs.d.ts

@@ -0,0 +1 @@
+export * from '../components/navigation/tabs/tabs.js';

package/dist/types/components/textarea.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/textarea/textarea.js';

package/dist/types/components/textfield.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/textfield/textfield.js';

package/dist/types/components/toast.d.ts

@@ -0,0 +1 @@
+export * from '../components/overlays/toast/toast.js';

package/dist/types/components/toggle.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/toggle/toggle.js';

package/dist/types/components/toolbar.d.ts

@@ -0,0 +1 @@
+export * from '../components/layout/toolbar/toolbar.js';

package/dist/types/components/tooltip.d.ts

@@ -0,0 +1 @@
+export * from '../components/overlays/tooltip/tooltip.js';

package/dist/types/components/tree.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/tree/tree.js';

package/dist/types/components/viewmanager.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/viewmanager/viewmanager.js';

package/dist/types/components/viewport.d.ts

@@ -0,0 +1 @@
+export * from '../components/layout/viewport/viewport.js';

package/dist/types/components/widget.d.ts

@@ -0,0 +1 @@
+export * from '../components/overlays/widget/widget.js';

package/dist/types/components/window.d.ts

@@ -0,0 +1 @@
+export * from '../components/overlays/window/window.js';

package/dist/types/core/component.d.ts

@@ -0,0 +1,94 @@
+import { Emitter, type Handler } from './emitter.js';
+export interface ComponentConfig {
+    type?: string;
+    id?: string;
+    cls?: string;
+    style?: string | Record<string, string | number>;
+    hidden?: boolean;
+    disabled?: boolean;
+    width?: number | string;
+    height?: number | string;
+    flex?: number | string;
+    tooltip?: string;
+    /** Inside a Form: shown only while this returns true (given the form values). A field hidden this way neither validates nor goes into `getValues`. */
+    showIf?: (values: Record<string, any>) => boolean;
+    /** Inside a Form: enabled only while this returns true (given the form values). */
+    enableIf?: (values: Record<string, any>) => boolean;
+    /** Component-scoped tokens: `{ radius: '0' }` on a button sets `--op-button-radius`. Keys starting with `--` are used as is. */
+    theme?: Record<string, string | number>;
+    /**
+     * Default `true`: the component keeps its size when only its *state* changes (loading, searching, invalid).
+     * The CSS reserves room for the state's extra content instead of growing. `false` lets it fit the content.
+     * Does not apply to new *content* (`setText` with a longer text).
+     */
+    stableSize?: boolean;
+    /** `true` or a text: shows a mask with a spinner over the component. */
+    loading?: boolean | string;
+    ariaLabel?: string;
+    /** Layout `border`: where the item goes. */
+    region?: 'north' | 'south' | 'west' | 'east' | 'center';
+    /** Layout `grid`: columns spanned; `'full'` takes the whole row. */
+    colspan?: number | 'full';
+    listeners?: Record<string, Handler>;
+    renderTo?: string | HTMLElement;
+    /** Free slot for application data. */
+    data?: unknown;
+}
+/** Anything that owns children (Container) and accepts being asked to drop one. */
+export interface Parent {
+    remove(child: Component, destroy?: boolean): unknown;
+}
+export declare class Component<C extends ComponentConfig = ComponentConfig> extends Emitter {
+    static type?: string;
+    config: C;
+    readonly id: string;
+    parent?: Component & Parent;
+    rendered: boolean;
+    mounted: boolean;
+    destroyed: boolean;
+    protected baseCls: string;
+    protected tag: keyof HTMLElementTagNameMap;
+    private _el?;
+    private disposers;
+    private mask?;
+    constructor(config?: C);
+    /** The root element. Built on first access. */
+    get el(): HTMLElement;
+    /** Builds the root element. Subclasses override to create their own DOM. */
+    protected build(): HTMLElement;
+    protected onRender(): void;
+    protected onMount(): void;
+    protected onDestroy(): void;
+    /** Builds the DOM once. Safe to call repeatedly. */
+    render(): HTMLElement;
+    /** Appends to a target (default `document.body`) and fires `onMount` for the whole subtree. */
+    mount(target?: string | HTMLElement): this;
+    /** Called when the element becomes part of a mounted tree. Containers override to reach children. */
+    notifyMount(): void;
+    destroy(): void;
+    /** Registers a function to run on `destroy` (listeners, timers, effects). Returns it. */
+    own<F extends () => void>(fn: F): F;
+    /** Adds a DOM listener released on `destroy`. */
+    listen(target: EventTarget, type: string, fn: (e: any) => void, opts?: AddEventListenerOptions | boolean): () => void;
+    /** `setTimeout` released on `destroy`; returns the cancel function. */
+    later(fn: () => void, ms: number): () => void;
+    protected onDisabled(_disabled: boolean): void;
+    setDisabled(disabled: boolean): void;
+    show(): void;
+    hide(): void;
+    isHidden(): boolean;
+    addCls(name: string): void;
+    removeCls(name: string): void;
+    toggleCls(name: string, on?: boolean): void;
+    setWidth(v: number | string): void;
+    setHeight(v: number | string): void;
+    setFlex(v: number | string): void;
+    setStableSize(stable: boolean): void;
+    setTooltip(text: string): void;
+    setTheme(theme: Record<string, string | number>): void;
+    /** Shows (or removes) a loading mask. A string is shown as text under the spinner. */
+    setLoading(loading: boolean | string): void;
+    /** The element that receives focus on `focus()`. */
+    protected focusEl(): HTMLElement;
+    focus(): void;
+}

package/dist/types/core/container.d.ts

@@ -0,0 +1,43 @@
+import { Component, type ComponentConfig, type Parent } from './component.js';
+import { type AnyConfig } from './registry.js';
+import { type Layout, type LayoutSpec } from '../layout/layout.js';
+export interface ContainerConfig extends ComponentConfig {
+    items?: Array<AnyConfig | Component | string>;
+    layout?: LayoutSpec;
+    /** Config merged into every item that does not set the key itself. */
+    defaults?: Record<string, unknown>;
+    /** `type` used by items that do not declare one. */
+    defaultType?: string;
+    /** Layout `card`: initial visible child (index or id). */
+    activeItem?: number | string;
+}
+export declare class Container<C extends ContainerConfig = ContainerConfig> extends Component<C> implements Parent {
+    protected baseCls: string;
+    protected defaultLayout: LayoutSpec | undefined;
+    items: Component[];
+    layout?: Layout;
+    constructor(config?: C);
+    /** Element that holds the children. Panels override it. */
+    getBody(): HTMLElement;
+    /** Turns shorthand strings (`'->'`) into configs. Subclasses override; the base has none. */
+    protected shorthand(s: string): AnyConfig;
+    private make;
+    protected onRender(): void;
+    protected attach(c: Component, index: number): void;
+    add(item: AnyConfig | Component | string): Component;
+    insert(index: number, item: AnyConfig | Component | string): Component;
+    /** Removes a child (by instance, id or index). Destroys it unless `destroy` is `false`. */
+    remove(child: Component | string | number, destroy?: boolean): Component | undefined;
+    removeAll(destroy?: boolean): void;
+    getItems(): Component[];
+    /** Direct child by id. */
+    get(id: string): Component | undefined;
+    /** All descendants (depth-first) matching `fn`. */
+    query(fn: (c: Component) => boolean): Component[];
+    /** Layout `card`: which child is visible. */
+    getActiveItem(): Component | undefined;
+    setActiveItem(item: Component | string | number): void;
+    notifyMount(): void;
+    protected onDestroy(): void;
+    setDisabled(disabled: boolean): void;
+}

package/dist/types/core/date.d.ts

@@ -0,0 +1,14 @@
+export declare const toISO: (d: Date) => string;
+export declare function fromISO(iso: string): Date | null;
+export declare const today: () => string;
+export declare function addDays(iso: string, n: number): string;
+/** Moves by whole months, clamping the day (Jan 31 + 1 month → Feb 28). */
+export declare function addMonths(iso: string, n: number): string;
+export declare const formatDate: (iso: string, opts?: Intl.DateTimeFormatOptions) => string;
+/**
+ * Parses what a user types: ISO, or day/month/year in the order the current locale uses (derived from `Intl`),
+ * with `/`, `-` or `.` as separators and 2- or 4-digit years.
+ */
+export declare function parseDate(text: string): string | null;
+/** 0 = Sunday. Reads the locale's week start when the engine knows it. */
+export declare function firstDay(): number;

package/dist/types/core/dom.d.ts

@@ -0,0 +1,11 @@
+export type Child = Node | string | number | null | undefined | false;
+export type Attrs = Record<string, string | number | boolean | null | undefined>;
+/** Sets attributes; `null`, `undefined` and `false` remove, `true` sets an empty attribute. */
+export declare function attr(el: Element, attrs: Attrs): void;
+/** Tiny element factory: `h('button', 'op-button', { type: 'button' }, 'Save')`. */
+export declare function h<K extends keyof HTMLElementTagNameMap>(tag: K, cls?: string, attrs?: Attrs, ...kids: Child[]): HTMLElementTagNameMap[K];
+export declare const uid: (prefix?: string) => string;
+export declare const kebab: (s: string) => string;
+export declare const px: (v: number | string) => string;
+export declare const clamp: (n: number, min: number, max: number) => number;
+export declare const isEl: (v: unknown) => v is HTMLElement;