revas 1.0.2 → 2.0.0

package/dist/revas-common.d.ts

@@ -0,0 +1,363 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+import * as react_reconciler from 'react-reconciler';
+
+declare class Frame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor(x?: number, y?: number, width?: number, height?: number);
+}
+declare class Node<T = any> {
+    readonly type: string;
+    props: NodeProps & T;
+    readonly children: Node[];
+    frame: Frame;
+    parent?: Node;
+    constructor(type: string, props: NodeProps & T);
+    get $ready(): boolean;
+}
+interface RevasTouch {
+    identifier: number;
+    x: number;
+    y: number;
+}
+type RevasTouchType = 'touchstart' | 'touchmove' | 'touchend';
+interface RevasTouchEvent {
+    type: RevasTouchType;
+    touches: {
+        [key: string]: RevasTouch;
+    };
+    timestamp: number;
+    [key: string]: any;
+}
+type RevasTouchEventListener = (event: RevasTouchEvent) => any;
+interface BaseProps {
+    children?: ReactNode;
+    style?: any | any[];
+    cache?: string | boolean;
+    forceCache?: boolean;
+}
+interface NodeProps extends BaseProps {
+    onTouchStart?: RevasTouchEventListener;
+    onTouchMove?: RevasTouchEventListener;
+    onTouchEnd?: RevasTouchEventListener;
+    onLayout?: (frame: Frame) => any;
+    pointerEvents?: 'auto' | 'none' | 'box-none';
+    $ready?: boolean;
+}
+
+declare function View(props: NodeProps): React.ReactElement<NodeProps, string | React.JSXElementConstructor<any>>;
+
+declare class RevasCanvas {
+    readonly transform: Transform;
+    constructor(context: CanvasRenderingContext2D);
+    get context(): CanvasRenderingContext2D;
+    get element(): HTMLCanvasElement;
+}
+declare class Transform {
+    readonly context: CanvasRenderingContext2D;
+    _stack: DOMMatrix[];
+    _canGetTransform: boolean;
+    constructor(context: CanvasRenderingContext2D);
+    save(): void;
+    restore(): void;
+    translate(x: number, y: number): void;
+    rotate(rad: number): void;
+    scale(sx: number, sy: number): void;
+}
+
+interface DrawTextOptions {
+    textStyle: any;
+    numberOfLines: number;
+    frame: Frame;
+    content: string;
+}
+type MeasureLine = {
+    width: number;
+    text: string;
+};
+type MeasureResult = [MeasureLine[], number];
+
+type TextProps = {
+    numberOfLines?: number;
+} & NodeProps;
+declare class Text extends React.Component<TextProps> {
+    state: {
+        height: number;
+    };
+    _measured: MeasureResult;
+    _drawed?: DrawTextOptions;
+    drawText: (canvas: RevasCanvas, node: Node) => void;
+    render(): React.DOMElement<any, Element>;
+}
+
+declare function drawImage(canvas: RevasCanvas, node: Node, flags: any): void;
+
+type ImageViewProps = {
+    src: string;
+} & NodeProps;
+declare function ImageView(props: ImageViewProps): React.ReactElement<{
+    style: any[];
+    $ready: boolean;
+    src: string;
+    onTouchStart?: RevasTouchEventListener;
+    onTouchMove?: RevasTouchEventListener;
+    onTouchEnd?: RevasTouchEventListener;
+    onLayout?: (frame: Frame) => any;
+    pointerEvents?: "auto" | "none" | "box-none";
+    children?: React.ReactNode;
+    cache?: string | boolean;
+    forceCache?: boolean;
+    customDrawer: typeof drawImage | undefined;
+}, string | React.JSXElementConstructor<any>>;
+
+declare abstract class AnimatedNode {
+    abstract getValue(observer?: Function): number;
+    interpolate(inRange: number[], outRange: number[], ease?: (t: number) => number): AnimatedInterpolate;
+}
+declare class AnimatedValue extends AnimatedNode {
+    private _value;
+    private _observer?;
+    constructor(_value: number);
+    setValue(value: number): void;
+    getValue(observer?: Function): number;
+}
+declare class AnimatedInterpolate extends AnimatedNode {
+    private source;
+    private inRange;
+    private outRange;
+    private ease;
+    constructor(source: AnimatedNode, inRange: number[], outRange: number[], ease: (t: number) => number);
+    getValue(observer?: Function): number;
+}
+type TimingConfig = {
+    to: number;
+    duration: number;
+    ease?: (t: number) => number;
+};
+declare class AnimatedTiming {
+    private value;
+    private config;
+    private _startTime;
+    private _startValue;
+    private _onEnd?;
+    private _next;
+    constructor(value: AnimatedValue, config: TimingConfig);
+    private get _ease();
+    start(onEnd?: Function): this;
+    stop(): this;
+    promise(): Promise<unknown>;
+    private _loop;
+}
+declare function timing(value: AnimatedValue, config: TimingConfig): AnimatedTiming;
+declare const Easing: {
+    linear(t: number): number;
+    ease(t: number): number;
+    /**
+     * Runs an easing function forwards.
+     */
+    in(easing?: (t: number) => number): (t: number) => number;
+    /**
+     * Runs an easing function backwards.
+     */
+    out(easing?: (t: number) => number): (t: number) => number;
+    /**
+     * Makes any easing function symmetrical. The easing function will run
+     * forwards for half of the duration, then backwards for the rest of the
+     * duration.
+     */
+    inOut(easing?: (t: number) => number): (t: number) => number;
+    bounce(t: number): number;
+    elastic(bounciness?: number): (t: number) => number;
+};
+
+type TouchableProps = {
+    onPress: Function;
+    onPressIn?: Function;
+    onPressOut?: Function;
+    activeOpacity?: number;
+} & BaseProps;
+declare class Touchable extends React.Component<TouchableProps> {
+    static defaultProps: {
+        activeOpacity: number;
+    };
+    _style: {
+        opacity: AnimatedValue;
+        animated: boolean;
+    };
+    private _start?;
+    private _tid;
+    private _onTouchStart;
+    private _onTouchEnd;
+    render(): React.ReactElement<{
+        style: any[];
+        onPress: Function;
+        onPressIn?: Function;
+        onPressOut?: Function;
+        activeOpacity?: number;
+        children?: React.ReactNode;
+        cache?: string | boolean;
+        forceCache?: boolean;
+        onTouchStart: (e: RevasTouchEvent) => void;
+        onTouchEnd: (e: RevasTouchEvent) => void;
+    }, string | React.JSXElementConstructor<any>>;
+}
+
+type RevasScrollEventType = 'start' | 'scroll' | 'end' | 'none';
+interface RevasScrollEvent {
+    type: RevasScrollEventType;
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    timestamp: number;
+    tid: string;
+}
+
+type ScrollViewOffset = {
+    x?: number;
+    y?: number;
+};
+type ScrollViewProps = {
+    horizontal?: boolean;
+    onScroll?: (e: RevasScrollEvent) => any;
+    onScrollStart?: (e: RevasScrollEvent) => any;
+    onScrollEnd?: (e: RevasScrollEvent) => any;
+    paging?: boolean | number;
+    offset?: ScrollViewOffset;
+} & NodeProps;
+declare class ScrollView extends React.Component<ScrollViewProps> {
+    private _height;
+    private _contentHeight;
+    private _width;
+    private _contentWidth;
+    private _innerStyle;
+    private _offset;
+    private _scroller;
+    componentWillUnmount(): void;
+    private _onLayout;
+    private _onContentLayout;
+    private _checkLayout;
+    render(): React.ReactElement<{
+        onLayout: (frame: Frame) => void;
+        onScroll?: (e: RevasScrollEvent) => any;
+        onScrollStart?: (e: RevasScrollEvent) => any;
+        onScrollEnd?: (e: RevasScrollEvent) => any;
+        paging?: boolean | number;
+        onTouchStart?: RevasTouchEventListener;
+        onTouchMove?: RevasTouchEventListener;
+        onTouchEnd?: RevasTouchEventListener;
+        pointerEvents?: "auto" | "none" | "box-none";
+        $ready?: boolean;
+        style?: any | any[];
+        cache?: string | boolean;
+        forceCache?: boolean;
+    }, string | React.JSXElementConstructor<any>>;
+}
+
+type ListViewProps<T = any> = {
+    data: T[];
+    renderItem: (item: T, index: number, data: T[]) => React.ReactNode;
+    itemHeight: number;
+} & ScrollViewProps;
+declare class ListView extends React.Component<ListViewProps<any>> {
+    state: {
+        start: number;
+        end: number;
+    };
+    private _height;
+    componentDidMount(): void;
+    private checkVisible;
+    private _onScroll;
+    private _onLayout;
+    renderItem: (item: any, i: number) => React.FunctionComponentElement<React.FragmentProps>;
+    render(): React.CElement<ScrollViewProps, ScrollView>;
+}
+
+type LinearGradientProps = {
+    start?: {
+        x: number;
+        y: number;
+    };
+    end?: {
+        x: number;
+        y: number;
+    };
+    colors: string[];
+} & NodeProps;
+declare function LinearGradient(props: LinearGradientProps): React.ReactElement<{
+    style: any[];
+    customDrawer: typeof drawGradient;
+    start?: {
+        x: number;
+        y: number;
+    };
+    end?: {
+        x: number;
+        y: number;
+    };
+    colors: string[];
+    onTouchStart?: RevasTouchEventListener;
+    onTouchMove?: RevasTouchEventListener;
+    onTouchEnd?: RevasTouchEventListener;
+    onLayout?: (frame: Frame) => any;
+    pointerEvents?: "auto" | "none" | "box-none";
+    $ready?: boolean;
+    children?: React.ReactNode;
+    cache?: string | boolean;
+    forceCache?: boolean;
+}, string | React.JSXElementConstructor<any>>;
+declare function drawGradient(canvas: RevasCanvas, node: Node): void;
+
+interface AppContextType {
+    clientWidth: number;
+    clientHeight: number;
+    deviceRatio: number;
+    canvas?: RevasCanvas;
+    RTL?: boolean;
+}
+declare const AppContext: React.Context<AppContextType>;
+declare function withContext<T>(comp: T): T;
+declare function Root(props: AppContextType): React.FunctionComponentElement<React.ProviderProps<AppContextType>>;
+
+declare class Container {
+    private _ready;
+    private _next;
+    private _reflow;
+    private _root?;
+    get canvas(): RevasCanvas | void;
+    get width(): number;
+    get height(): number;
+    get scale(): number;
+    setRoot(root?: Node<AppContextType>): void;
+    handleTouch: (evt: RevasTouchEvent) => void;
+    draw: (reflow?: boolean) => void;
+    private ready;
+}
+
+declare const RevasReconciler: react_reconciler.Reconciler<Container, Node<any>, never, unknown, Node<any>>;
+
+declare function noop(): any;
+declare const EMPTY_OBJECT: any;
+declare const EMPTY_ARRAY: any[];
+declare function flatten(array: any[]): any[];
+declare const now: () => number;
+declare function applyAnimated(style: any, callback?: Function): any;
+declare function getMergedStyleFromNode(node: Node, callback?: Function): any;
+declare function getFrameFromNode(node: Node): Frame;
+declare function sortByZIndexAscending(a: Node, b: Node): number;
+declare function clamp(n: number, min: number, max: number): number;
+declare function getChars(str: string): readonly string[];
+declare function getWords(str: string): readonly string[];
+declare function setShadow(canvas: RevasCanvas, color: string, x?: number, y?: number, blur?: number): () => void;
+declare function pushOpacity(canvas: RevasCanvas, opacity: number): typeof noop;
+type RevasAdapter = {
+    createImage: () => HTMLImageElement;
+    createOffscreenCanvas?: (width: number, height: number) => RevasCanvas;
+    resetOffscreenCanvas?: (ctx: RevasCanvas, width: number, height: number) => RevasCanvas;
+};
+declare const adapter: RevasAdapter;
+
+export { AnimatedInterpolate, AnimatedNode, AnimatedTiming, AnimatedValue, AppContext, type AppContextType, type BaseProps, Container, EMPTY_ARRAY, EMPTY_OBJECT, Easing, Frame, ImageView as Image, type ImageViewProps, LinearGradient, type LinearGradientProps, ListView, type ListViewProps, Node, type NodeProps, type RevasAdapter, RevasCanvas, type RevasScrollEvent, type RevasScrollEventType, type RevasTouch, type RevasTouchEvent, type RevasTouchEventListener, type RevasTouchType, Root, ScrollView, type ScrollViewOffset, type ScrollViewProps, Text, type TextProps, type TimingConfig, Touchable, type TouchableProps, Transform, View, adapter, applyAnimated, clamp, flatten, getChars, getFrameFromNode, getMergedStyleFromNode, getWords, noop, now, pushOpacity, RevasReconciler as renderer, setShadow, sortByZIndexAscending, timing, withContext };

package/dist/revas-common.js

@@ -0,0 +1,3 @@
+export { AnimatedInterpolate, AnimatedNode, AnimatedTiming, AnimatedValue, AppContext, Container, EMPTY_ARRAY, EMPTY_OBJECT, Easing, Frame, ImageView as Image, LinearGradient, ListView, Node, RevasCanvas, Root, ScrollView, Text, Touchable, Transform, View, adapter, applyAnimated, clamp, flatten, getChars, getFrameFromNode, getMergedStyleFromNode, getWords, noop, now, pushOpacity, reconciler_default as renderer, setShadow, sortByZIndexAscending, timing, withContext } from './chunk-JPUKLNW3.js';
+//# sourceMappingURL=revas-common.js.map
+//# sourceMappingURL=revas-common.js.map

package/dist/revas-common.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"revas-common.js"}