@tarojs/runtime 3.7.0-canary.1 → 3.8.0-canary.0

package/dist/bom/URL.d.ts

@@ -0,0 +1,61 @@
+import { URLSearchParams } from './URLSearchParams';
+export declare class URL {
+    #private;
+    static createObjectURL(): void;
+    static revokeObjectURL(): void;
+    constructor(url: string, base?: string);
+    get protocol(): string;
+    set protocol(val: string);
+    get host(): string;
+    set host(val: string);
+    get hostname(): string;
+    set hostname(val: string);
+    get port(): string;
+    set port(val: string);
+    get pathname(): string;
+    set pathname(val: string);
+    get search(): string;
+    set search(val: string);
+    get hash(): string;
+    set hash(val: string);
+    get href(): string;
+    set href(val: string);
+    get origin(): string;
+    set origin(val: string);
+    get searchParams(): URLSearchParams;
+    toString(): string;
+    toJSON(): string;
+    _toRaw(): {
+        protocol: string;
+        port: string;
+        host: string;
+        hostname: string;
+        pathname: string;
+        hash: string;
+        search: string;
+        origin: string;
+        href: string;
+    };
+}
+export declare function parseUrl(url?: string): {
+    href: string;
+    origin: string;
+    protocol: string;
+    hostname: string;
+    host: string;
+    port: string;
+    pathname: string;
+    search: string;
+    hash: string;
+};
+export declare function parseUrlBase(url: string, base?: string): {
+    href: string;
+    origin: string;
+    protocol: string;
+    hostname: string;
+    host: string;
+    port: string;
+    pathname: string;
+    search: string;
+    hash: string;
+};

package/dist/bom/URLSearchParams.d.ts

@@ -0,0 +1,14 @@
+export declare class URLSearchParams {
+    #private;
+    constructor(query: any);
+    append(name: string, value: string): void;
+    delete(name: string): void;
+    get(name: string): any;
+    getAll(name: string): any;
+    has(name: string): boolean;
+    keys(): string[];
+    set(name: string, value: string): void;
+    forEach(callback: any, thisArg: any): void;
+    toJSON(): {};
+    toString(): string;
+}

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/history.d.ts

@@ -0,0 +1,29 @@
+import { Events } from '../emitter/emitter';
+import { RuntimeCache } from '../utils/cache';
+import type * as LocationType from './location';
+export interface HistoryState {
+    state: Record<string, any> | null;
+    title: string;
+    url: string;
+}
+type Options = {
+    window: any;
+};
+type HistoryContext = {
+    location: LocationType.Location;
+    stack: HistoryState[];
+    cur: number;
+};
+export declare class History extends Events {
+    #private;
+    constructor(location: LocationType.Location, options: Options);
+    get length(): number;
+    get state(): Record<string, any> | null;
+    go(delta: number): void;
+    back(): void;
+    forward(): void;
+    pushState(state: any, title: string, url: string): void;
+    replaceState(state: any, title: string, url: string): void;
+    get cache(): RuntimeCache<HistoryContext>;
+}
+export {};

package/dist/bom/location.d.ts

@@ -0,0 +1,36 @@
+import { Events } from '../emitter/emitter';
+import { RuntimeCache } from '../utils/cache';
+type Options = {
+    window: any;
+};
+type LocationContext = {
+    lastHref: string;
+};
+export declare class Location extends Events {
+    #private;
+    constructor(options: Options);
+    get protocol(): string;
+    set protocol(val: string);
+    get host(): string;
+    set host(val: string);
+    get hostname(): string;
+    set hostname(val: string);
+    get port(): string;
+    set port(val: string);
+    get pathname(): string;
+    set pathname(val: string);
+    get search(): string;
+    set search(val: string);
+    get hash(): string;
+    set hash(val: string);
+    get href(): string;
+    set href(val: string);
+    get origin(): string;
+    set origin(val: string);
+    assign(): void;
+    reload(): void;
+    replace(url: string): void;
+    toString(): string;
+    get cache(): RuntimeCache<LocationContext>;
+}
+export {};

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,4 @@
+declare let window: any;
+export declare const location: any;
+export declare const history: any;
+export { window };

package/dist/constants/index.d.ts

@@ -0,0 +1,59 @@
+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 COMPILE_MODE = "compileMode";
+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 EVENT_CALLBACK_RESULT = "e_result";
+export declare const BEHAVIORS = "behaviors";
+export declare const A = "a";
+/**
+ * 页面上下文切换时的行为
+ */
+export declare enum CONTEXT_ACTIONS {
+    INIT = "0",
+    RESTORE = "1",
+    RECOVER = "2",
+    DESTORY = "3"
+}

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/anchor-element.d.ts

@@ -0,0 +1,13 @@
+import { TaroElement } from './element';
+export declare class AnchorElement extends TaroElement {
+    get href(): string;
+    set href(val: string);
+    get protocol(): any;
+    get host(): any;
+    get search(): any;
+    get hash(): any;
+    get hostname(): any;
+    get port(): any;
+    get pathname(): any;
+    setAttribute(qualifiedName: string, value: any): void;
+}

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

@@ -0,0 +1,16 @@
+import type { TaroElement } from './element';
+export declare class ClassList {
+    private el;
+    private tokenList;
+    constructor(className: string, el: TaroElement);
+    get value(): string;
+    get length(): number;
+    add(): void;
+    remove(): void;
+    contains(token: string): boolean;
+    toggle(token: string, force: boolean): boolean;
+    replace(token: string, replacement_token: string): void;
+    toString(): string;
+    private checkTokenIsValid;
+    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,39 @@
+import { ClassList } from './class-list';
+import { TaroNode } from './node';
+import { Style } from './style';
+import type { Attributes, Func } from '../interface';
+import type { TaroEvent } from './event';
+export declare class TaroElement extends TaroNode {
+    ctx?: any;
+    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,23 @@
+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;
+    button: number;
+    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): any;

package/dist/dom/form.d.ts

@@ -0,0 +1,9 @@
+import { TaroElement } from './element';
+import type { TaroEvent } from './event';
+export declare class FormElement extends TaroElement {
+    get type(): string;
+    set type(val: string);
+    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,76 @@
+import { TaroEventTarget } from './event-target';
+import { NodeType } from './node_types';
+import type { Func, UpdatePayload } from '../interface';
+import type { TaroDocument } from './document';
+import type { TaroElement } from './element';
+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;
+    private updateSingleChild;
+    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 { TaroElement } from './element';
+import type { Func, MpInstance, UpdatePayload } from '../interface';
+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';
+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 '../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;
+}
+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;