@tarojs/runtime 3.5.0-theta.1 → 3.5.0

package/dist/bom/document.d.ts

@@ -0,0 +1,2 @@
+declare let document: any;
+export { document };

package/dist/bom/getComputedStyle.d.ts

@@ -0,0 +1,3 @@
+import type { TaroElement } from '../dom/element';
+import type { Style } from '../dom/style';
+export declare function getComputedStyle(element: TaroElement): Style;

package/dist/bom/navigator.d.ts

@@ -0,0 +1 @@
+export declare const nav: any;

package/dist/bom/raf.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+export declare let now: () => number;
+declare const _raf: typeof requestAnimationFrame | ((callback: any) => NodeJS.Timeout);
+declare const _caf: typeof cancelAnimationFrame;
+export { _caf as caf, _raf as raf };

package/dist/bom/window.d.ts

@@ -0,0 +1,2 @@
+declare let window: any;
+export { window };

package/dist/constants/index.d.ts

@@ -0,0 +1,47 @@
+export declare const PROPERTY_THRESHOLD = 2046;
+export declare const TARO_RUNTIME = "Taro runtime";
+export declare const HOOKS_APP_ID = "taro-app";
+export declare const SET_DATA = "\u5C0F\u7A0B\u5E8F setData";
+export declare const PAGE_INIT = "\u9875\u9762\u521D\u59CB\u5316";
+export declare const ROOT_STR = "root";
+export declare const HTML = "html";
+export declare const HEAD = "head";
+export declare const BODY = "body";
+export declare const APP = "app";
+export declare const CONTAINER = "container";
+export declare const DOCUMENT_ELEMENT_NAME = "#document";
+export declare const DOCUMENT_FRAGMENT = "document-fragment";
+export declare const ID = "id";
+export declare const UID = "uid";
+export declare const CLASS = "class";
+export declare const STYLE = "style";
+export declare const FOCUS = "focus";
+export declare const VIEW = "view";
+export declare const STATIC_VIEW = "static-view";
+export declare const PURE_VIEW = "pure-view";
+export declare const PROPS = "props";
+export declare const DATASET = "dataset";
+export declare const OBJECT = "object";
+export declare const VALUE = "value";
+export declare const INPUT = "input";
+export declare const CHANGE = "change";
+export declare const CUSTOM_WRAPPER = "custom-wrapper";
+export declare const TARGET = "target";
+export declare const CURRENT_TARGET = "currentTarget";
+export declare const TYPE = "type";
+export declare const CONFIRM = "confirm";
+export declare const TIME_STAMP = "timeStamp";
+export declare const KEY_CODE = "keyCode";
+export declare const TOUCHMOVE = "touchmove";
+export declare const DATE = "Date";
+export declare const SET_TIMEOUT = "setTimeout";
+export declare const CATCHMOVE = "catchMove";
+export declare const CATCH_VIEW = "catch-view";
+export declare const COMMENT = "comment";
+export declare const ON_LOAD = "onLoad";
+export declare const ON_READY = "onReady";
+export declare const ON_SHOW = "onShow";
+export declare const ON_HIDE = "onHide";
+export declare const OPTIONS = "options";
+export declare const EXTERNAL_CLASSES = "externalClasses";
+export declare const BEHAVIORS = "behaviors";

package/dist/current.d.ts

@@ -0,0 +1,19 @@
+import { AppInstance, PageInstance } from './dsl/instance';
+export interface Router {
+    params: Record<string, unknown>;
+    path: string;
+    $taroPath: string;
+    onReady: string;
+    onHide: string;
+    onShow: string;
+    exitState?: any;
+}
+interface Current {
+    app: AppInstance | null;
+    router: Router | null;
+    page: PageInstance | null;
+    preloadData?: any;
+}
+export declare const Current: Current;
+export declare const getCurrentInstance: () => Current;
+export {};

package/dist/dom/class-list.d.ts

@@ -0,0 +1,14 @@
+import type { TaroElement } from './element';
+export declare class ClassList extends Set<string> {
+    private el;
+    constructor(className: string, el: TaroElement);
+    get value(): string;
+    add(s: string): this;
+    get length(): number;
+    remove(s: string): void;
+    toggle(s: string): void;
+    replace(s1: string, s2: string): void;
+    contains(s: string): boolean;
+    toString(): string;
+    private _update;
+}

package/dist/dom/document.d.ts

@@ -0,0 +1,20 @@
+import { TaroElement } from '../dom/element';
+import { createEvent } from '../dom/event';
+import { FormElement } from '../dom/form';
+import { TaroRootElement } from '../dom/root';
+import { TaroText } from '../dom/text';
+export declare class TaroDocument extends TaroElement {
+    documentElement: TaroElement;
+    head: TaroElement;
+    body: TaroElement;
+    createEvent: typeof createEvent;
+    constructor();
+    createElement(type: string): TaroElement | TaroRootElement | FormElement;
+    createElementNS(_svgNS: string, type: string): TaroElement | TaroRootElement | FormElement;
+    createTextNode(text: string): TaroText;
+    getElementById<T extends TaroElement>(id: string | undefined | null): T | null;
+    querySelector<T extends TaroElement>(query: string): T | null;
+    querySelectorAll(): never[];
+    createComment(): TaroText;
+    get defaultView(): any;
+}

package/dist/dom/element.d.ts

@@ -0,0 +1,38 @@
+import type { Attributes, Func } from '../interface';
+import { ClassList } from './class-list';
+import type { TaroEvent } from './event';
+import { TaroNode } from './node';
+import { Style } from './style';
+export declare class TaroElement extends TaroNode {
+    tagName: string;
+    props: Record<string, any>;
+    style: Style;
+    dataset: Record<string, unknown>;
+    innerHTML: string;
+    constructor();
+    private _stopPropagation;
+    get id(): string;
+    set id(val: string);
+    get className(): string;
+    set className(val: string);
+    get cssText(): string;
+    get classList(): ClassList;
+    get children(): TaroElement[];
+    get attributes(): Attributes[];
+    get textContent(): string;
+    set textContent(text: string);
+    hasAttribute(qualifiedName: string): boolean;
+    hasAttributes(): boolean;
+    get focus(): () => void;
+    set focus(value: () => void);
+    blur(): void;
+    setAttribute(qualifiedName: string, value: any): void;
+    removeAttribute(qualifiedName: string): void;
+    getAttribute(qualifiedName: string): string;
+    getElementsByTagName(tagName: string): TaroElement[];
+    getElementsByClassName(className: string): TaroElement[];
+    dispatchEvent(event: TaroEvent): boolean;
+    addEventListener(type: any, handler: any, options: any): void;
+    removeEventListener(type: any, handler: any, sideEffect?: boolean): void;
+    static extend(methodName: string, options: Func | Record<string, any>): void;
+}

package/dist/dom/event-source.d.ts

@@ -0,0 +1,7 @@
+import type { TaroNode } from './node';
+interface IEventSource extends Map<string | undefined | null, TaroNode> {
+    removeNode(child: TaroNode): void;
+    removeNodeTree(child: TaroNode): void;
+}
+export declare const eventSource: IEventSource;
+export {};

package/dist/dom/event-target.d.ts

@@ -0,0 +1,7 @@
+import type { AddEventListenerOptions, EventHandler } from '../interface';
+export declare class TaroEventTarget {
+    __handlers: Record<string, EventHandler[]>;
+    addEventListener(type: string, handler: EventHandler, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: string, handler: EventHandler): void;
+    isAnyEventBinded(): boolean;
+}

package/dist/dom/event.d.ts

@@ -0,0 +1,22 @@
+import type { EventOptions, MpEvent } from '../interface';
+import type { TaroElement } from './element';
+export declare class TaroEvent {
+    private cacheTarget;
+    private cacheCurrentTarget;
+    type: string;
+    bubbles: boolean;
+    cancelable: boolean;
+    _stop: boolean;
+    _end: boolean;
+    defaultPrevented: boolean;
+    timeStamp: number;
+    mpEvent: MpEvent | undefined;
+    constructor(type: string, opts: EventOptions, event?: MpEvent);
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+    preventDefault(): void;
+    get target(): any;
+    get currentTarget(): any;
+}
+export declare function createEvent(event: MpEvent | string, node?: TaroElement): TaroEvent;
+export declare function eventHandler(event: MpEvent): void;

package/dist/dom/form.d.ts

@@ -0,0 +1,7 @@
+import { TaroElement } from './element';
+import type { TaroEvent } from './event';
+export declare class FormElement extends TaroElement {
+    get value(): string | boolean | number | any[];
+    set value(val: string | boolean | number | any[]);
+    dispatchEvent(event: TaroEvent): boolean;
+}

package/dist/dom/node.d.ts

@@ -0,0 +1,75 @@
+import type { Func, UpdatePayload } from '../interface';
+import type { TaroDocument } from './document';
+import type { TaroElement } from './element';
+import { TaroEventTarget } from './event-target';
+import { NodeType } from './node_types';
+import type { TaroRootElement } from './root';
+interface RemoveChildOptions {
+    cleanRef?: boolean;
+    doUpdate?: boolean;
+}
+export declare class TaroNode extends TaroEventTarget {
+    uid: string;
+    sid: string;
+    nodeType: NodeType;
+    nodeName: string;
+    parentNode: TaroNode | null;
+    childNodes: TaroNode[];
+    constructor();
+    private hydrate;
+    private updateChildNodes;
+    get _root(): TaroRootElement | null;
+    protected findIndex(refChild: TaroNode): number;
+    get _path(): string;
+    get nextSibling(): TaroNode | null;
+    get previousSibling(): TaroNode | null;
+    get parentElement(): TaroElement | null;
+    get firstChild(): TaroNode | null;
+    get lastChild(): TaroNode | null;
+    /**
+     * @textContent 目前只能置空子元素
+     * @TODO 等待完整 innerHTML 实现
+     */
+    set textContent(text: string);
+    /**
+     * @doc https://developer.mozilla.org/zh-CN/docs/Web/API/Node/insertBefore
+     * @scenario
+     * [A,B,C]
+     *   1. insert D before C, D has no parent
+     *   2. insert D before C, D has the same parent of C
+     *   3. insert D before C, D has the different parent of C
+     */
+    insertBefore<T extends TaroNode>(newChild: T, refChild?: TaroNode | null, isReplace?: boolean): T;
+    /**
+     * @doc https://developer.mozilla.org/zh-CN/docs/Web/API/Node/appendChild
+     * @scenario
+     * [A,B,C]
+     *   1. append C, C has no parent
+     *   2. append C, C has the same parent of B
+     *   3. append C, C has the different parent of B
+     */
+    appendChild(newChild: TaroNode): TaroNode;
+    /**
+     * @doc https://developer.mozilla.org/zh-CN/docs/Web/API/Node/replaceChild
+     * @scenario
+     * [A,B,C]
+     *   1. replace B with C, C has no parent
+     *   2. replace B with C, C has no parent, C has the same parent of B
+     *   3. replace B with C, C has no parent, C has the different parent of B
+     */
+    replaceChild(newChild: TaroNode, oldChild: TaroNode): TaroNode | undefined;
+    /**
+     * @doc https://developer.mozilla.org/zh-CN/docs/Web/API/Node/removeChild
+     * @scenario
+     * [A,B,C]
+     *   1. remove A or B
+     *   2. remove C
+     */
+    removeChild<T extends TaroNode>(child: T, options?: RemoveChildOptions): T;
+    remove(options?: RemoveChildOptions): void;
+    hasChildNodes(): boolean;
+    enqueueUpdate(payload: UpdatePayload): void;
+    get ownerDocument(): TaroDocument;
+    static extend(methodName: string, options: Func | Record<string, any>): void;
+}
+export {};

package/dist/dom/node_types.d.ts

@@ -0,0 +1,10 @@
+export declare const enum NodeType {
+    ELEMENT_NODE = 1,
+    ATTRIBUTE_NODE = 2,
+    TEXT_NODE = 3,
+    CDATA_SECTION_NODE = 4,
+    ENTITY_REFERENCE_NODE = 5,
+    COMMENT_NODE = 6,
+    PROCESSING_INSTRUCTION_NODE = 7,
+    DOCUMENT_NODE = 9
+}

package/dist/dom/root.d.ts

@@ -0,0 +1,15 @@
+import type { Func, MpInstance, UpdatePayload } from '../interface';
+import { TaroElement } from './element';
+export declare class TaroRootElement extends TaroElement {
+    private updatePayloads;
+    private updateCallbacks;
+    pendingUpdate: boolean;
+    ctx: null | MpInstance;
+    constructor();
+    get _path(): string;
+    get _root(): TaroRootElement;
+    enqueueUpdate(payload: UpdatePayload): void;
+    performUpdate(initRender?: boolean, prerender?: Func): void;
+    enqueueUpdateCallback(cb: Func, ctx?: Record<string, any>): void;
+    flushUpdateCallback(): void;
+}

package/dist/dom/style.d.ts

@@ -0,0 +1,14 @@
+import { TaroElement } from './element';
+export declare class Style {
+    _pending: boolean;
+    _usedStyleProp: Set<string>;
+    _value: Partial<CSSStyleDeclaration>;
+    _element: TaroElement;
+    constructor(element: TaroElement);
+    private setCssVariables;
+    get cssText(): string;
+    set cssText(str: string);
+    setProperty(propertyName: string, value?: string | null): void;
+    removeProperty(propertyName: string): string;
+    getPropertyValue(propertyName: string): any;
+}

package/dist/dom/style_properties.d.ts

@@ -0,0 +1,3 @@
+declare const styleProperties: string[];
+/** 非常用 style */
+export { styleProperties };

package/dist/dom/svg.d.ts

@@ -0,0 +1,3 @@
+import { TaroElement } from './element';
+export declare class SVGElement extends TaroElement {
+}

package/dist/dom/text.d.ts

@@ -0,0 +1,14 @@
+import { TaroNode } from './node';
+import { NodeType } from './node_types';
+export declare class TaroText extends TaroNode {
+    _value: string;
+    nodeType: NodeType;
+    nodeName: string;
+    constructor(value: any);
+    set textContent(text: string);
+    get textContent(): string;
+    set nodeValue(text: string);
+    get nodeValue(): string;
+    set data(text: string);
+    get data(): string;
+}

package/dist/dom/tree.d.ts

@@ -0,0 +1,4 @@
+import type { TaroElement } from './element';
+declare type Filter = (element: TaroElement) => boolean;
+export declare function treeToArray(root: TaroElement, predict?: Filter): TaroElement[];
+export {};

package/dist/dom-external/element.d.ts

@@ -0,0 +1,3 @@
+import type { TaroElement } from 'src/dom/element';
+export declare function getBoundingClientRectImpl(this: TaroElement): Promise<null>;
+export declare function getTemplateContent(ctx: TaroElement): TaroElement | undefined;

package/dist/dom-external/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dom-external/inner-html/html.d.ts

@@ -0,0 +1,2 @@
+import type { TaroNode } from '../../dom/node';
+export declare function setInnerHTML(element: TaroNode, html: string): void;

package/dist/dom-external/inner-html/parser.d.ts

@@ -0,0 +1,25 @@
+import type { TaroDocument } from '../../dom/document';
+import type { TaroElement } from '../../dom/element';
+interface Node {
+    type: string;
+}
+interface Comment extends Node {
+    type: 'comment';
+    content: string;
+}
+export interface Text extends Node {
+    type: 'text';
+    content: string;
+}
+export interface Element extends Node {
+    type: 'element';
+    tagName: string;
+    children: ChildNode[];
+    attributes: string[];
+}
+export interface ParsedTaroElement extends TaroElement {
+    h5tagName?: string;
+}
+declare type ChildNode = Comment | Text | Element;
+export declare function parser(html: string, document: TaroDocument): (import("../..").TaroText | TaroElement)[];
+export {};

package/dist/dom-external/inner-html/scaner.d.ts

@@ -0,0 +1,30 @@
+interface Position {
+    index: number;
+    column: number;
+    line: number;
+}
+export interface Token {
+    type: string;
+    content?: string;
+    position?: {
+        start?: Position;
+        end?: Position;
+    };
+    close?: boolean;
+}
+export declare class Scaner {
+    private tokens;
+    private position;
+    private html;
+    constructor(html: string);
+    scan(): Token[];
+    private scanText;
+    private scanComment;
+    private scanTag;
+    private scanTagStart;
+    private scanTagEnd;
+    private scanTagName;
+    private scanAttrs;
+    private scanSkipTag;
+}
+export {};

package/dist/dom-external/inner-html/style.d.ts

@@ -0,0 +1,27 @@
+import type { ParsedTaroElement } from './parser';
+interface ISelector {
+    isChild: boolean;
+    isGeneralSibling: boolean;
+    isAdjacentSibling: boolean;
+    tag: string | null;
+    id: string | null;
+    class: string[];
+    attrs: {
+        all: boolean;
+        key: string;
+        value?: string | null;
+    }[];
+}
+interface IStyle {
+    content: string;
+    selectorList: ISelector[];
+}
+export default class StyleTagParser {
+    styles: IStyle[];
+    extractStyle(src: string): string;
+    stringToSelector(style: string): void;
+    parseSelector(src: string): ISelector[];
+    matchStyle(tagName: string, el: ParsedTaroElement, list: number[]): string;
+    matchCurrent(tagName: string, el: ParsedTaroElement, selector: ISelector): boolean;
+}
+export {};

package/dist/dom-external/inner-html/tags.d.ts

@@ -0,0 +1,8 @@
+export declare function makeMap(str: string, expectsLowerCase?: boolean): (key: string) => boolean;
+export declare const specialMiniElements: {
+    img: string;
+    iframe: string;
+};
+export declare const isMiniElements: (key: string) => boolean;
+export declare const isInlineElements: (key: string) => boolean;
+export declare const isBlockElements: (key: string) => boolean;

package/dist/dom-external/inner-html/utils.d.ts

@@ -0,0 +1 @@
+export declare function unquote(str: string): string;

package/dist/dom-external/mutation-observer/implements.d.ts

@@ -0,0 +1,52 @@
+import type { TaroNode } from '../../dom/node';
+import type { MutationRecord } from './record';
+export declare type MutationCallback = (mutations: MutationRecord[]) => any;
+/**
+ * @see https://dom.spec.whatwg.org/#dictdef-mutationobserverinit
+ */
+export interface MutationObserverInit {
+    attributeFilter?: string[];
+    attributeOldValue?: boolean;
+    attributes?: boolean;
+    characterData?: boolean;
+    characterDataOldValue?: boolean;
+    childList?: boolean;
+    subtree?: boolean;
+}
+/**
+ * The MutationObserver provides the ability
+ * to watch for changes being made to the DOM tree.
+ * It will invoke a specified callback function
+ * when DOM changes occur.
+ * @see https://dom.spec.whatwg.org/#mutationobserver
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+ */
+export declare class MutationObserverImpl {
+    callback: MutationCallback;
+    target: TaroNode | null;
+    options: MutationObserverInit;
+    records: MutationRecord[];
+    constructor(callback: MutationCallback);
+    /**
+     * Configures the MutationObserver
+     * to begin receiving notifications
+     * through its callback function
+     * when DOM changes matching the given options occur.
+     *
+     * Options matching is to be implemented.
+     */
+    observe(target: TaroNode, options?: MutationObserverInit): void;
+    /**
+     * Stop the MutationObserver instance
+     * from receiving further notifications
+     * until and unless observe() is called again.
+     */
+    disconnect(): void;
+    /**
+     * Removes all pending notifications
+     * from the MutationObserver's notification queue
+     * and returns them in a new Array of MutationRecord objects.
+     */
+    takeRecords(): MutationRecord[];
+}
+export declare function recordMutation(record: MutationRecord): void;

package/dist/dom-external/mutation-observer/index.d.ts

@@ -0,0 +1,13 @@
+import type { TaroNode } from '../../dom/node';
+import type { MutationCallback, MutationObserverInit } from './implements';
+import { MutationObserverImpl } from './implements';
+import { MutationRecord, MutationRecordType } from './record';
+export declare class MutationObserver {
+    core: Pick<MutationObserverImpl, 'observe' | 'disconnect' | 'takeRecords'>;
+    constructor(callback: MutationCallback);
+    observe(...args: [TaroNode, MutationObserverInit?]): void;
+    disconnect(): void;
+    takeRecords(): MutationRecord[];
+    static record(record: MutationRecord): void;
+}
+export { MutationRecordType };

package/dist/dom-external/mutation-observer/record.d.ts

@@ -0,0 +1,24 @@
+import type { TaroNode } from '../../dom/node';
+/**
+ * A MutationRecord represents an individual DOM mutation.
+ * It is the object that is passed to MutationObserver's callback.
+ * @see https://dom.spec.whatwg.org/#interface-mutationrecord
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord
+*/
+export interface MutationRecord {
+    readonly target: TaroNode;
+    readonly addedNodes?: TaroNode[];
+    readonly removedNodes?: TaroNode[];
+    readonly previousSibling?: TaroNode | null;
+    readonly nextSibling?: TaroNode | null;
+    readonly attributeName?: string | null;
+    readonly attributeNamespace?: string | null;
+    oldValue?: string | null;
+    readonly type: MutationRecordType;
+    readonly value?: string | null;
+}
+export declare const enum MutationRecordType {
+    ATTRIBUTES = "attributes",
+    CHARACTER_DATA = "characterData",
+    CHILD_LIST = "childList"
+}

package/dist/dom-external/node.d.ts

@@ -0,0 +1,11 @@
+import type { TaroNode } from 'src/dom/node';
+export declare type IPosition = 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend';
+/**
+ * An implementation of `Element.insertAdjacentHTML()`
+ * to support Vue 3 with a version of or greater than `vue@3.1.2`
+ */
+export declare function insertAdjacentHTML(this: TaroNode, position: IPosition, html: string): void;
+export declare function cloneNode(this: TaroNode, isDeep?: boolean): any;
+export declare function contains(this: TaroNode, node: TaroNode & {
+    id?: string;
+}): boolean;

package/dist/dsl/common.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import type { PageConfig } from '@tarojs/taro';
+import type { Instance, PageInstance, PageProps } from './instance';
+export declare function injectPageInstance(inst: Instance<PageProps>, id: string): void;
+export declare function getPageInstance(id: string): Instance | undefined;
+export declare function addLeadingSlash(path?: string): string;
+export declare function safeExecute(path: string, lifecycle: string, ...args: unknown[]): any;
+export declare function stringify(obj?: Record<string, unknown>): string;
+export declare function getPath(id: string, options?: Record<string, unknown>): string;
+export declare function getOnReadyEventKey(path: string): string;
+export declare function getOnShowEventKey(path: string): string;
+export declare function getOnHideEventKey(path: string): string;
+export declare function createPageConfig(component: any, pageName?: string, data?: Record<string, unknown>, pageConfig?: PageConfig): PageInstance;
+export declare function createComponentConfig(component: React.ComponentClass, componentName?: string, data?: Record<string, unknown>): any;
+export declare function createRecursiveComponentConfig(componentName?: string): any;