@vyr/cli 0.0.11 → 0.0.13

package/output/remote/src/utils/index.ts

@@ -0,0 +1,85 @@
+import { AnimationUnitDescriptor, Asset, Descriptor } from "@vyr/engine"
+import { RemoteProcess } from "../RemoteProcess"
+import { Job } from "../job"
+
+const createControllerStyle = () => {
+    const style = document.createElement('style')
+    const css = [
+        '.vyr-html-wrapper{pointer-events: all !important;}',
+        '.vyr-html-wrapper > * {pointer-events: none !important}',
+    ]
+    style.innerText = css.join('\n')
+    document.head.append(style)
+}
+
+const pickupObject = (process: RemoteProcess) => {
+    const executor = (event: MouseEvent) => {
+        const graphics = process.engine.getGraphics(process.scheduler)
+        const result = graphics.pickup(event)
+        if (result.length === 0) return
+
+        const select = result[0]
+        process.bridge.send(new Job.invoke.pick.Response({ descriptor: select.generatedBy || select.uuid }))
+    }
+
+    let count = 0
+    const beforePickup = (event: MouseEvent) => {
+        if (count === 0) {
+            setTimeout(() => pickup(event), 250)
+        }
+        count++
+    }
+    const pickup = (event: MouseEvent) => {
+        if (count > 1) {
+            executor(event)
+        }
+        count = 0
+    }
+
+    window.addEventListener('click', beforePickup)
+}
+
+const cleanPickupObject = (process: RemoteProcess) => {
+    let now = 0
+    const mousedown = (event: MouseEvent) => {
+        if (event.button !== 2) return
+        now = performance.now()
+        window.addEventListener('mouseup', mouseup, { once: true })
+    }
+    const mouseup = (event: MouseEvent) => {
+        if (event.button !== 2) return
+        if (performance.now() - now > 150) return
+        process.bridge.send(new Job.invoke.pick.Response({ descriptor: '' }))
+    }
+
+    window.addEventListener('mousedown', mousedown)
+}
+
+const getAnimationUnit = (descriptor: Descriptor) => {
+    let max = 0
+    descriptor.traverse((sub) => {
+        if (sub instanceof AnimationUnitDescriptor) {
+            const uptime = sub.startTime + sub.duration
+            if (uptime > max) max = uptime
+        }
+    })
+    return max
+}
+
+const getAnimationUnitByAsset = (url: string) => {
+    const descriptor = Asset.get<Descriptor>(url)
+    if (descriptor instanceof Descriptor) {
+        return getAnimationUnit(descriptor)
+    } else {
+        return 0
+    }
+}
+
+export {
+    createControllerStyle,
+    pickupObject,
+    cleanPickupObject,
+    getAnimationUnit,
+    getAnimationUnitByAsset,
+}
+export * from './screenshot'

package/output/remote/src/utils/screenshot.ts

@@ -0,0 +1,20 @@
+let HTMLToImage: any = null
+const screenshot = async (html: HTMLElement, backgroundColor = '#ffffff') => {
+    if (HTMLToImage === null) {
+        //@ts-ignore
+        HTMLToImage = await import('dom-to-image')
+    }
+
+    const url = await HTMLToImage.default.toPng(html, {
+        bgcolor: backgroundColor,
+        width: html.clientWidth || html.scrollWidth,
+        height: html.clientHeight || html.scrollHeight,
+        quality: 1.0,
+    })
+
+    return url
+}
+
+export {
+    screenshot
+}

package/output/remote/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "lib": [
+      "ESNext",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "outDir": "build",
+    "strict": true,
+    "jsx": "preserve",
+    "declaration": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "useDefineForClassFields": true,
+    "sourceMap": false,
+    "baseUrl": "",
+    "types": [
+      "webpack-env"
+    ],
+    "paths": {}
+  },
+  "include": [
+    "src/**/*.ts",
+  ],
+  "exclude": []
+}

package/output/rollup-config-plugin/index.js

@@ -0,0 +1,46 @@
+const fs = require('fs-extra')
+
+const getRollupConfigContent = (outputFile, input, outputPath, external) => {
+    const configObj = {
+    }
+
+    const config = [
+        `{`,
+        `    input: ${JSON.stringify(input)},`,
+        `    output: {`,
+        `        file: ${JSON.stringify(outputPath)},`,
+        `        format: 'cjs',`,
+        `        inlineDynamicImports: true,`,
+        `    },`,
+        `    external: ${JSON.stringify(external)},`,
+        `    plugins: [`,
+        `        json(),`,
+        `        postcss({ extract: false, minimize: true }),`,
+        `        nodeResolve({ preferBuiltins: true}),`,
+        `        commonjs({ ignoreDynamicRequires: true }),`,
+        `        esbuild(${JSON.stringify(configObj)}),`,
+        `        varRename(${JSON.stringify(external)}, ${JSON.stringify(outputFile)}),`,
+        `    ],`,
+        `    treeshake: false,`,
+        `}`,
+    ].join('\n')
+
+    return config
+}
+
+const createRollupConfigFactory = (config) => {
+    const factory = new Function(
+        'nodeResolve',
+        'commonjs',
+        'json',
+        'postcss',
+        'esbuild',
+        'varRename',
+        `return ${config}`)
+
+    return factory
+}
+module.exports = {
+    getRollupConfigContent,
+    createRollupConfigFactory,
+}

package/output/rollup-config-plugin/package.json

@@ -0,0 +1,8 @@
+{
+    "name": "@vyr/pack-rollup-config-plugin",
+    "version": "0.0.13",
+    "description": "",
+    "main": "./index.js",
+    "author": "",
+    "license": "ISC"
+}

package/output/runtime/build/Action.d.ts

@@ -0,0 +1,42 @@
+declare abstract class Action {
+    static id: string;
+    static rightMenu: number;
+    static shortcutkey: number;
+    readonly id: string;
+    readonly value: number;
+    abstract label: string;
+    order: number;
+    /**行为的触发类型 */
+    trigger: number;
+    /**是否显示 */
+    show: boolean;
+    /**是否被禁用 */
+    disabled: boolean;
+    /**该行为的子行为 */
+    children: Action[];
+    /**快捷键服务会调用该方法验证行为是否应该被更新 */
+    abstract validator(...args: any[]): boolean;
+    /**更新行为的属性,例如`show` `disabled`等属性。可在行为执行前控制是否展示/禁用该行为*/
+    abstract update(): void;
+    /**该行为需要执行的逻辑 */
+    abstract execute(): void;
+    constructor();
+    active(): boolean;
+}
+declare class ActionGroup {
+    private actions;
+    private queue;
+    private needReset;
+    readonly region: string;
+    constructor(region: string, actions: Action[]);
+    reset(forced?: boolean): void;
+    add(...actions: Action[]): void;
+    remove(...actions: Action[]): void;
+    getActions(): Action[];
+    get<T extends Action | null = Action | null>(id: string): T;
+    /**更新所有行为，右键菜单功能会调用该方法 */
+    update(trigger: number): Action[];
+    /**对所有行为进行验证,通过验证的行为将被执行，快捷键功能会调用该方法  */
+    execute(trigger: number, ...args: any[]): boolean;
+}
+export { ActionGroup, Action };

package/output/runtime/build/DataService.d.ts

@@ -0,0 +1,22 @@
+import { Service } from "@vyr/service";
+import { ScriptOption } from './data/global';
+import { Header } from "./data/header";
+import { Body } from './data/body';
+import { Sidebar } from './data/sidebar';
+import { Inspector } from "./data/inspector";
+import { Footer } from './data/footer';
+import { Status } from './data/status';
+declare class DataService extends Service {
+    readonly scripts: ScriptOption[];
+    readonly header: Header;
+    readonly body: Body;
+    readonly sidebar: Sidebar;
+    readonly inspector: Inspector;
+    readonly footer: Footer;
+    readonly status: Status;
+    constructor(name: string);
+    setup(): Promise<void>;
+    addScripte(script: ScriptOption): void;
+}
+export { DataService };
+export * from './data/global';

package/output/runtime/build/DraggableService.d.ts

@@ -0,0 +1,37 @@
+import { Service } from "@vyr/service";
+import { SerializationObject } from '@vyr/engine';
+import { AdditionalData, DraggableEndType, DraggableData } from '@vyr/declare';
+declare abstract class Draggable<D extends AdditionalData = AdditionalData, T extends AdditionalData = D> {
+    abstract readonly id: string;
+    /**对拖拽的类型进行限制 */
+    limit(dragData: DraggableData<D>, targetData: DraggableData<D>, type: DraggableEndType): DraggableEndType;
+    updateTargetOfKey<T extends AdditionalData = AdditionalData>(key: string, value: any, target: SerializationObject): void;
+    /**拖拽组的启动器，当托拽功能准备启动拖拽组时会调用该方法。
+     *
+     * @param dragData 准备拖动的对象
+     * @returns 返回值决定了该对象是否可被拖动
+     */
+    abstract starter(dragData: D): boolean;
+    /**拖拽组的验证器，当托拽对象进入目标对象`(该托拽组内的任意一个对象)`时会调用该方法。
+     *
+     * @param targetData 进入的目标对象
+     * @returns 返回值决定了托拽对象能否被放置在目标对象
+     */
+    abstract validator(dragData: DraggableData<D>, targetData: DraggableData<T>): boolean;
+    /**成功完成托拽时该方法将被执行 */
+    abstract finished(dragData: DraggableData<D>, targetData: DraggableData<T>, type: DraggableEndType): void;
+}
+declare class DraggableKey {
+    scene: string;
+    asset: string;
+    inspector: string;
+    footer: string;
+}
+declare class DraggableService extends Service {
+    static readonly key: DraggableKey;
+    private _collection;
+    readonly key: DraggableKey;
+    get(id: string | number): Draggable<AdditionalData, AdditionalData>;
+    set(id: string | number, draggable: Draggable): void;
+}
+export { Draggable, DraggableService, };

package/output/runtime/build/InspectorService.d.ts

@@ -0,0 +1,18 @@
+import { ComponentPublicInstance, Component, AsyncComponentLoader } from 'vue';
+import { Service } from "@vyr/service";
+interface ServiceConfig {
+    loading: Component;
+    error: Component;
+}
+declare class InspectorService<T extends new () => ComponentPublicInstance = new () => ComponentPublicInstance> extends Service {
+    private map;
+    readonly loading: Component;
+    readonly error: Component;
+    constructor(name: string, config: ServiceConfig);
+    setup(): Promise<void>;
+    ready(): Promise<void>;
+    start(): Promise<void>;
+    get<R extends T = T>(id: string): R;
+    set(id: string, executor: AsyncComponentLoader): void;
+}
+export { InspectorService };

package/output/runtime/build/PresetService.d.ts

@@ -0,0 +1,32 @@
+import { Descriptor } from "@vyr/engine";
+import { Service } from "@vyr/service";
+interface Preset {
+    type: string;
+    value: string;
+    label: string;
+    executor: (...args: any[]) => Promise<void>;
+}
+type InteractionProvider = {
+    id: string;
+    label: string;
+    ignore: string[] | ((descriptor: Descriptor) => boolean);
+};
+declare class PresetService extends Service {
+    private _collection;
+    private _typeCollection;
+    private _eventProviderCollection;
+    constructor(name: string);
+    private _addGlobalInteractionProvider;
+    private _addDatasetInteractionProvider;
+    private _addHTMLInteractionProvider;
+    get(value: string): Preset;
+    getByType(type: string): Preset[];
+    set(preset: Preset): void;
+    addInteractionProvider(provider: InteractionProvider): void;
+    getInteractionLabel(id: string): string;
+    getByInteractionProvider(descriptor: Descriptor): {
+        label: string;
+        value: string;
+    }[];
+}
+export { Preset, PresetService };

package/output/runtime/build/RemoteService.d.ts

@@ -0,0 +1,12 @@
+import { Service } from "@vyr/service";
+import { Job, RemoteConfig, RemoteInvoker } from '@vyr/remote';
+declare class RemoteService extends Service {
+    private _collection;
+    constructor(name: string);
+    private dispose;
+    create(config: Partial<Omit<RemoteConfig, "id">>): RemoteInvoker;
+    get(id: string | number): RemoteInvoker;
+    set(id: string | number, remote: RemoteInvoker): void;
+    send(task: Job): void;
+}
+export { RemoteService };

package/output/runtime/build/Runtime.d.ts

@@ -0,0 +1,8 @@
+import { Service } from "@vyr/service";
+declare class Runtime {
+    static services(): Service[];
+    get<K extends Service = Service>(name: string): K;
+    set(service: Service): void;
+}
+declare const runtime: Runtime;
+export { runtime, Runtime };

package/output/runtime/build/ShortcutkeyService.d.ts

@@ -0,0 +1,23 @@
+import { Region, Service } from "@vyr/service";
+import { Action, ActionGroup } from "./Action";
+declare class ShortcutkeyService extends Service {
+    static spaced: boolean;
+    static update(event: KeyboardEvent, enable: boolean): void;
+    private groupCollection;
+    private current;
+    private status;
+    constructor(name: string);
+    private bindActionHandler;
+    private unbindActionHandler;
+    listen(): void;
+    /**获取快捷键服务的当前行为组 */
+    get(): ActionGroup;
+    get(name: Region | 'global'): ActionGroup;
+    /**设置快捷键服务的行为组，多次调用会覆盖上一次的设置 */
+    active(region: Region): void;
+    unactive(): void;
+    enable(): void;
+    disable(): void;
+    getAction<T extends Action = Action>(id: string): T | null;
+}
+export { ShortcutkeyService };

package/output/runtime/build/data/body.d.ts

@@ -0,0 +1,13 @@
+declare class Body {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    scale: number;
+    position: {
+        x: number;
+        y: number;
+    };
+    background: string;
+}
+export { Body };

package/output/runtime/build/data/footer.d.ts

@@ -0,0 +1,42 @@
+import { VirtualNode } from '@vyr/service-rpc';
+declare class Status {
+    /**鼠标当前所在的区域
+     * @directory 目录
+     * @manifest 清单
+    */
+    mouseRegion: 'directory' | 'manifest';
+    /**鼠标在当前区域的激活项 */
+    mouseItem: VirtualNode | null;
+    /**目录的修改模式 */
+    modifyMode: 'close' | 'add' | 'edit';
+    /**目录的修改模式开启时修改的数据项 */
+    modifyValue: VirtualNode | null;
+    /**目录的修改模式为`add`时的类型 */
+    modifyModeAdd: 'file' | 'dir';
+    /**目录的修改模式为`add`且路径为`file`时文件的内容 */
+    modifyContent: string;
+    /**目录的修改模式为`add`且路径为`file`时文件的后缀 */
+    modifySuffix: string;
+    /**快捷操作的类型 */
+    stickup: 'copy' | 'cut' | '';
+    /**快捷操作的数据项 */
+    stickupItems: VirtualNode[];
+    /**全选数组 */
+    selectAll: VirtualNode[];
+    /**对清单进行筛选时所需的值 */
+    search: string;
+}
+declare class Footer {
+    readonly root: VirtualNode;
+    readonly emptyDirectory: VirtualNode;
+    readonly status: Status;
+    readonly getter: {
+        label(item: VirtualNode): string;
+        value(item: VirtualNode): string;
+    };
+    directory: VirtualNode;
+    manifest: VirtualNode[];
+    size: number;
+    updateManifest(): VirtualNode[];
+}
+export { Footer };

package/output/runtime/build/data/global.d.ts

@@ -0,0 +1,15 @@
+import { InteractionInput } from "@vyr/engine";
+interface ScriptPropertyOptions extends Array<{
+    [k: string]: any;
+}> {
+}
+interface ScriptPropertyOptionsGetters {
+    [k: string]: (input: InteractionInput) => ScriptPropertyOptions;
+}
+interface ScriptOption {
+    label: string;
+    value: string;
+    getDefaultInput(): any;
+    getPropertyOptions?: () => ScriptPropertyOptionsGetters;
+}
+export { ScriptPropertyOptions, ScriptPropertyOptionsGetters, ScriptOption };

package/output/runtime/build/data/header.d.ts

@@ -0,0 +1,11 @@
+declare class Status {
+    /**
+     * - 'file'
+     * - 'scene'
+     */
+    type: string;
+}
+declare class Header {
+    status: Status;
+}
+export { Header };

package/output/runtime/build/data/inspector.d.ts

@@ -0,0 +1,10 @@
+declare class Inspector {
+    size: number;
+    active: string;
+    eventKind: string;
+    datasetKind: string;
+    animations: {
+        [uuid: string]: string[];
+    };
+}
+export { Inspector };

package/output/runtime/build/data/sidebar.d.ts

@@ -0,0 +1,11 @@
+import { SidebarNavigator } from "../navigator";
+declare class Sidebar {
+    private _collection;
+    size: number;
+    active: string;
+    get<T extends SidebarNavigator | null = SidebarNavigator | null>(key: string): T;
+    set<T extends SidebarNavigator = SidebarNavigator>(navigator: T): T;
+    getCollection(): SidebarNavigator[];
+    toggle(key: string): void;
+}
+export { Sidebar };

package/output/runtime/build/data/status.d.ts

@@ -0,0 +1,17 @@
+declare class Transform {
+    target: string;
+    mode: string;
+}
+declare class Helper {
+}
+declare class Aniamtion {
+    max: number;
+    currentTime: number;
+    enabled: boolean;
+}
+declare class Status {
+    transform: Transform;
+    helper: Helper;
+    animation: Aniamtion;
+}
+export { Status };

package/output/runtime/build/index.d.ts

@@ -0,0 +1,10 @@
+export * from './locale';
+export * from './navigator';
+export * from './Action';
+export * from './DataService';
+export * from './PresetService';
+export * from './DraggableService';
+export * from './InspectorService';
+export * from './RemoteService';
+export * from './ShortcutkeyService';
+export * from './Runtime';

package/output/runtime/build/locale/Language.d.ts

@@ -0,0 +1,3 @@
+import { ZhCNLanguageProvider } from "./LanguageProvider";
+declare const language: import("@vyr/locale").Language<ZhCNLanguageProvider>;
+export { language };

package/output/runtime/build/locale/LanguageProvider.d.ts

@@ -0,0 +1,31 @@
+import { LanguageProvider } from '@vyr/locale';
+interface ZhCNLanguageProvider extends LanguageProvider {
+    'preset.Interaction.id.mount': string;
+    'preset.Interaction.id.click': string;
+    'preset.Interaction.id.compile': string;
+    'preset.Interaction.id.mousedown': string;
+    'preset.Interaction.id.mouseup': string;
+    'preset.Interaction.id.mouseenter': string;
+    'preset.Interaction.id.mouseleave': string;
+    'preset.Interaction.id.mousemove': string;
+    'preset.Interaction.id.mouseout': string;
+    'preset.Interaction.id.mouseover': string;
+    'preset.Interaction.id.contextmenu': string;
+    'preset.Interaction.id.dblclick': string;
+    'preset.Interaction.id.keydown': string;
+    'preset.Interaction.id.keyup': string;
+    'preset.Interaction.id.focus': string;
+    'preset.Interaction.id.blur': string;
+    'preset.Interaction.id.play': string;
+    'preset.Interaction.id.pause': string;
+    'preset.Interaction.id.pointercancel': string;
+    'preset.Interaction.id.pointerdown': string;
+    'preset.Interaction.id.pointerenter': string;
+    'preset.Interaction.id.pointerleave': string;
+    'preset.Interaction.id.pointermove': string;
+    'preset.Interaction.id.pointerout': string;
+    'preset.Interaction.id.pointerover': string;
+    'preset.Interaction.id.pointerup': string;
+}
+declare const zhCnLanguageProvider: ZhCNLanguageProvider;
+export { ZhCNLanguageProvider, zhCnLanguageProvider, };

package/output/runtime/build/locale/index.d.ts

@@ -0,0 +1,2 @@
+export * from './LanguageProvider';
+export * from './Language';

package/output/runtime/build/navigator/SidebarNavigator.d.ts

@@ -0,0 +1,52 @@
+import { Descriptor, DeserializationObject } from "@vyr/engine";
+import { DraggableData, DraggableEndType } from "@vyr/declare";
+import { RpcService, VirtualNode } from "@vyr/service-rpc";
+import { Job } from "@vyr/remote";
+import { Draggable } from "../DraggableService";
+declare class Status {
+    /**目录的修改模式 */
+    modifyMode: 'close' | 'add' | 'edit';
+    /**场景树的修改模式开启时修改的数据项 */
+    modifyValue: Descriptor | null;
+    /**场景树的修改模式为`add`时的元数据对象 */
+    modifyContent: Descriptor | null;
+    /**鼠标在当前区域的激活项 */
+    mouseItem: Descriptor | null;
+    /**快捷操作的类型 */
+    stickup: 'copy' | 'cut' | '';
+    /**快捷操作的数据项 */
+    stickupItems: Descriptor[];
+    /**对场景节点进行筛选时所需的值 */
+    search: string;
+}
+/**该类会被响应式对象使用，定义方法时不要使用箭头函数（会导致在方法里修改变量时，直接修改了原始对象） */
+declare abstract class SidebarNavigator {
+    static key: string;
+    readonly key: string;
+    readonly label: string;
+    readonly icon: string;
+    readonly root: Descriptor;
+    readonly getter: {
+        label(item: Descriptor): string;
+        value(item: Descriptor): string;
+        disabled(): boolean;
+    };
+    readonly status: Status;
+    readonly events: Array<{
+        key: string;
+        bind: (...args: any[]) => void;
+    }>;
+    url: string;
+    selectAll: Descriptor[];
+    constructor(label: string, icon: string);
+    active(): void;
+    unactive(): void;
+    on(rpc: RpcService, key: string, cb: (...args: any[]) => void): (...args: any[]) => void;
+    unAll(rpc: RpcService): void;
+    abstract finishedWhereInspectorDraggable(draggable: Draggable, dragData: DraggableData<VirtualNode>, targetData: DraggableData, type: DraggableEndType): void;
+    abstract ensureReadonlyWhereInteraction(client: string): boolean;
+    abstract saveWhereInteraction(content: DeserializationObject<Descriptor>): void;
+    abstract remoteTransformEvent(...args: any[]): void;
+    abstract remotePickEvent(task: InstanceType<typeof Job['invoke']['pick']['Response']>): void;
+}
+export { Status, SidebarNavigator, };

package/output/runtime/build/navigator/index.d.ts

@@ -0,0 +1 @@
+export * from './SidebarNavigator';

package/output/runtime/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@vyr/runtime",
+  "version": "0.0.13",
+  "description": " - Type Declarations",
+  "main": "",
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "vue": "3.5.22"
+  },
+  "files": [
+    "**/*.d.ts"
+  ],
+  "types": "./index.d.ts",
+  "typings": "./index.d.ts"
+}

package/output/service/package.json

@@ -0,0 +1 @@
+{"name":"@vyr/service","version":"0.0.13","description":"","main":"./src/index.ts","author":"","license":"MIT","dependencies":{},"files":["package.json","src/"]}