marko 5.37.6 → 6.0.0-3.11

package/dist/dom/abort-signal.d.ts

@@ -0,0 +1,3 @@
+import type { Scope } from "../common/types";
+export declare function resetAbortSignal(scope: Scope, id: string | number): void;
+export declare function getAbortSignal(scope: Scope, id: string | number): any;

package/dist/dom/compat.d.ts

@@ -0,0 +1,20 @@
+import { patchConditionals } from "./control-flow";
+import { queueEffect } from "./queue";
+import { type Renderer } from "./renderer";
+export declare const compat: {
+    patchConditionals: typeof patchConditionals;
+    queueEffect: typeof queueEffect;
+    init(): void;
+    registerRenderer(fn: any): void;
+    isOp(value: any): boolean;
+    isRenderer(renderer: any): boolean;
+    getStartNode(scope: any): any;
+    setScopeNodes(scope: any, startNode: Node, endNode: Node): void;
+    runComponentEffects(this: any): void;
+    resolveRegistered(value: any, { runtimeId, componentIdPrefix, }: {
+        runtimeId: string;
+        componentIdPrefix: string;
+    }): any;
+    createRenderer(setup: Renderer["___setup"], clone: Renderer["___clone"], args: Renderer["___args"]): Renderer;
+    render(out: any, component: any, renderer: Renderer, input: any): (Node & ChildNode) | ParentNode | null | undefined;
+};

package/dist/dom/control-flow.d.ts

@@ -0,0 +1,14 @@
+import { type Accessor, type Scope } from "../common/types";
+import { type Renderer } from "./renderer";
+import { type IntersectionSignal, type SignalOp, type ValueSignal } from "./signals";
+export declare function patchConditionals(fn: <T extends typeof conditional | typeof conditionalOnlyChild>(cond: T) => T): void;
+export declare let conditional: (nodeAccessor: Accessor, fn?: ((scope: Scope) => void) | 0, getIntersection?: () => IntersectionSignal) => ValueSignal<Renderer | string | undefined>;
+export declare function inConditionalScope<S extends Scope>(signal: IntersectionSignal, nodeAccessor: Accessor): IntersectionSignal;
+export declare function setConditionalRenderer<ChildScope extends Scope>(scope: Scope, nodeAccessor: Accessor, newRenderer: Renderer | string | undefined): void;
+export declare let conditionalOnlyChild: (nodeAccessor: Accessor, fn?: ((scope: Scope) => void) | 0, getIntersection?: () => IntersectionSignal) => ValueSignal<Renderer | string | undefined>;
+export declare function setConditionalRendererOnlyChild(scope: Scope, nodeAccessor: Accessor, newRenderer: Renderer | string | undefined): void;
+export declare const emptyMarkerArray: Scope[];
+export declare function loopOf(nodeAccessor: Accessor, renderer: Renderer): (scope: Scope, valueOrOp: SignalOp | [all: unknown[], by?: ((item: unknown, index: number) => unknown) | undefined]) => void;
+export declare function loopIn(nodeAccessor: Accessor, renderer: Renderer): (scope: Scope, valueOrOp: SignalOp | [obj: {}, by?: ((key: string, v: unknown) => unknown) | undefined]) => void;
+export declare function loopTo(nodeAccessor: Accessor, renderer: Renderer): (scope: Scope, valueOrOp: SignalOp | [to: number, from: number, step: number, by?: ((v: number) => unknown) | undefined]) => void;
+export declare function inLoopScope(signal: IntersectionSignal, loopNodeAccessor: Accessor): (scope: Scope, op: SignalOp) => void;

package/dist/dom/controllable.d.ts

@@ -0,0 +1,12 @@
+import { type Accessor, type Scope } from "../common/types";
+export declare function controllable_input_checked(scope: Scope, nodeAccessor: Accessor, checked: unknown, checkedChange: unknown): void;
+export declare function controllable_input_checked_effect(scope: Scope, nodeAccessor: Accessor): void;
+export declare function controllable_input_checkedValue(scope: Scope, nodeAccessor: Accessor, checkedValue: unknown, checkedValueChange: unknown, value: unknown): void;
+export declare function controllable_input_checkedValue_effect(scope: Scope, nodeAccessor: Accessor): void;
+export declare function controllable_input_value(scope: Scope, nodeAccessor: Accessor, value: unknown, valueChange: unknown): void;
+export declare function controllable_input_value_effect(scope: Scope, nodeAccessor: Accessor): void;
+export { controllable_input_value as controllable_textarea_value, controllable_input_value_effect as controllable_textarea_value_effect, };
+export declare function controllable_select_value(scope: Scope, nodeAccessor: Accessor, value: unknown, valueChange: unknown): void;
+export declare function controllable_select_value_effect(scope: Scope, nodeAccessor: Accessor): void;
+export declare function controllable_detailsOrDialog_open(scope: Scope, nodeAccessor: Accessor, open: unknown, openChange: unknown): void;
+export declare function controllable_detailsOrDialog_open_effect(scope: Scope, nodeAccessor: Accessor): void;

package/dist/dom/dom.d.ts

@@ -0,0 +1,19 @@
+import { type Accessor, type Scope } from "../common/types";
+export declare function isDocumentFragment(node: Node): node is DocumentFragment;
+export declare function attr(element: Element, name: string, value: unknown): void;
+export declare function setAttribute(element: Element, name: string, value: string | undefined): void;
+export declare function classAttr(element: Element, value: unknown): void;
+export declare function styleAttr(element: Element, value: unknown): void;
+export declare function data(node: Text | Comment, value: unknown): void;
+export declare function textContent(node: ParentNode, value: unknown): void;
+export declare function attrs(scope: Scope, nodeAccessor: Accessor, nextAttrs: Record<string, unknown>): void;
+export declare function partialAttrs(scope: Scope, nodeAccessor: Accessor, nextAttrs: Record<string, unknown>, skip: Record<string, 1>): void;
+export declare function attrsEvents(scope: Scope, nodeAccessor: Accessor): void;
+export declare function html(scope: Scope, value: unknown, index: Accessor): void;
+export declare function props(scope: Scope, nodeIndex: number, index: number): void;
+export declare function normalizeAttrValue(value: unknown): string | undefined;
+export declare function lifecycle(scope: Scope, index: string | number, thisObj: Record<string, unknown> & {
+    onMount?: (this: unknown) => void;
+    onUpdate?: (this: unknown) => void;
+    onDestroy?: (this: unknown) => void;
+}): void;

package/dist/dom/event.d.ts

@@ -0,0 +1,4 @@
+type EventNames = keyof GlobalEventHandlersEventMap;
+export declare function on<T extends EventNames, H extends false | null | undefined | ((ev: GlobalEventHandlersEventMap[T], target: Element) => void)>(element: Element, type: T, handler: H): void;
+export declare function createDelegator(): (node: Node, type: string, handler: EventListener) => void;
+export {};

package/dist/dom/parse-html.d.ts

@@ -0,0 +1,5 @@
+export declare function parseHTML(html: string): DocumentFragment;
+export declare function parseHTMLOrSingleNode(html: string): Text | (Node & {
+    firstChild?: ChildNode;
+    lastChild?: ChildNode;
+});

package/dist/dom/queue.d.ts

@@ -0,0 +1,10 @@
+import type { Scope } from "../common/types";
+import { type ValueSignal } from "./signals";
+type ExecFn<S extends Scope = Scope> = (scope: S, arg?: any) => void;
+export declare let rendering: boolean;
+export declare function queueSource<T>(scope: Scope, signal: ValueSignal, value: T): T;
+export declare function queueEffect<S extends Scope, T extends ExecFn<S>>(scope: S, fn: T): void;
+export declare function run(): void;
+export declare function prepareEffects(fn: () => void): unknown[];
+export declare function runEffects(effects?: unknown[]): void;
+export {};

package/dist/dom/reconcile.d.ts

@@ -0,0 +1,2 @@
+import type { Scope } from "../common/types";
+export declare function reconcile(parent: Node & ParentNode, oldScopes: Scope[], newScopes: Scope[], afterReference: Node | null): void;

package/dist/dom/renderer.d.ts

@@ -0,0 +1,21 @@
+import { type Accessor, type Scope } from "../common/types";
+import { type IntersectionSignal, type SignalOp, type ValueSignal } from "./signals";
+export type Renderer = {
+    ___id: symbol;
+    ___template: string;
+    ___walks: string;
+    ___setup: SetupFn | undefined;
+    ___closureSignals: Set<IntersectionSignal>;
+    ___clone: () => Node;
+    ___sourceNode: Node | undefined;
+    ___args: ValueSignal | undefined;
+    ___owner: Scope | undefined;
+};
+type SetupFn = (scope: Scope) => void;
+export declare function createScopeWithRenderer(renderer: Renderer, $global: Scope["___global"], ownerScope?: Scope): Scope;
+export declare function createScopeWithTagNameOrRenderer(tagNameOrRenderer: Renderer | string, $global: Scope["___global"], ownerScope?: Scope): Scope;
+export declare function initRenderer(renderer: Renderer, scope: Scope): Node;
+export declare function dynamicTagAttrs(nodeAccessor: Accessor, getRenderBody?: (scope: Scope) => Renderer, inputIsArgs?: boolean): (scope: Scope, attrsOrOp: (() => Record<string, unknown>) | SignalOp) => void;
+export declare function createRendererWithOwner(template: string, rawWalks?: string, setup?: SetupFn, getClosureSignals?: () => IntersectionSignal[], getArgs?: () => ValueSignal): (owner?: Scope) => Renderer;
+export declare function createRenderer(template: string, walks?: string, setup?: SetupFn, getClosureSignals?: () => IntersectionSignal[], getArgs?: () => ValueSignal): Renderer;
+export {};

package/dist/dom/resolve-cursor-position.d.ts

@@ -0,0 +1 @@
+export declare function resolveCursorPosition(updatedValue: string, initialValue: string, initialPosition: number, inputType: string): number;

package/dist/dom/resume.d.ts

@@ -0,0 +1,9 @@
+import { type Scope } from "../common/types";
+import type { IntersectionSignal, ValueSignal } from "./signals";
+export declare let isResuming: boolean;
+export declare function register<T>(id: string, obj: T): T;
+export declare function registerBoundSignal<T extends ValueSignal>(id: string, signal: T): T;
+export declare function getRegisteredWithScope(id: string, scope?: Scope): unknown;
+export declare function init(runtimeId?: string): void;
+export declare function registerSubscriber(id: string, signal: IntersectionSignal): IntersectionSignal;
+export declare function nodeRef(id: string, key: string): (scope: Scope) => () => any;

package/dist/dom/schedule.d.ts

@@ -0,0 +1,2 @@
+export declare let isScheduled: boolean;
+export declare function schedule(): void;

package/dist/dom/scope.d.ts

@@ -0,0 +1,7 @@
+import type { Scope } from "../common/types";
+export declare function createScope($global: Scope["$global"]): Scope;
+export declare function getEmptyScope(marker: Comment): Scope;
+export declare function destroyScope(scope: Scope): Scope;
+export declare function onDestroy(scope: Scope): void;
+export declare function removeAndDestroyScope(scope: Scope): void;
+export declare function insertBefore(scope: Scope, parent: Node & ParentNode, nextSibling: Node | null): void;

package/dist/dom/signals.d.ts

@@ -0,0 +1,39 @@
+import { type Accessor, type Scope } from "../common/types";
+import type { Renderer } from "./renderer";
+export type Signal = ValueSignal | IntersectionSignal;
+export declare const MARK: unique symbol;
+export declare const CLEAN: unique symbol;
+export declare const DIRTY: unique symbol;
+export type SignalOp = typeof MARK | typeof CLEAN | typeof DIRTY;
+export type SignalFn<T = unknown> = (scope: Scope, value: T) => void;
+export type ValueSignal<T = unknown> = SignalFn<T | SignalOp>;
+export type BoundValueSignal<T = unknown> = (valueOrOp: T | SignalOp) => void;
+export type IntersectionSignal = SignalFn<SignalOp> & {
+    ___subscribe?(scope: Scope): void;
+    ___unsubscribe?(scope: Scope): void;
+};
+export type BoundIntersectionSignal = ((op?: SignalOp) => void) & {
+    ___subscribe?(scope: Scope): void;
+    ___unsubscribe?(scope: Scope): void;
+};
+export declare function state<T>(valueAccessor: Accessor, fn: ValueSignal<T>, getIntersection?: () => IntersectionSignal): (scope: Scope, valueOrOp: T | SignalOp, valueChange?: (v: T) => void) => SignalOp | T;
+export declare function value<T>(valueAccessor: Accessor, fn: SignalFn<T> | 0, getIntersection?: () => IntersectionSignal): ValueSignal<T>;
+export declare function intersection(count: number, fn: SignalFn<never>, getIntersection?: () => IntersectionSignal): IntersectionSignal;
+export declare function closure<T>(ownerValueAccessor: Accessor | ((scope: Scope) => Accessor), fn: SignalFn<T> | 0, getOwnerScope?: (scope: Scope) => Scope, getIntersection?: () => IntersectionSignal): IntersectionSignal;
+export declare function dynamicClosure<T>(ownerValueAccessor: Accessor | ((scope: Scope) => Accessor), fn: ValueSignal<T> | 0, getOwnerScope?: (scope: Scope) => Scope, getIntersection?: () => IntersectionSignal): IntersectionSignal;
+export declare function childClosures(closureSignals: IntersectionSignal[], childAccessor: Accessor): {
+    (scope: Scope, op: SignalOp): void;
+    ___subscribe(scope: Scope): void;
+    ___unsubscribe(scope: Scope): void;
+};
+export declare function dynamicSubscribers(valueAccessor: Accessor): (scope: Scope, op: SignalOp) => void;
+export declare function setTagVar(scope: Scope, childAccessor: Accessor, tagVarSignal: ValueSignal): void;
+export declare const tagVarSignal: (scope: Scope, valueOrOp: unknown | SignalOp) => any;
+export declare function setTagVarChange(scope: Scope, changeHandler: (value: unknown) => void): void;
+export declare const tagVarSignalChange: (scope: Scope, value: unknown) => any;
+export declare const renderBodyClosures: (renderBody: Renderer | string | undefined, childScope: Scope, op: SignalOp) => void;
+export declare const inMany: (scopes: Scope[], op: SignalOp, signal: IntersectionSignal) => void;
+export declare function nextTagId({ $global }: Scope): string;
+export declare function inChild(childAccessor: Accessor, signal: ValueSignal): (scope: Scope, valueOrOp: unknown | SignalOp) => void;
+export declare function intersections(signals: IntersectionSignal[]): IntersectionSignal;
+export declare function effect(id: string, fn: (scope: Scope) => void): (scope: Scope) => void;

package/dist/dom/template.d.ts

@@ -0,0 +1,3 @@
+import type { Scope, Template } from "../common/types";
+import { createRenderer } from "./renderer";
+export declare const createTemplate: (templateId: string, template: string, walks?: string | undefined, setup?: ((scope: Scope) => void) | undefined, getClosureSignals?: (() => import("./signals").IntersectionSignal[]) | undefined, getArgs?: (() => import("./signals").ValueSignal) | undefined) => Template;

package/dist/dom/walker.d.ts

@@ -0,0 +1,4 @@
+import { type Scope } from "../common/types";
+export declare const walker: TreeWalker;
+export declare function trimWalkString(walkString: string): string;
+export declare function walk(startNode: Node, walkCodes: string, scope: Scope): void;

package/dist/dom.d.ts

@@ -0,0 +1,15 @@
+export { attrTag, attrTags } from "./common/attr-tag";
+export { forIn, forOf, forTo } from "./common/for";
+export type { Scope } from "./common/types";
+export { getAbortSignal, resetAbortSignal } from "./dom/abort-signal";
+export { compat } from "./dom/compat";
+export { conditional, conditionalOnlyChild, inConditionalScope, inLoopScope, loopIn, loopOf, loopTo, } from "./dom/control-flow";
+export { controllable_detailsOrDialog_open, controllable_detailsOrDialog_open_effect, controllable_input_checked, controllable_input_checked_effect, controllable_input_checkedValue, controllable_input_checkedValue_effect, controllable_input_value, controllable_input_value_effect, controllable_select_value, controllable_select_value_effect, controllable_textarea_value, controllable_textarea_value_effect, } from "./dom/controllable";
+export { attr, attrs, attrsEvents, classAttr, data, html, lifecycle, partialAttrs, props, styleAttr, textContent, } from "./dom/dom";
+export { on } from "./dom/event";
+export { run } from "./dom/queue";
+export { createRenderer, createRendererWithOwner, dynamicTagAttrs, } from "./dom/renderer";
+export { init, nodeRef, register, registerBoundSignal, registerSubscriber, } from "./dom/resume";
+export { createScope } from "./dom/scope";
+export { childClosures, closure, dynamicClosure, dynamicSubscribers, effect, inChild, intersection, intersections, nextTagId, setTagVar, setTagVarChange, state, tagVarSignal, tagVarSignalChange, value, } from "./dom/signals";
+export { createTemplate } from "./dom/template";