@shijiu/jsview-vue 2.1.482-test.0 → 2.2.128

package/bin/types/JsViewEngineWidget/MetroWidget/RenderItem.d.ts

@@ -0,0 +1,46 @@
+import type { Ref } from "vue";
+import { TemplateItem } from "../TemplateParser/MetroTemplate";
+interface RenderItemStyle {
+    zIndex: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+interface ItemConfig {
+    focusZIndex: number;
+    normalZIndex: number;
+    itemSlide: number;
+    permanent: boolean;
+}
+export declare class RenderItem {
+    private divMountedCallback;
+    customerData: object;
+    templateInfo: TemplateItem;
+    renderStyle: RenderItemStyle;
+    itemConfig: ItemConfig;
+    mounted: Ref<boolean>;
+    touchInit: boolean;
+    rootDiv: HTMLDivElement | null;
+    enableTap: boolean;
+    private customerCallbackMap;
+    private onRef;
+    readonly registerObj: object;
+    readonly query: object;
+    constructor(templateInfo: TemplateItem, customerData: object, renderStyle: RenderItemStyle, itemConfig: ItemConfig, onRef: () => void, query: object);
+    get id(): number;
+    get index(): number;
+    divRef: (ele: HTMLDivElement | null) => void;
+    slotRef: (ele: object | null) => void;
+    register(name: string, callback: Function): void;
+    unregister(name: string): void;
+    onFocus(rect: object): boolean;
+    onBlur(): boolean;
+    readonly onTap: import("vue").ComputedRef<(() => boolean) | null>;
+    onClick(): boolean;
+    onWidgetEdge(rect: object): boolean;
+    addDivMountedListener(cbk: (div: HTMLDivElement) => void): () => void;
+    private onDivMounted;
+    private onDivUnmounted;
+}
+export {};

package/bin/types/JsViewEngineWidget/MetroWidget/Slide.d.ts

@@ -0,0 +1,21 @@
+export interface TargetRectInfo {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    frameCount: number;
+}
+export declare class RectCache {
+    private preRect;
+    private curRect;
+    cache(rect: TargetRectInfo): void;
+    cacheManually(): void;
+    getCurRect(): TargetRectInfo | null;
+    getPreRect(): TargetRectInfo | null;
+    updatePre(key: "left" | "top" | "width" | "height", value: number): void;
+    clean(): void;
+}
+export declare const getDirectionByRect: (curRect: TargetRectInfo, preRect: TargetRectInfo) => {
+    horizontal: number;
+    vertical: number;
+};

package/bin/types/JsViewEngineWidget/MetroWidget/SlotComponent.vue.d.ts

@@ -0,0 +1,48 @@
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default: (_: {}) => any;
+    };
+});
+export default _default;

package/bin/types/JsViewEngineWidget/MetroWidget/VisibleInfo.d.ts

@@ -0,0 +1,16 @@
+export declare class VisibleInfo {
+    private _start;
+    range: number;
+    padding: {
+        start: number;
+        end: number;
+    };
+    private _startMax;
+    set start(value: number);
+    get start(): number;
+    get end(): number;
+    get startMax(): number;
+    get startWithPadding(): number;
+    get endWithPadding(): number;
+    copy(): VisibleInfo;
+}

package/bin/types/JsViewEngineWidget/MetroWidget/WidgetRectInfo.d.ts

@@ -0,0 +1,17 @@
+export interface Padding {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export declare class WidgetRectInfo {
+    private mWidth;
+    private mHeight;
+    private mPadding;
+    constructor(w: number, h: number, padding: any);
+    get width(): number;
+    get height(): number;
+    get contentWidth(): number;
+    get contentHeight(): number;
+    get padding(): Padding;
+}

package/bin/types/JsViewEngineWidget/RangeModel.d.ts

@@ -0,0 +1,162 @@
+export class RangesModel {
+    /**
+     * 范围计算模型（用于复数范围比较）<br>
+     *     例如：范围[-10, -2] + [2, 10] 与 范围[-8,-1] + [1, 8]进行交集计算<br>
+     *         再如：范围[-10, -2] + [2, 10] 与 范围 [-8, 8]进行排除运算
+     *
+     * @public
+     * @constructor Forge.RangesModel
+     * @param {int} start 范围的初始起点
+     * @param {int} end 范围的初始终点
+     * */
+    constructor(start: int, end: int);
+    /**
+     * 范围数组
+     * @public
+     * @name Forge.RangeModel#Ranges
+     * @type {Forge.SingleRangeModel[]}
+     */
+    public Ranges: Forge.SingleRangeModel[];
+    /**
+     * 范围合并
+     *
+     * @public
+     * @func Merge
+     * @memberof Forge.RangesModel
+     * @instance
+     * @param {Forge.SingleRangeModel} merge_from
+     * */
+    public Merge(merge_from: Forge.SingleRangeModel): void;
+    /**
+     * 范围排除
+     *
+     * @public
+     * @func Exclude
+     * @memberof Forge.RangesModel
+     * @instance
+     * @param {Forge.SingleRangeModel} exclude_range
+     * */
+    public Exclude(exclude_range: Forge.SingleRangeModel): void;
+    /**
+     * 遍历范围数组的每个位置
+     *
+     * @public
+     * @func ForEach
+     * @memberof Forge.RangeModel
+     * @instance
+     * @param {function} callback  对于每个位置的回调处理，参数（int:当前位置值）。
+     * @param {boolean} invert     是否是倒序进行遍历，默认为正序
+     * */
+    public ForEach(callback: Function, invert: boolean): void;
+    /**
+     * 判断与另一个 RangesModel 是否相交
+     *
+     * @public
+     * @func IsInterAct
+     * @memberof Forge.RangesModel
+     * @instance
+     * @param {Forge.RangesModel} ranges     比较对象
+     * @return {Boolean} 是否相交
+     * */
+    public IsInterAct(ranges: Forge.RangesModel): boolean;
+    /**
+     * 排除 另一个 RangesModel
+     *
+     * @public
+     * @func ExcludeRanges
+     * @memberof Forge.RangesModel
+     * @instance
+     * @param {Forge.RangesModel} ranges     比较对象
+     * */
+    public ExcludeRanges(ranges: Forge.RangesModel): void;
+    IsEmpty(): boolean;
+    Clone(): RangesModel;
+}
+export class SingleRangeModel {
+    /**
+     * 范围计算模型（RangesModel数组中的单元模型）
+     *
+     * @public
+     * @constructor Forge.SingleRangeModel
+     * @param {int} start 范围的初始起点
+     * @param {int} end 范围的初始终点
+     * */
+    constructor(start: int, end: int);
+    /**
+     * 范围的起始位置
+     * @public
+     * @name Forge.SingleRangeModel#Start
+     * @type {int}
+     */
+    public Start: int;
+    /**
+     * 范围的结束位置
+     * @public
+     * @name Forge.SingleRangeModel#End
+     * @type {int}
+     */
+    public End: int;
+    /**
+     * 与给定的单元范围进行合并
+     *
+     * @public
+     * @func Merge
+     * @memberof Forge.SingleRangeModel
+     * @instance
+     * @param {Forge.SingleRangeModel} merge_from 合并对象
+     * @return {boolean}  true:合并成功（有交集或者范围恰好衔接），false:合并失败
+     * */
+    public Merge(merge_from: Forge.SingleRangeModel): boolean;
+    /**
+     * 检查是否与给定单元范围有交集
+     *
+     * @public
+     * @func IsInterAct
+     * @memberof Forge.SingleRangeModel
+     * @instance
+     * @param {Forge.SingleRangeModel} rang  合并对象
+     * @return {boolean}  true:有交集，false:无交集
+     * */
+    public IsInterAct(range: any): boolean;
+    /**
+     * 排除指定单元范围
+     *
+     * @public
+     * @func Exclude
+     * @memberof Forge.SingleRangeModel
+     * @instance
+     * @param {Forge.SingleRangeModel} exclude 指定单元范围
+     * @return {Object}  {success(boolean):是否排除成功，如无交集则为false, <br>
+     *                   newSplitedRange(Forge.SingleRangeModel):进行排除后，被分离出来的后半段单元范围}
+     * */
+    public Exclude(exclude: Forge.SingleRangeModel): Object;
+    /**
+     * 范围是否空区域
+     *
+     * @public
+     * @func IsEmpty
+     * @memberof Forge.SingleRangeModel
+     * @instance
+     * @return {boolean} true:为空区域，false:不为空
+     * */
+    public IsEmpty(): boolean;
+    /**
+     * 将单元范围清成空区域
+     *
+     * @public
+     * @func Clear
+     * @memberof Forge.SingleRangeModel
+     * @instance
+     * */
+    public Clear(): void;
+    /**
+     * 复制单元范围
+     *
+     * @public
+     * @func Clone
+     * @memberof Forge.SingleRangeModel
+     * @instance
+     * @return {Forge.SingleRangeModel} 复制出的实例
+     * */
+    public Clone(): Forge.SingleRangeModel;
+}

package/bin/types/JsViewEngineWidget/TemplateParser/CommonMetroTemplate.d.ts

@@ -0,0 +1,37 @@
+import { MetroTemplate, TemplateItem, MeasureInfo } from "./MetroTemplate";
+declare class CommonMetroTemplate extends MetroTemplate {
+    private _FenceStack;
+    private _FenceEdge;
+    private _NotOccupiedEdgeList;
+    constructor(direction: Symbol, lineMax: number, pageSize: number, layoutType: string, supportHistoryPath: boolean);
+    calculateNeighborWhenAddStop(): void;
+    private _UpdateLastFenceEdge;
+    private _CheckIdsHasFocusable;
+    private _GetValidNeighborIndex;
+    private _FindFocusableNeighbor;
+    addItemInner(itemObj: MeasureInfo): TemplateItem;
+    /** get next item functions */
+    getNextItem(baseId: number, vOffset: number, hOffset: number, moveType: number): TemplateItem | null;
+    private getNextItemInner;
+    private _GetItemDistance;
+    private _GetTotalNeighbor;
+    private _GetNearestItem;
+    private _GetNextLoopItem;
+    private _GetNearLineItem;
+    updateItemSize(index: number, newSize: {
+        width: number;
+        height: number;
+    }): void;
+    static intersects(s0: number, e0: number, s1: number, e1: number): boolean;
+    static iterCount: number;
+    /** get visible item list functions */
+    getVisibleItemList(visibleStart: number, visibleEnd: number, baseId: number): [number, number];
+    /** neighbor calculate functions */
+    private _TryCalculateNeighborItem;
+    private _CalculateNeighborItem;
+    private _IfBlockedByOtherNeighbor;
+    private _CheckNeighborItemMatching;
+    private _FindNearestNeighbor;
+    private _TryUpdateItemNeighbor;
+}
+export { CommonMetroTemplate };

package/bin/types/JsViewEngineWidget/TemplateParser/Fence.d.ts

@@ -0,0 +1,58 @@
+interface GapInfo {
+    readonly GapStart: number;
+    readonly GapEnd: number;
+}
+declare class Fence {
+    /**
+     * MetroLayout用于计算使用区域的Fence(栅栏)
+     *
+     * @private
+     * @constructor _Fence
+     * @memberof Forge.MetroLayout
+     * @param {int} takenStartPos     栅栏使用区域的起始位置
+     * @param {int} width               栅栏使用区域的宽度
+     * @param {int} fenceWidth         栅栏的总宽度
+     * @param {int} offsetAhead        栅栏的横向位置
+     * */
+    private Gaps;
+    private FenceTotalWidth;
+    private AheadOffsetInner;
+    constructor(takenStartPos: number, width: number, fenceWidth: number, offsetAhead: number);
+    get AheadOffset(): number;
+    /**
+     * 查询栅栏是否能放下给定宽度的方块
+     *
+     * @public
+     * @func HasGapFor
+     * @memberof Forge.MetroLayout._Fence
+     * @instance
+     * @param {int} width
+     * @return {Object} 格式为{startPos: 栅栏空隙的起始位置}，null为没有能容下的空隙。
+     * */
+    HasGapFor(width: number): GapInfo | null;
+    /**
+     * 标记栅栏空隙被占用
+     *
+     * @public
+     * @func MarkGapUsed
+     * @memberof Forge.MetroLayout._Fence
+     * @instance
+     * @param {int} startPos       占用块的起始位置
+     * @param {int} width           占用快的宽度
+     * @return {int} 剩余栅栏的个数
+     * */
+    MarkGapUsed(startPos: number, width: number): number;
+    private SplitGap;
+    /**
+     * 标记栅栏空隙被占用
+     *
+     * @public
+     * @func Fork
+     * @memberof Forge.MetroLayout._Fence
+     * @instance
+     * @param {int} new_ahead_offset 新栅栏的起点位置
+     * @return {Forge.MetroLayout._Fence} 复制出来的Fence
+     * */
+    Fork(new_ahead_offset: number): Fence;
+}
+export { Fence, GapInfo };

package/bin/types/JsViewEngineWidget/TemplateParser/ListMetroTemplate.d.ts

@@ -0,0 +1,15 @@
+import { MetroTemplate, TemplateItem, MeasureInfo } from "./MetroTemplate";
+/** 单行/单列 */
+declare class ListMetroTemplate extends MetroTemplate {
+    constructor(direction: Symbol, lineMax: number, pageSize: number, layoutType: string);
+    calculateNeighborWhenAddStop(): void;
+    addItemInner(itemObj: MeasureInfo): TemplateItem;
+    private _addTemplateItem;
+    getNextItem(baseId: number, vOffset: number, hOffset: number, moveType: number): TemplateItem | null;
+    getVisibleItemList(visibleStart: number, visibleEnd: number, baseId: number): [number, number];
+    updateItemSize(index: number, newSize: {
+        width: number;
+        height: number;
+    }): void;
+}
+export { ListMetroTemplate };

package/bin/types/JsViewEngineWidget/TemplateParser/MetroTemplate.d.ts

@@ -0,0 +1,91 @@
+import { RectCache } from "../MetroWidget/Slide";
+interface NeighborInfo {
+    left: Array<number>;
+    top: Array<number>;
+    bottom: Array<number>;
+    right: Array<number>;
+}
+interface FindNextAnchor {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+interface TemplateItem {
+    id: number;
+    index: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    marginRight: number;
+    marginBottom: number;
+    focusable: boolean;
+    centerXPos: number;
+    centerYPos: number;
+    pageNumber: number;
+    pageHeadIndex: number;
+    neighborIndexList: NeighborInfo;
+    tmpNeighborIndexList: NeighborInfo;
+    pathHistory: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    findNextAnchor: FindNextAnchor | null;
+    layoutCache: RectCache;
+    uid?: string;
+}
+interface MeasureInfo {
+    left?: number;
+    top?: number;
+    width: number;
+    height: number;
+    marginRight?: number;
+    marginBottom?: number;
+    focusable?: boolean;
+    findNextAnchor?: FindNextAnchor | null;
+    itemSlide?: number;
+    permanent?: boolean;
+    zIndex?: number | object;
+    uid?: string;
+}
+declare abstract class MetroTemplate {
+    protected supportHistoryPath: boolean;
+    protected idsMap: Array<number>;
+    protected uidMap: Object;
+    templateList: Array<TemplateItem>;
+    readonly direction: Symbol;
+    readonly lineMax: number;
+    readonly pageSize: number;
+    readonly layoutType: string;
+    protected tailItemIndex: number;
+    private cachedLayoutRange;
+    constructor(direction: Symbol, lineMax: number, pageSize: number, layoutType: string, supportHistoryPath: boolean);
+    get size(): number;
+    get focusableSize(): number;
+    protected addTemplateItem(item: TemplateItem): void;
+    index2Id(index: number): number;
+    id2Index(id: number): number;
+    getItemById(id: number): TemplateItem | null;
+    getItemByIndex(index: number): TemplateItem | null;
+    getItemByUid(uid: string): TemplateItem | null;
+    abstract calculateNeighborWhenAddStop(): void;
+    abstract addItemInner(itemObj: MeasureInfo): TemplateItem;
+    addItem(itemObj: MeasureInfo): TemplateItem;
+    abstract getNextItem(baseId: number, hOffset: number, vOffset: number, moveType: number): TemplateItem | null;
+    abstract getVisibleItemList(visibleStart: number, visibleEnd: number, baseId: number): [number, number];
+    abstract updateItemSize(index: number, newSize: {
+        width: number;
+        height: number;
+    }): void;
+    getBoundingBoxSize(): {
+        width: number;
+        height: number;
+    };
+    getTailItemIndex(): number;
+    protected static getTemplateItem(itemObj: MeasureInfo): TemplateItem;
+    private static checkMeasureObject;
+}
+export { MeasureInfo, MetroTemplate, TemplateItem, };

package/bin/types/JsViewEngineWidget/TemplateParser/TemplateItemAdder.d.ts

@@ -0,0 +1,22 @@
+import { MetroTemplate, TemplateItem } from "./MetroTemplate";
+declare class TemplateItemAdder {
+    private _MetroTemplate;
+    private _Data;
+    private _PageRange;
+    private _MeasureFunc;
+    private _CurIndex;
+    private _CurPage;
+    private _SideEffect;
+    private _Key;
+    private _ID;
+    private _OnAddDone;
+    constructor(template_parser: MetroTemplate, data: Array<object>, measure_func: Function, page_range: number, side_effect: Function, id: number, onAddDone?: Function | null);
+    private addDataToTemplate;
+    tryAddItem(cur_item?: TemplateItem | null, page_num?: number): boolean;
+    tryAddItemByPosition(position: number): void;
+    tryAddItemByIndex(index: number): void;
+    tryAddItemById(id: number): void;
+    tryAddItemByUid(uid: string): void;
+    updateData(data: Array<object>): void;
+}
+export { TemplateItemAdder, };

package/bin/types/JsViewEngineWidget/TemplateParser/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./CommonMetroTemplate";
+export * from "./TemplateItemAdder";
+export * from "./ListMetroTemplate";
+export * from "./MetroTemplate";