@blueking/bk-weweb 0.0.1

package/typings/entry/script.d.ts

@@ -0,0 +1,22 @@
+import { BaseModel, IScriptOption } from '../typings';
+export declare class Script {
+    code: string;
+    async: boolean;
+    defer: boolean;
+    isModule: boolean;
+    url: string | undefined;
+    exportInstance?: any;
+    scoped: boolean;
+    fromHtml: boolean;
+    initial: boolean;
+    constructor({ code, async, defer, isModule, url, fromHtml, initial }: IScriptOption);
+    getCode(app?: BaseModel): Promise<string>;
+    excuteCode(app: BaseModel, needRelaceScriptElement?: boolean): Promise<HTMLScriptElement | Comment | undefined>;
+    transformCode(app: BaseModel): string;
+    executeSourceScript(scriptElement: HTMLScriptElement, scopedCode: string): void;
+    executeMemoryScript(app: BaseModel, scopedCode: string): void;
+}
+export declare function shouldSkipProperty(global: Window, p: any): boolean;
+export declare function getGlobalProp(global: Window, useFirstGlobalProp?: boolean): string | undefined;
+export declare function noteGlobalProps(global: Window): string | undefined;
+export declare function execAppScripts(app: BaseModel): Promise<void>;

package/typings/entry/style.d.ts

@@ -0,0 +1,22 @@
+import { BaseModel, IStyleOption } from '../typings';
+export declare class Style {
+    scopedCode: string;
+    code: string;
+    prefetch: boolean;
+    preload: boolean;
+    url: string | undefined;
+    scoped: boolean;
+    fromHtml: boolean;
+    initial: boolean;
+    constructor({ code, prefetch, preload, url, fromHtml, initial }: IStyleOption);
+    getCode(app?: BaseModel): Promise<string>;
+    excuteCode(app: BaseModel): Promise<HTMLStyleElement>;
+    scopedStyleCSS(app: BaseModel, styleElement: HTMLStyleElement): HTMLStyleElement;
+    scopedLinkCSS(app: BaseModel, linkElement: HTMLLinkElement): HTMLStyleElement;
+    commonScoped(templateStyle: HTMLStyleElement, styleElement: HTMLStyleElement, app: BaseModel): void;
+    scopeRule(rules: CSSRule[], cssPrefix: string): string;
+    resetPackRule(rule: CSSMediaRule | CSSSupportsRule, prefix: string, packName: string): string;
+    resetUrlHost(cssText: string, baseURI: string, linkpath?: string): string;
+    scopeStyleRule(rule: CSSStyleRule, prefix: string): string;
+}
+export declare function excuteAppStyles(app: BaseModel, container?: Element | ShadowRoot): Promise<void>;

package/typings/index.d.ts

@@ -0,0 +1,19 @@
+import './context/memory';
+import { FetchSourceType, IStartOption } from './typings';
+export * from './lifecircle/before-load';
+export * from './lifecircle/load';
+export * from './lifecircle/mount';
+export * from './lifecircle/unload';
+export * from './lifecircle/unmount';
+export * from './lifecircle/activated';
+export * from './lifecircle/deactivated';
+export * from './preload/preload';
+export declare class IframeApp {
+    fetchSource?: FetchSourceType;
+    webcomponentTag: string;
+    constructor();
+    start(option?: IStartOption): void;
+    setWebComponentTag(): void;
+}
+declare const iframeApp: IframeApp;
+export default iframeApp;

package/typings/lifecircle/activated.d.ts

@@ -0,0 +1,2 @@
+import { BaseModel } from '../typings';
+export declare function activated<T>(appKey: string, container: HTMLElement | ShadowRoot, callback?: <M extends BaseModel>(instance: M, exportInstance?: T) => void): void;

package/typings/lifecircle/before-load.d.ts

@@ -0,0 +1 @@
+export declare function beforeLoad(): void;

package/typings/lifecircle/deactivated.d.ts

@@ -0,0 +1 @@
+export declare function deactivated(appKey: string): void;

package/typings/lifecircle/load.d.ts

@@ -0,0 +1,6 @@
+import { MicroAppModel } from '../mode/app';
+import { BaseModel, IAppModleProps, IBaseModelProps, IJsModelProps } from '../typings';
+import { MicroInstanceModel } from '../mode/instance';
+export declare function load(props: IBaseModelProps): Promise<BaseModel>;
+export declare function loadApp(props: IAppModleProps): Promise<MicroAppModel>;
+export declare function loadInstance(props: IJsModelProps): Promise<MicroInstanceModel>;

package/typings/lifecircle/mount.d.ts

@@ -0,0 +1,2 @@
+import { BaseModel } from '../typings';
+export declare function mount<T>(appKey: string, container?: HTMLElement | ShadowRoot, callback?: <M extends BaseModel>(instance: M, exportInstance?: T) => void): void;

package/typings/lifecircle/unload.d.ts

@@ -0,0 +1 @@
+export declare function unload(url: string): void;

package/typings/lifecircle/unmount.d.ts

@@ -0,0 +1 @@
+export declare function unmount(appKey: string): void;

package/typings/mode/app.d.ts

@@ -0,0 +1,37 @@
+import { AppState } from '../common';
+import { EntrySource } from '../entry/entry';
+import { AppMode, BaseModel, IAppModleProps } from '../typings';
+import SandBox from '../context/sandbox';
+import { SourceType } from '../utils/load-source';
+export declare class MicroAppModel implements BaseModel {
+    private state;
+    isPreLoad: boolean;
+    mode: AppMode;
+    name: string;
+    url: string;
+    container?: HTMLElement | ShadowRoot;
+    showSourceCode: boolean;
+    scopeCss: boolean;
+    scopeJs: boolean;
+    source?: EntrySource;
+    sandBox?: SandBox;
+    scopeLocation: boolean;
+    keepAlive: boolean;
+    initSource: SourceType;
+    iframe: HTMLIFrameElement | null;
+    data: Record<string, unknown>;
+    constructor(props: IAppModleProps);
+    get appCacheKey(): string;
+    get status(): AppState;
+    set status(v: AppState);
+    start(): Promise<void>;
+    onMount(): void;
+    onError(): void;
+    mount(container?: HTMLElement | ShadowRoot, callback?: (app: BaseModel) => void): void;
+    activated(container: HTMLElement | ShadowRoot, callback?: (app: BaseModel) => void): void;
+    deactivated(): void;
+    unmount(needDestroy?: boolean): void;
+    createIframe(): Promise<HTMLIFrameElement>;
+    registerRunningApp(): void;
+}
+export declare const createApp: (props: IAppModleProps) => void;

package/typings/mode/instance.d.ts

@@ -0,0 +1,32 @@
+import { AppState } from '../common';
+import SandBox from '../context/sandbox';
+import { EntrySource } from '../entry/entry';
+import { BaseModel, IJsModelProps } from '../typings';
+import { SourceType } from '../utils/load-source';
+export declare class MicroInstanceModel implements BaseModel {
+    private state;
+    isPreLoad: boolean;
+    appCacheKey: string;
+    url: string;
+    container?: HTMLElement | ShadowRoot;
+    scopeJs: boolean;
+    source?: EntrySource;
+    sandBox?: SandBox;
+    name: string;
+    showSourceCode: boolean;
+    scopeCss: boolean;
+    keepAlive: boolean;
+    initSource: SourceType;
+    data: Record<string, unknown>;
+    constructor(props: IJsModelProps);
+    get status(): AppState;
+    set status(v: AppState);
+    start(): Promise<void>;
+    onMount(): void;
+    onError(): void;
+    mount<T>(container?: HTMLElement | ShadowRoot, callback?: (instance: MicroInstanceModel, exportInstance: T) => void): void;
+    activated<T>(container: HTMLElement | ShadowRoot, callback?: (instance: BaseModel, exportInstance?: T) => void): void;
+    deactivated(): void;
+    unmount(needDestroy?: boolean): void;
+    registerRunningApp(): void;
+}

package/typings/preload/preload.d.ts

@@ -0,0 +1,5 @@
+import { IAppModleProps, IJsModelProps } from '../typings';
+import { SourceType } from '../utils/load-source';
+export declare function preLoadInstance(options: IJsModelProps): void;
+export declare function preLoadApp(options: IAppModleProps): void;
+export declare function preLoadSource(sourceList: SourceType): void;

package/typings/typings/global.d.ts

@@ -0,0 +1,17 @@
+import { AppCache } from '../cache/app-cache';
+import { BaseModel } from './model';
+export {};
+declare global {
+    interface Window {
+        __POWERED_BY_BK_WEWEB__?: boolean;
+        __BK_WEWEB_APP_KEY__?: string;
+        __getAppOrInstance__(id?: string): AppCache | BaseModel | undefined;
+        Zone?: Function;
+        requestIdleCallback(callback: Function, options?: unknown | undefined): number;
+    }
+    interface Node {
+        __BK_WEWEB_APP_KEY__?: string;
+        __KEEP_ALIVE__?: string;
+        data?: any;
+    }
+}

package/typings/typings/index.d.ts

@@ -0,0 +1,10 @@
+export * from './global';
+export * from './source';
+export * from './sandbox';
+export * from './model';
+export declare type AppMode = 'app' | 'config' | 'js';
+export declare type FetchSourceType = (url: string, options: Record<string, unknown>) => Promise<string>;
+export interface IStartOption {
+    fetchSource?: FetchSourceType;
+    webcomponentTag?: string;
+}

package/typings/typings/model.d.ts

@@ -0,0 +1,64 @@
+import { AppMode } from '.';
+import { AppState } from '../common';
+import { ObserveAttrs } from '../component/web-compnent';
+import SandBox from '../context/sandbox';
+import { EntrySource } from '../entry/entry';
+import { SourceType } from '../utils/load-source';
+export interface IComponentProps {
+    [ObserveAttrs.URL]: string;
+    [ObserveAttrs.showSourceCode]?: boolean;
+    [ObserveAttrs.scopeLocation]?: boolean;
+    [ObserveAttrs.setShodowDom]?: boolean;
+    [ObserveAttrs.mode]?: AppMode;
+    [ObserveAttrs.data]?: string;
+}
+export interface IBaseModelProps {
+    [ObserveAttrs.mode]?: AppMode;
+    [ObserveAttrs.URL]: string;
+    isPreLoad?: boolean;
+    id?: string | null;
+}
+export interface IAppModleProps extends IBaseModelProps {
+    container?: HTMLElement | ShadowRoot | null;
+    scopeCss?: boolean;
+    scopeJs?: boolean;
+    keepAlive?: boolean;
+    [ObserveAttrs.showSourceCode]?: boolean;
+    [ObserveAttrs.scopeLocation]?: boolean;
+    [ObserveAttrs.setShodowDom]?: boolean;
+    [ObserveAttrs.data]?: Record<string, unknown>;
+    initSource?: SourceType;
+}
+export interface IJsModelProps extends IBaseModelProps {
+    container?: HTMLElement | ShadowRoot | null;
+    scopeJs?: boolean;
+    scopeCss?: boolean;
+    keepAlive?: boolean;
+    [ObserveAttrs.showSourceCode]?: boolean;
+    [ObserveAttrs.data]?: Record<string, unknown>;
+    initSource?: SourceType;
+}
+export interface BaseModel {
+    url: string;
+    container?: HTMLElement | ShadowRoot;
+    source?: EntrySource;
+    sandBox?: SandBox;
+    isPreLoad: boolean;
+    showSourceCode?: boolean;
+    name: string;
+    scopeCss?: boolean;
+    scopeJs: boolean;
+    keepAlive?: boolean;
+    initSource?: SourceType;
+    get appCacheKey(): string;
+    get status(): AppState;
+    set status(v: AppState);
+    start(): Promise<void>;
+    onMount(): void;
+    onError(): void;
+    mount<T>(container?: HTMLElement | ShadowRoot, callback?: (instance: BaseModel, exportInstance?: T) => void): void;
+    activated<T>(container: HTMLElement | ShadowRoot, callback?: (instance: BaseModel, exportInstance?: T) => void): void;
+    deactivated(): void;
+    unmount(needDestroy?: boolean): void;
+    registerRunningApp(): void;
+}

package/typings/typings/sandbox.d.ts

@@ -0,0 +1,18 @@
+export interface IInjectWindowAttrs {
+    __POWERED_BY_BK_WEWEB__: boolean;
+    __BK_WEWEB_APP_KEY__: string;
+    __BK_WEWEB_DATA__: Record<string, unknown>;
+    rawWindow: Window;
+    rawDocument: Document;
+}
+export declare const commonEScapeKeyList: PropertyKey[];
+export declare const escapeSetterKeyList: PropertyKey[];
+export declare const scopeWindowKeyList: PropertyKey[];
+export declare const scopedLocationKeyList: PropertyKey[];
+export declare enum DescriptorMapValue {
+    'TARGET' = "TARGET",
+    'WINDOW' = "WINDOW"
+}
+export declare const commonRawWindowKeyMap: any;
+export declare const commonFakeWindowKeyMap: any;
+export declare const commonWindowNameMap: any;

package/typings/typings/source.d.ts

@@ -0,0 +1,23 @@
+export interface IStyleOption {
+    code: string;
+    prefetch?: boolean;
+    preload?: boolean;
+    url?: string;
+    fromHtml: boolean;
+    initial?: boolean;
+}
+export interface IScriptOption {
+    code: string;
+    async: boolean;
+    defer: boolean;
+    isModule: boolean;
+    url?: string;
+    fromHtml: boolean;
+    initial?: boolean;
+}
+export declare const CSS_ATTRIBUTE_KEY = "id";
+export declare enum CSS_RULE_TYPE {
+    STYLE_RULE = 1,
+    MEDIA_RULE = 4,
+    SUPPORTS_RULE = 12
+}

package/typings/utils/common.d.ts

@@ -0,0 +1,18 @@
+export declare function isFunction(target: unknown): boolean;
+export declare const nextTask: (cb: () => void) => any;
+export declare function nextTick(cb: () => void): void;
+export declare function addUrlProtocol(url: string): string;
+export declare function getUrlDir(url: string): string;
+export declare function fillUpPath(path: string, baseURI: string): string;
+export declare function getFileDir(linkpath: string): string;
+export declare const isIE11: boolean;
+export declare function randomUrl(): string;
+export declare function arrayUnique(array: any[]): any[];
+export declare const requestIdleCallback: {
+    (callback: IdleRequestCallback, options?: IdleRequestOptions | undefined): number;
+    (callback: Function, options?: unknown): number;
+} & typeof globalThis.requestIdleCallback;
+export declare function isSafari(): boolean;
+export declare function createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
+export declare function isBodyElement(key: string): boolean;
+export declare const random: (n: number, str?: string) => string;

package/typings/utils/element-event.d.ts

@@ -0,0 +1,2 @@
+export declare function dispatchLinkOrScriptLoad(element: HTMLLinkElement | HTMLScriptElement): void;
+export declare function dispatchLinkOrScriptError(element: HTMLLinkElement | HTMLScriptElement): void;

package/typings/utils/element.d.ts

@@ -0,0 +1,6 @@
+import { BaseModel } from '../typings';
+export declare function resetNewElement(parent: Node, child: Node, app: BaseModel): Node;
+export declare function isSepcailElement(node: Node): boolean;
+export declare function elmentAppendHandler(parent: Node, newChild: Node, rawMethod: Function): any;
+export declare function elementInsertHandler(parent: Node, newChild: Node, passiveChild: Node | null, rawMethod: Function): any;
+export declare function setMarkElement<T extends Element>(element: T, app: BaseModel, keepAlive: boolean): T;

package/typings/utils/fetch.d.ts

@@ -0,0 +1 @@
+export declare function fetchSource(url: string, options?: {}): Promise<string>;

package/typings/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './element-event';
+export * from './element';
+export * from './fetch';

package/typings/utils/load-source.d.ts

@@ -0,0 +1,12 @@
+import { Script } from '../entry/script';
+import { Style } from '../entry/style';
+export declare type SourceFuncType = () => Promise<string[]>;
+export declare type SourceType = string[] | SourceFuncType;
+export declare function collectSource(soruceList: SourceType): Promise<{
+    collectScript?: undefined;
+    collectStyle?: undefined;
+} | {
+    collectScript: Map<string, Script>;
+    collectStyle: Map<string, Style>;
+}>;
+export declare function LoadGlobalSource(soruceList: SourceType): Promise<void>;