Oak-Team
/
oak-frontend-base
13
0
Fork 0
Code Issues 2 Pull Requests Packages Projects Releases 37 Wiki Activity

fix polyfill.ts

This commit is contained in:
梁朝伟 2022-04-29 14:08:43 +08:00
parent 0f8b47c4fc
commit b3b53f93ce
18 changed files with 271 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/aspects/crud.d.ts vendored Normal file
View File

@ -0,0 +1,11 @@
import { OperateParams, EntityDict, Context } from 'oak-domain/lib/types';
export declare function operate<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>>(options: {
entity: T;
operation: ED[T]['Operation'] | ED[T]['Operation'][];
params?: OperateParams;
}, context: Cxt): Promise<import("oak-domain/lib/types").OperationResult | Promise<import("oak-domain/lib/types").OperationResult>[]>;
export declare function select<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>>(options: {
entity: T;
selection: ED[T]['Selection'];
params?: object;
}, context: Cxt): Promise<import("oak-domain/lib/types").SelectionResult<ED[T]["Schema"], ED[T]["Selection"]["data"]>>;

6
src/aspects/index.d.ts vendored Normal file
View File

@ -0,0 +1,6 @@
import { operate, select } from './crud';
declare const aspectDict: {
operate: typeof operate;
select: typeof select;
};
export default aspectDict;

18
src/cacheStore/CacheStore.d.ts vendored Normal file
View File

@ -0,0 +1,18 @@
import { EntityDict, OperationResult } from 'oak-domain/lib/types/Entity';
import { StorageSchema } from "oak-domain/lib/types/Storage";
import { Checker, Context } from 'oak-domain/lib/types';
import { TreeStore } from 'oak-memory-tree-store';
export declare class CacheStore<ED extends EntityDict, Cxt extends Context<ED>> extends TreeStore<ED, Cxt> {
private executor;
constructor(storageSchema: StorageSchema<ED>, contextBuilder: () => Cxt, initialData?: {
[T in keyof ED]?: {
[ID: string]: ED[T]['OpSchema'];
};
});
operate<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: Cxt, params?: Object): Promise<OperationResult>;
select<T extends keyof ED, S extends ED[T]['Selection']>(entity: T, selection: S, context: Cxt, params?: Object): Promise<{
result: import("oak-domain/lib/types").SelectRowShape<ED[T]["Schema"], ED[T]["Selection"]["data"]>[];
}>;
count<T extends keyof ED>(entity: T, selection: Omit<ED[T]['Selection'], 'data' | 'sorter' | 'action'>, context: Cxt, params?: Object): Promise<number>;
registerChecker<T extends keyof ED>(checker: Checker<ED, T, Cxt>): void;
}

23
src/debugStore/debugStore.d.ts vendored Normal file
View File

@ -0,0 +1,23 @@
import { EntityDict, OperationResult, Context, RowStore } from "oak-domain/lib/types";
import { TreeStore } from 'oak-memory-tree-store';
import { StorageSchema, Trigger, Checker } from "oak-domain/lib/types";
export declare class DebugStore<ED extends EntityDict, Cxt extends Context<ED>> extends TreeStore<ED, Cxt> {
private executor;
constructor(storageSchema: StorageSchema<ED>, contextBuilder: (store: RowStore<ED, Cxt>) => Cxt, initialData?: {
[T in keyof ED]?: {
[ID: string]: ED[T]['OpSchema'];
};
}, initialStat?: {
create: number;
update: number;
remove: number;
commit: number;
});
operate<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: Cxt, params?: Object): Promise<OperationResult>;
select<T extends keyof ED, S extends ED[T]['Selection']>(entity: T, selection: S, context: Cxt, params?: Object): Promise<{
result: import("oak-domain/lib/types").SelectRowShape<ED[T]["Schema"], ED[T]["Selection"]["data"]>[];
}>;
count<T extends keyof ED>(entity: T, selection: Omit<ED[T]['Selection'], 'data' | 'sorter' | 'action'>, context: Cxt, params?: Object): Promise<number>;
registerTrigger<T extends keyof ED>(trigger: Trigger<ED, T, Cxt>): void;
registerChecker<T extends keyof ED>(checker: Checker<ED, T, Cxt>): void;
}

5
src/debugStore/index.d.ts vendored Normal file
View File

@ -0,0 +1,5 @@
import { DebugStore } from './debugStore';
import { Checker, Trigger, StorageSchema, FormCreateData, Context, EntityDict, RowStore } from "oak-domain/lib/types";
export declare function createDebugStore<ED extends EntityDict, Cxt extends Context<ED>>(storageSchema: StorageSchema<ED>, createContext: (store: RowStore<ED, Cxt>) => Cxt, triggers?: Array<Trigger<ED, keyof ED, Cxt>>, checkers?: Array<Checker<ED, keyof ED, Cxt>>, initialData?: {
[T in keyof ED]?: Array<FormCreateData<ED[T]['OpSchema']>>;
}): DebugStore<ED, Cxt>;

20
src/features/cache.d.ts vendored Normal file
View File

@ -0,0 +1,20 @@
import { StorageSchema, EntityDict, OperateParams, OpRecord, Aspect, Checker, RowStore, Context, OperationResult } from 'oak-domain/lib/types';
import { Feature } from '../types/Feature';
import { CacheStore } from '../cacheStore/CacheStore';
export declare class Cache<ED extends EntityDict, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>> extends Feature<ED, Cxt, AD> {
cacheStore: CacheStore<ED, Cxt>;
createContext: (store: RowStore<ED, Cxt>) => Cxt;
private syncEventsCallbacks;
constructor(storageSchema: StorageSchema<ED>, createContext: (store: RowStore<ED, Cxt>) => Cxt, checkers?: Array<Checker<ED, keyof ED, Cxt>>);
refresh<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], params?: object): OperationResult;
sync(records: OpRecord<ED>[]): Promise<void>;
operate<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], commit?: boolean, params?: OperateParams): Promise<OperationResult>;
get<T extends keyof ED>(options: {
entity: T;
selection: ED[T]['Selection'];
params?: object;
}): Promise<import("oak-domain/lib/types").SelectRowShape<ED[T]["Schema"], ED[T]["Selection"]["data"]>[]>;
judgeRelation(entity: keyof ED, attr: string): string | 0 | 1 | 2 | string[];
bindOnSync(callback: (opRecords: OpRecord<ED>[]) => Promise<void>): void;
unbindOnSync(callback: (opRecords: OpRecord<ED>[]) => Promise<void>): void;
}

11
src/features/index.d.ts vendored Normal file
View File

@ -0,0 +1,11 @@
import { Aspect, Checker, Context, EntityDict, RowStore } from 'oak-domain/lib/types';
import { Cache } from './cache';
import { Location } from './location';
import { RunningNode } from './node';
import { StorageSchema } from 'oak-domain/lib/types/Storage';
export declare function initialize<ED extends EntityDict, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>>(storageSchema: StorageSchema<ED>, createContext: (store: RowStore<ED, Cxt>) => Cxt, checkers?: Array<Checker<ED, keyof ED, Cxt>>): BasicFeatures<ED, Cxt, AD>;
export declare type BasicFeatures<ED extends EntityDict, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>> = {
cache: Cache<ED, Cxt, AD>;
location: Location;
runningNode: RunningNode<ED, Cxt, AD>;
};

6
src/features/location.d.ts vendored Normal file
View File

@ -0,0 +1,6 @@
import { EntityDict, Aspect, Context } from 'oak-domain/lib/types';
import { Feature } from '../types/Feature';
export declare class Location extends Feature<EntityDict, Context<EntityDict>, Record<string, Aspect<EntityDict, Context<EntityDict>>>> {
get(): void;
refresh(): void;
}

52
src/features/node.d.ts vendored Normal file
View File

@ -0,0 +1,52 @@
import { DeduceFilter, DeduceUpdateOperation, EntityDict, OpRecord } from 'oak-domain/lib/types/Entity';
import { Aspect, Context } from 'oak-domain/lib/types';
import { Feature } from '../types/Feature';
import { Cache } from './cache';
import { StorageSchema } from 'oak-domain/lib/types/Storage';
import { Pagination } from '../types/Pagination';
export declare class Node<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>> {
protected entity: T;
protected fullPath: string;
protected schema: StorageSchema<ED>;
protected projection?: ED[T]['Selection']['data'];
protected parent?: Node<ED, keyof ED, Cxt, AD>;
protected action?: ED[T]['Action'];
protected dirty: boolean;
protected updateData?: DeduceUpdateOperation<ED[T]['OpSchema']>['data'];
protected cache: Cache<ED, Cxt, AD>;
protected needReGetValue: boolean;
protected refreshing: boolean;
private refreshFn?;
constructor(entity: T, fullPath: string, schema: StorageSchema<ED>, cache: Cache<ED, Cxt, AD>, projection?: ED[T]['Selection']['data'], parent?: Node<ED, keyof ED, Cxt, AD>, action?: ED[T]['Action']);
getSubEntity(path: string): {
entity: keyof ED;
isList: boolean;
};
getEntity(): T;
setUpdateData(attr: string, value: any): void;
setDirty(): void;
isDirty(): boolean;
getParent(): Node<ED, keyof ED, Cxt, AD> | undefined;
getProjection(): NonNullable<ED[T]["Selection"]["data"]>;
registerValueSentry(refreshFn: (opRecords: OpRecord<ED>[]) => Promise<void>): void;
unregisterValueSentry(): void;
}
export declare class RunningNode<ED extends EntityDict, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>> extends Feature<ED, Cxt, AD> {
private cache;
private schema?;
private root;
constructor(cache: Cache<ED, Cxt, AD>);
createNode<T extends keyof ED>(path: string, parent?: string, entity?: T, isList?: boolean, isPicker?: boolean, projection?: ED[T]['Selection']['data'], id?: string, pagination?: Pagination, filters?: ED[T]['Selection']['filter'][], sorter?: ED[T]['Selection']['sorter']): Promise<keyof ED>;
destroyNode(path: string): Promise<void>;
setStorageSchema(schema: StorageSchema<ED>): void;
private applyOperation;
get(path: string): Promise<(Partial<ED[keyof ED]["Schema"]> | undefined)[]>;
isDirty(path: string): Promise<boolean>;
private findNode;
protected setUpdateDataInner(path: string, attr: string, value: any): Promise<void>;
setUpdateData(path: string, attr: string, value: any): Promise<void>;
setMultipleData(path: string, data: [string, any][]): Promise<void>;
refresh(path: string): Promise<void>;
setFilters<T extends keyof ED>(path: string, filters: DeduceFilter<ED[T]['Schema']>[], refresh?: boolean): Promise<void>;
execute(path: string, action?: string, isTry?: boolean): Promise<void>;
}

5
src/index.d.ts vendored Normal file
View File

@ -0,0 +1,5 @@
import { initialize as InitializeWechatMp, MakeOakComponent, MakeOakPage } from './platforms/wechatMp';
export { InitializeWechatMp, MakeOakComponent, MakeOakPage, };
export * from './types/Feature';
export * from './types/ExceptionRoute';
export { BasicFeatures } from './features';

12
src/initialize.d.ts vendored Normal file
View File

@ -0,0 +1,12 @@
import { Aspect, Checker, Trigger, StorageSchema, Context, RowStore } from "oak-domain/lib/types";
import { EntityDict } from 'oak-domain/lib/types/Entity';
import { Feature, subscribe } from './types/Feature';
import { BasicFeatures } from './features';
export declare function initialize<ED extends EntityDict, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>, FD extends Record<string, Feature<ED, Cxt, AD>>>(storageSchema: StorageSchema<ED>, createFeatures: (basicFeatures: BasicFeatures<ED, Cxt, AD>) => FD, createContext: (store: RowStore<ED, Cxt>) => Cxt, triggers?: Array<Trigger<ED, keyof ED, Cxt>>, checkers?: Array<Checker<ED, keyof ED, Cxt>>, aspectDict?: AD, initialData?: {
[T in keyof ED]?: Array<ED[T]['OpSchema']>;
}): {
subscribe: typeof subscribe;
features: BasicFeatures<ED, Cxt, AD> & FD;
};
export * from './types/Feature';
export * from './types/Pagination';

62
src/platforms/wechatMp/index.d.ts vendored Normal file
View File

@ -0,0 +1,62 @@
/// <reference types="types" />
import './polyfill';
import { Aspect, Checker, Context, DeduceFilter, EntityDict, RowStore, SelectionResult, StorageSchema, Trigger } from "oak-domain/lib/types";
import { Feature } from '../../types/Feature';
import { Pagination } from "../../types/Pagination";
import { BasicFeatures } from "../../features";
import { ExceptionRouters } from '../../types/ExceptionRoute';
declare type OakComponentOption<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>, FD extends Record<string, Feature<ED, Cxt, AD>>, Proj extends ED[T]['Selection']['data'], FormedData extends WechatMiniprogram.Component.DataOption> = {
entity: T;
formData: ($rows: SelectionResult<ED[T]['Schema'], Proj>['result'], features: BasicFeatures<ED, Cxt, AD> & FD) => FormedData;
};
interface OakPageOption<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>, FD extends Record<string, Feature<ED, Cxt, AD>>, Proj extends ED[T]['Selection']['data'], FormedData extends WechatMiniprogram.Component.DataOption> {
entity: T;
path: string;
isList: boolean;
projection: Proj;
parent?: string;
append?: boolean;
pagination?: Pagination;
filters?: Array<ED[T]['Selection']['filter']>;
sorter?: ED[T]['Selection']['sorter'];
formData: ($rows: SelectionResult<ED[T]['Schema'], Proj>['result'], features: BasicFeatures<ED, Cxt, AD> & FD) => FormedData;
}
declare type OakComponentMethods<ED extends EntityDict, T extends keyof ED> = {
setUpdateData: (input: WechatMiniprogram.Input) => void;
callPicker: (touch: WechatMiniprogram.Touch) => void;
setFilters: (filters: DeduceFilter<ED[T]['Schema']>[]) => void;
execute: (touch: WechatMiniprogram.Touch) => void;
navigateTo: (...options: Parameters<typeof wx.navigateTo>) => ReturnType<typeof wx.navigateTo>;
};
declare type OakPageMethods<ED extends EntityDict, T extends keyof ED> = OakComponentMethods<ED, T> & {
reRender: (extra?: any) => Promise<void>;
refresh: (extra?: any) => Promise<void>;
onPullDownRefresh: () => Promise<void>;
subscribed?: () => void;
subscribe: () => void;
unsubscribe: () => void;
setForeignKey: (id: string, goBackDelta?: number) => Promise<void>;
onForeignKeyPicked: (touch: WechatMiniprogram.Touch) => void;
};
declare type OakComponentInstanceInnerProperties<ED extends EntityDict, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>, FD extends Record<string, Feature<ED, Cxt, AD>>> = {
features: BasicFeatures<ED, Cxt, AD> & FD;
};
declare type OakPageInstanceProperties<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>, FD extends Record<string, Feature<ED, Cxt, AD>>> = OakPageMethods<ED, T> & OakComponentInstanceInnerProperties<ED, Cxt, AD, FD>;
export declare function initialize<ED extends EntityDict, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>, FD extends Record<string, Feature<ED, Cxt, AD>>>(storageSchema: StorageSchema<ED>, createFeatures: (basicFeatures: BasicFeatures<ED, Cxt, AD>) => FD, createContext: (store: RowStore<ED, Cxt>) => Cxt, exceptionRouters?: ExceptionRouters, triggers?: Array<Trigger<ED, keyof ED, Cxt>>, checkers?: Array<Checker<ED, keyof ED, Cxt>>, aspectDict?: AD, initialData?: {
[T in keyof ED]?: Array<ED[T]['OpSchema']>;
}): {
OakPage: <T extends keyof ED, D extends WechatMiniprogram.Component.DataOption, P extends WechatMiniprogram.Component.PropertyOption, M extends WechatMiniprogram.Component.MethodOption, Proj extends ED[T]["Selection"]["data"], IS extends WechatMiniprogram.IAnyObject = {}, FormedData extends WechatMiniprogram.Component.DataOption = {}>(options: OakPageOption<ED, T, Cxt, AD, FD, Proj, FormedData>, componentOptions?: WechatMiniprogram.Component.Options<D, P, M, IS & OakComponentMethods<ED, T> & {
reRender: (extra?: any) => Promise<void>;
refresh: (extra?: any) => Promise<void>;
onPullDownRefresh: () => Promise<void>;
subscribed?: (() => void) | undefined;
subscribe: () => void;
unsubscribe: () => void;
setForeignKey: (id: string, goBackDelta?: number | undefined) => Promise<void>;
onForeignKeyPicked: (touch: WechatMiniprogram.Touch<WechatMiniprogram.IAnyObject, WechatMiniprogram.TouchDetail, WechatMiniprogram.IAnyObject, WechatMiniprogram.IAnyObject, WechatMiniprogram.IAnyObject>) => void;
} & OakComponentInstanceInnerProperties<ED, Cxt, AD, FD>, true>) => string;
OakComponent: <T_1 extends string | number, D_1 extends WechatMiniprogram.Component.DataOption, P_1 extends WechatMiniprogram.Component.PropertyOption, M_1 extends WechatMiniprogram.Component.MethodOption, Proj_1 extends ED[T_1]["Selection"]["data"], IS_1 extends WechatMiniprogram.IAnyObject = {}, FormedData_1 extends WechatMiniprogram.Component.DataOption = {}>(options: OakComponentOption<ED, T_1, Cxt, AD, FD, Proj_1, FormedData_1>, componentOptions?: WechatMiniprogram.Component.Options<D_1, P_1, M_1, IS_1, false>) => string;
};
export declare type MakeOakPage<ED extends EntityDict, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>, FD extends Record<string, Feature<ED, Cxt, AD>>> = <T extends keyof ED, D extends WechatMiniprogram.Component.DataOption, P extends WechatMiniprogram.Component.PropertyOption, M extends WechatMiniprogram.Component.MethodOption, Proj extends ED[T]['Selection']['data'], IS extends WechatMiniprogram.IAnyObject = {}, FormedData extends WechatMiniprogram.Component.DataOption = {}>(options: OakPageOption<ED, T, Cxt, AD, FD, Proj, FormedData>, componentOptions: WechatMiniprogram.Component.Options<D & FormedData, P, M, IS & OakPageInstanceProperties<ED, T, Cxt, AD, FD>, true>) => string;
export declare type MakeOakComponent<ED extends EntityDict, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>, FD extends Record<string, Feature<ED, Cxt, AD>>> = <T extends keyof ED, D extends WechatMiniprogram.Component.DataOption, P extends WechatMiniprogram.Component.PropertyOption, M extends WechatMiniprogram.Component.MethodOption, Proj extends ED[T]['Selection']['data'], IS extends WechatMiniprogram.IAnyObject = {}, FormedData extends WechatMiniprogram.Component.DataOption = {}>(options: OakComponentOption<ED, T, Cxt, AD, FD, Proj, FormedData>, componentOptions: WechatMiniprogram.Component.Options<D & FormedData, P, M, IS>) => string;
export {};

1
src/platforms/wechatMp/polyfill.d.ts vendored Normal file
View File

@ -0,0 +1 @@
declare function getRandomValues(length: number): Promise<Uint8Array>;

1
src/platforms/wechatMp/polyfill.ts
View File

@ -27,3 +27,4 @@ Object.assign(global, {
getRandomValues,
process: {},
});
export {}

4
src/types/AspectProxy.d.ts vendored Normal file
View File

@ -0,0 +1,4 @@
import { EntityDict, Aspect, Context } from "oak-domain/lib/types";
export declare type AspectProxy<ED extends EntityDict, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>> = {
[K in keyof AD]: (p: Parameters<AD[K]>[0]) => ReturnType<AD[K]>;
};

8
src/types/ExceptionRoute.d.ts vendored Normal file
View File

@ -0,0 +1,8 @@
import { OakException } from "oak-domain/lib/types";
export interface ExceptionHandler {
hidden?: true;
level?: 'warning' | 'error';
handler?: (error: OakException) => void;
router?: string;
}
export declare type ExceptionRouters = Array<[new (...args: any) => OakException, ExceptionHandler]>;

19
src/types/Feature.d.ts vendored Normal file
View File

@ -0,0 +1,19 @@
import { EntityDict, Aspect, Context } from 'oak-domain/lib/types';
import { AspectProxy } from './AspectProxy';
import baseAspectDict from '../aspects';
export declare abstract class Feature<ED extends EntityDict, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>> {
private aspectProxy?;
protected getAspectProxy(): NonNullable<AspectProxy<ED, Cxt, AD & {
operate: typeof import("../aspects/crud").operate;
select: typeof import("../aspects/crud").select;
}>>;
setAspectProxy(aspectProxy: AspectProxy<ED, Cxt, AD & typeof baseAspectDict>): void;
}
export declare function subscribe(callback: () => any): () => void;
/**
* 方法注解，使函数调用最后一层堆栈时唤起所有登记的回调
* @param target
* @param propertyName
* @param descriptor
*/
export declare function Action(target: any, propertyName: string, descriptor: TypedPropertyDescriptor<any>): void;

7
src/types/Pagination.d.ts vendored Normal file
View File

@ -0,0 +1,7 @@
export interface Pagination {
step: number;
append: boolean;
indexFrom: number;
more: boolean;
total?: number;
}