@vyr/cli 0.0.12 → 0.0.13

package/output/builtin/build/service/sidebar/asset/action/RenameAction.d.ts

@@ -0,0 +1,14 @@
+import { Action, DataService } from "@vyr/runtime";
+declare class RenameAction extends Action {
+    static id: string;
+    label: string;
+    active(): boolean;
+    validator(e: KeyboardEvent): boolean;
+    updateRightMenu(): void;
+    updateShortcutkey(): void;
+    update(): void;
+    executeRightMenu(dataService: DataService): void;
+    executeShortcutkey(dataService: DataService): void;
+    execute(): void;
+}
+export { RenameAction };

package/output/builtin/build/service/sidebar/asset/action/SaveAction.d.ts

@@ -0,0 +1,14 @@
+import { Action, DataService } from "@vyr/runtime";
+declare class SaveAction extends Action {
+    static id: string;
+    label: string;
+    active(): boolean;
+    validator(e: KeyboardEvent): boolean;
+    updateRightMenu(): void;
+    updateShortcutkey(): void;
+    update(): void;
+    executeRightMenu(dataService: DataService): void;
+    executeShortcutkey(dataService: DataService): void;
+    execute(): void;
+}
+export { SaveAction };

package/output/builtin/build/service/sidebar/asset/action/StickupAction.d.ts

@@ -0,0 +1,15 @@
+import { Action, DataService } from "@vyr/runtime";
+import { AssetService } from "@vyr/service-asset";
+declare class StickupAction extends Action {
+    static id: string;
+    label: string;
+    active(): boolean;
+    validator(e: KeyboardEvent): boolean;
+    updateRightMenu(): void;
+    updateShortcutkey(): void;
+    update(): void;
+    executeRightMenu(dataService: DataService, assetService: AssetService): void;
+    executeShortcutkey(dataService: DataService, assetService: AssetService): void;
+    execute(): void;
+}
+export { StickupAction };

package/output/builtin/build/service/sidebar/asset/action/index.d.ts

@@ -0,0 +1,8 @@
+export * from './ControllerAction';
+export * from './AddNodeAction';
+export * from './SaveAction';
+export * from './CopyAction';
+export * from './CutAction';
+export * from './StickupAction';
+export * from './DeleteAction';
+export * from './RenameAction';

package/output/builtin/build/service/sidebar/asset/draggable/Draggable.d.ts

@@ -0,0 +1,14 @@
+import { DraggableData, DraggableEndType } from '@vyr/declare';
+import { Draggable as _Draggable } from "@vyr/runtime";
+import { Descriptor } from "@vyr/engine";
+import { VirtualNode } from "@vyr/service-rpc";
+declare class Draggable extends _Draggable<Descriptor> {
+    readonly id: string;
+    isVirtualNode(dragData: DraggableData<Descriptor | VirtualNode>): dragData is DraggableData<VirtualNode>;
+    starter(dragData: Descriptor): boolean;
+    validator(dragData: DraggableData<Descriptor | VirtualNode>, targetData: DraggableData<Descriptor>): boolean;
+    limit(dragData: DraggableData<Descriptor | VirtualNode>, targetData: DraggableData<Descriptor>, type: DraggableEndType): DraggableEndType;
+    finished(dragData: DraggableData<Descriptor | VirtualNode>, targetData: DraggableData<Descriptor>, type: DraggableEndType): void;
+    prefab(dragData: DraggableData<VirtualNode>, targetData: DraggableData<Descriptor>): Promise<void>;
+}
+export { Draggable };

package/output/builtin/build/service/sidebar/asset/draggable/index.d.ts

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

package/output/builtin/build/service/sidebar/asset/index.d.ts

@@ -0,0 +1,3 @@
+export * as action from './action';
+export * as draggable from './draggable';
+export * from './AssetNavigator';

package/output/builtin/build/service/sidebar/index.d.ts

@@ -0,0 +1,2 @@
+export * as scene from './scene';
+export * as asset from './asset';

package/output/builtin/build/service/sidebar/scene/Scene.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/output/builtin/build/service/sidebar/scene/SceneItem.vue.d.ts

@@ -0,0 +1,18 @@
+import { TreeOption } from '@vyr/design';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    data: {
+        default(): TreeOption;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    visible: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        default(): TreeOption;
+    };
+}>> & Readonly<{
+    onVisible?: ((...args: any[]) => any) | undefined;
+}>, {
+    data: TreeOption;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/output/builtin/build/service/sidebar/scene/SceneNavigator.d.ts

@@ -0,0 +1,36 @@
+import { DraggableData, DraggableEndType } from '@vyr/declare';
+import { Descriptor, DeserializationObject } from "@vyr/engine";
+import { Draggable, SidebarNavigator } from "@vyr/runtime";
+import { Job } from "@vyr/remote";
+import { Option } from "@vyr/design";
+import { VirtualNode } from "@vyr/service-rpc";
+declare class SceneNavigator extends SidebarNavigator {
+    static key: string;
+    createSceneOption: {
+        label: string;
+        value: string;
+    };
+    sceneOptions: Option[];
+    addScene: boolean;
+    newSceneName: string;
+    currentScene: string;
+    visibilityMap: {
+        [k: string]: boolean;
+    };
+    constructor();
+    active(): void;
+    unactive(): void;
+    private _updateScenes;
+    selectRootNode(): Promise<void>;
+    createScene(): Promise<void>;
+    deleteScene(index: number): Promise<void>;
+    updateVisibilityMapBySearch(): {
+        [k: string]: boolean;
+    };
+    finishedWhereInspectorDraggable(draggable: Draggable, dragData: DraggableData<VirtualNode>, targetData: DraggableData, type: DraggableEndType): void;
+    ensureReadonlyWhereInteraction(client: string): boolean;
+    saveWhereInteraction(content: DeserializationObject<Descriptor>): void;
+    remoteTransformEvent(task: InstanceType<typeof Job['invoke']['transform']['Response']>): void;
+    remotePickEvent(task: InstanceType<typeof Job['invoke']['pick']['Response']>): Promise<void>;
+}
+export { SceneNavigator };

package/output/builtin/build/service/sidebar/scene/action/AddNodeAction.d.ts

@@ -0,0 +1,54 @@
+import { Descriptor } from "@vyr/engine";
+import { Action } from "@vyr/runtime";
+declare class AddNodeAction extends Action {
+    static id: string;
+    static generate: (label: string, Class: typeof Descriptor) => {
+        label: string;
+        update(): void;
+        validator(): boolean;
+        execute(): void;
+        readonly id: string;
+        readonly value: number;
+        order: number;
+        trigger: number;
+        show: boolean;
+        disabled: boolean;
+        children: Action[];
+        active(): boolean;
+    };
+    generate: (label: string, Class: typeof Descriptor) => {
+        label: string;
+        update(): void;
+        validator(): boolean;
+        execute(): void;
+        readonly id: string;
+        readonly value: number;
+        order: number;
+        trigger: number;
+        show: boolean;
+        disabled: boolean;
+        children: Action[];
+        active(): boolean;
+    };
+    label: string;
+    order: number;
+    children: {
+        label: string;
+        update(): void;
+        validator(): boolean;
+        execute(): void;
+        readonly id: string;
+        readonly value: number;
+        order: number;
+        trigger: number;
+        show: boolean;
+        disabled: boolean;
+        children: Action[];
+        active(): boolean;
+    }[];
+    active(): boolean;
+    update(): void;
+    validator(): boolean;
+    execute(): void;
+}
+export { AddNodeAction };

package/output/builtin/build/service/sidebar/scene/action/AddServiceAction.d.ts

@@ -0,0 +1,54 @@
+import { Action } from "@vyr/runtime";
+import { Descriptor } from "@vyr/engine";
+declare class AddServiceAction extends Action {
+    static id: string;
+    static generate: (label: string, Class: typeof Descriptor) => {
+        label: string;
+        update(): void;
+        validator(): boolean;
+        execute(): void;
+        readonly id: string;
+        readonly value: number;
+        order: number;
+        trigger: number;
+        show: boolean;
+        disabled: boolean;
+        children: Action[];
+        active(): boolean;
+    };
+    generate: (label: string, Class: typeof Descriptor) => {
+        label: string;
+        update(): void;
+        validator(): boolean;
+        execute(): void;
+        readonly id: string;
+        readonly value: number;
+        order: number;
+        trigger: number;
+        show: boolean;
+        disabled: boolean;
+        children: Action[];
+        active(): boolean;
+    };
+    label: string;
+    order: number;
+    children: {
+        label: string;
+        update(): void;
+        validator(): boolean;
+        execute(): void;
+        readonly id: string;
+        readonly value: number;
+        order: number;
+        trigger: number;
+        show: boolean;
+        disabled: boolean;
+        children: Action[];
+        active(): boolean;
+    }[];
+    active(): boolean;
+    update(): void;
+    validator(): boolean;
+    execute(): void;
+}
+export { AddServiceAction };

package/output/builtin/build/service/sidebar/scene/action/ControllerAction.d.ts

@@ -0,0 +1,39 @@
+import { Descriptor } from '@vyr/engine';
+import { Action, DataService } from '@vyr/runtime';
+import { TreeOption } from '@vyr/design';
+import { SceneService } from '@vyr/service-scene';
+interface Controller {
+    expand: (item: Descriptor, type?: boolean) => void;
+    change: (items: Descriptor[]) => void;
+    search: () => void;
+}
+declare class ControllerAction extends Action {
+    static id: string;
+    static options: string[];
+    controller: Controller;
+    label: string;
+    code: string;
+    setController(controller: Controller): void;
+    active(): boolean;
+    validator(e: KeyboardEvent): boolean;
+    update(): void;
+    private useCurrentSelectItem;
+    private getVisibleCollection;
+    private expand;
+    private enter;
+    private quit;
+    private moveup;
+    private movedown;
+    changeTransform(): void;
+    execute(): void;
+    changeTransformController(clean?: boolean): void;
+    createScene: (name: string, sceneService?: SceneService) => void;
+    deleteScene: (url: string, sceneService?: SceneService) => void;
+    changeScene: (url: string, sceneService?: SceneService) => void;
+    changeSceneItem: (items: Descriptor[], sceneService?: SceneService, dataService?: DataService) => void;
+    getSceneItemVisible: (item: TreeOption) => boolean;
+    addSceneItem: (name: string, item: Descriptor, sceneService?: SceneService, dataService?: DataService) => void;
+    renameSceneItem: (name: string, item: Descriptor, sceneService?: SceneService, dataService?: DataService) => void;
+    setSceneItemVisible: (item: Descriptor, sceneService?: SceneService) => void;
+}
+export { ControllerAction };

package/output/builtin/build/service/sidebar/scene/action/CopyAction.d.ts

@@ -0,0 +1,14 @@
+import { Action, DataService } from "@vyr/runtime";
+declare class CopyAction extends Action {
+    static id: string;
+    label: string;
+    active(): boolean;
+    validator(e: KeyboardEvent): boolean;
+    updateRightMenu(): void;
+    updateShortcutkey(): void;
+    update(): void;
+    executeRightMenu(dataService: DataService): void;
+    executeShortcutkey(dataService: DataService): void;
+    execute(): void;
+}
+export { CopyAction };

package/output/builtin/build/service/sidebar/scene/action/CutAction.d.ts

@@ -0,0 +1,14 @@
+import { Action, DataService } from "@vyr/runtime";
+declare class CutAction extends Action {
+    static id: string;
+    label: string;
+    active(): boolean;
+    validator(e: KeyboardEvent): boolean;
+    updateRightMenu(): void;
+    updateShortcutkey(): void;
+    update(): void;
+    executeRightMenu(dataService: DataService): void;
+    executeShortcutkey(dataService: DataService): void;
+    execute(): void;
+}
+export { CutAction };

package/output/builtin/build/service/sidebar/scene/action/DeleteAction.d.ts

@@ -0,0 +1,15 @@
+import { Action, DataService } from "@vyr/runtime";
+import { SceneService } from "@vyr/service-scene";
+declare class DeleteAction extends Action {
+    static id: string;
+    label: string;
+    active(): boolean;
+    validator(e: KeyboardEvent): boolean;
+    updateRightMenu(): void;
+    updateShortcutkey(): void;
+    update(): void;
+    executeRightMenu(dataService: DataService, sceneService: SceneService): void;
+    executeShortcutkey(dataService: DataService, sceneService: SceneService): void;
+    execute(): void;
+}
+export { DeleteAction };

package/output/builtin/build/service/sidebar/scene/action/RenameAction.d.ts

@@ -0,0 +1,14 @@
+import { Action, DataService } from "@vyr/runtime";
+declare class RenameAction extends Action {
+    static id: string;
+    label: string;
+    active(): boolean;
+    validator(e: KeyboardEvent): boolean;
+    updateRightMenu(): void;
+    updateShortcutkey(): void;
+    update(): void;
+    executeRightMenu(dataService: DataService): void;
+    executeShortcutkey(dataService: DataService): void;
+    execute(): void;
+}
+export { RenameAction };

package/output/builtin/build/service/sidebar/scene/action/SaveAction.d.ts

@@ -0,0 +1,14 @@
+import { Action, DataService } from "@vyr/runtime";
+declare class SaveAction extends Action {
+    static id: string;
+    label: string;
+    active(): boolean;
+    validator(e: KeyboardEvent): boolean;
+    updateRightMenu(): void;
+    updateShortcutkey(): void;
+    update(): void;
+    executeRightMenu(dataService: DataService): void;
+    executeShortcutkey(dataService: DataService): void;
+    execute(): void;
+}
+export { SaveAction };

package/output/builtin/build/service/sidebar/scene/action/StickupAction.d.ts

@@ -0,0 +1,15 @@
+import { Action, DataService } from "@vyr/runtime";
+import { SceneService } from "@vyr/service-scene";
+declare class StickupAction extends Action {
+    static id: string;
+    label: string;
+    active(): boolean;
+    validator(e: KeyboardEvent): boolean;
+    updateRightMenu(): void;
+    updateShortcutkey(): void;
+    update(): void;
+    executeRightMenu(dataService: DataService, sceneService: SceneService): void;
+    executeShortcutkey(dataService: DataService, sceneService: SceneService): void;
+    execute(): void;
+}
+export { StickupAction };

package/output/builtin/build/service/sidebar/scene/action/index.d.ts

@@ -0,0 +1,9 @@
+export * from './ControllerAction';
+export * from './AddServiceAction';
+export * from './AddNodeAction';
+export * from './SaveAction';
+export * from './CopyAction';
+export * from './CutAction';
+export * from './StickupAction';
+export * from './DeleteAction';
+export * from './RenameAction';

package/output/builtin/build/service/sidebar/scene/draggable/Draggable.d.ts

@@ -0,0 +1,14 @@
+import { DraggableData, DraggableEndType } from '@vyr/declare';
+import { Draggable as _Draggable } from "@vyr/runtime";
+import { Descriptor } from "@vyr/engine";
+import { VirtualNode } from "@vyr/service-rpc";
+declare class Draggable extends _Draggable<Descriptor> {
+    readonly id: string;
+    isVirtualNode(dragData: DraggableData<Descriptor | VirtualNode>): dragData is DraggableData<VirtualNode>;
+    starter(dragData: Descriptor): boolean;
+    validator(dragData: DraggableData<Descriptor | VirtualNode>, targetData: DraggableData<Descriptor>): boolean;
+    limit(dragData: DraggableData<Descriptor | VirtualNode>, targetData: DraggableData<Descriptor>, type: DraggableEndType): DraggableEndType;
+    finished(dragData: DraggableData<Descriptor | VirtualNode>, targetData: DraggableData<Descriptor>, type: DraggableEndType): void;
+    prefab(dragData: DraggableData<VirtualNode>, targetData: DraggableData<Descriptor>): Promise<void>;
+}
+export { Draggable };

package/output/builtin/build/service/sidebar/scene/draggable/index.d.ts

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

package/output/builtin/build/service/sidebar/scene/index.d.ts

@@ -0,0 +1,3 @@
+export * as action from './action';
+export * as draggable from './draggable';
+export * from './SceneNavigator';

package/output/builtin/build/singleton/index.d.ts

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

package/output/builtin/build/singleton/rightMenu.d.ts

@@ -0,0 +1,10 @@
+import { Action, ActionGroup } from "@vyr/runtime";
+declare class RightMenu {
+    private status;
+    private vm;
+    constructor();
+    show(group: ActionGroup, x: number, y: number): Promise<void | Action>;
+    hide(): void;
+}
+declare const rightMenu: RightMenu;
+export { RightMenu, rightMenu };

package/output/builtin/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@vyr/builtin",
+  "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/builtin/src/shims-vue.d.ts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+declare module '*.vue' {
+  const component: DefineComponent<{}, {}, any>
+  export default component
+}
+
+declare module '!!raw-loader!*' {
+  const v: string
+  export default v
+}

package/output/class-wrapper-plugin/index.js

@@ -0,0 +1,42 @@
+const { join, resolve } = require("path")
+
+class ClassWrapperPlugin {
+
+  constructor(rules = []) {
+    const handlers = [
+      { path: join(__dirname, '../../packages/universal/engine'), className: 'ObjectPool' },
+      { path: join(__dirname, '../../packages/universal/engine'), className: 'Descriptor' },
+      { path: join(__dirname, '../../packages/universal/engine'), className: 'InputSystem' },
+      { path: join(__dirname, '../../packages/universal/engine'), className: 'DynamicInterpreter' },
+    ]
+    this.rules = handlers.filter(handler => rules.includes(handler.className))
+  }
+
+  validate(path) {
+    for (const rule of this.rules) {
+      if (path.indexOf(rule.path) > -1 && path.indexOf(rule.className) > -1) return rule
+    }
+  }
+
+  wrapper(module, rule) {
+    const custom = {
+      loader: resolve(__dirname, './loaders/index'),
+      options: JSON.stringify({ className: rule.className })
+    }
+    module.loaders.push(custom)
+  }
+
+  compiler(module) {
+    if (!module.request) return
+    const rule = this.validate(module.request)
+    if (rule) return this.wrapper(module, rule)
+  }
+
+  apply(compiler) {
+    compiler.hooks.compilation.tap('class-wrapper-plugin', (compilation) => {
+      compilation.hooks.buildModule.tap('class-wrapper-plugin', (module) => this.compiler(module))
+    })
+  }
+}
+
+module.exports = ClassWrapperPlugin

package/output/class-wrapper-plugin/loaders/descriptor.js

@@ -0,0 +1,89 @@
+const types = require('@babel/types');
+const { default: traverse } = require('@babel/traverse')
+const { vueImportDeclaration, wrapperDeclaration, wrapperIdentifier, wrapperCall, returnwrapper } = require('../utils')
+
+const pushRetuenStatement = (block) => {
+  // 假设block是一个BlockStatement节点  
+  if (!types.isBlockStatement(block)) return
+  // 获取BlockStatement的最后一个语句  
+  const lastStatement = block.body[block.body.length - 1];
+  // 检查这个语句是否是ReturnStatement  
+  if (types.isReturnStatement(lastStatement)) return
+  //添加 return 语句
+  block.body.push(returnwrapper)
+}
+const wrapperConstructor = (p) => {
+  p.traverse({
+    CallExpression(path) {
+      if (
+        types.isMemberExpression(path.node.callee) &&
+        path.node.callee.object.type === 'ThisExpression' &&
+        path.node.callee.property.name === 'add'
+      ) {
+
+        const newCallee = types.memberExpression(wrapperCall, types.identifier('add'));
+        path.node.callee = newCallee;
+      }
+    },
+    ReturnStatement(path) {
+      path.replaceWith(returnwrapper)
+    }
+  })
+  pushRetuenStatement(p.node.body)
+  p.stop()
+}
+const validateConstructor = (p, options) => {
+  if (types.isClassMethod(p.node) === false) return false
+  if (p.node.kind !== 'constructor') return false
+  return p.parentPath.parent.id.name === options.className
+}
+
+const wrapperMethod = (p) => {
+  const instance = p.node.params[0]
+  p.traverse({
+    MemberExpression(path) {
+      if (
+        path.node.object.type === 'Identifier' &&
+        path.node.object.name === 'instance' &&
+        !path.parentPath.isMemberExpression()
+      ) {
+        const vueCallInstance = types.callExpression(wrapperIdentifier, [instance]);
+        const newMemberExpression = types.memberExpression(vueCallInstance, path.node.property);
+        path.replaceWith(newMemberExpression);
+      }
+    }
+  })
+  p.stop()
+}
+const validateMethod = (p, options) => {
+  if (types.isClassMethod(p.node) === false) return false
+  if (p.node.kind !== 'method') return false
+  if (p.node.key.name !== 'beenInstantiated') return false
+  return p.parentPath.parent.id.name === options.className
+}
+
+const wrapperDescriptor = (ast, options) => {
+  //添加导入语句
+  ast.program.body.splice(2, 0, vueImportDeclaration)
+  ast.program.body.splice(3, 0, wrapperDeclaration)
+
+  traverse(ast, {
+    enter: (p) => {
+      if (validateConstructor(p, options)) wrapperConstructor(p)
+    }
+  })
+
+  traverse(ast, {
+    enter: (p) => {
+      if (validateMethod(p, options)) wrapperMethod(p)
+    }
+  })
+}
+const validateDescriptor = (options) => {
+  return options.className === 'Descriptor'
+}
+
+module.exports = {
+  wrapperDescriptor,
+  validateDescriptor,
+}

package/output/class-wrapper-plugin/loaders/dynamic-interpreter.js

@@ -0,0 +1,54 @@
+const types = require('@babel/types');
+const { parse } = require('@babel/parser')
+const { default: traverse } = require('@babel/traverse')
+
+const wrapperMethod = (p) => {
+    const newCode = `
+        function checkCode(){
+            if (this._currentDepth > 3000) {
+                observer.trigger('__VYR_RUNTIME@remote', { type: 'Dynamic', uuid: this.unit.uuid })
+                return
+            }
+        }
+        `;
+
+    // 解析新代码为AST
+    const newAst = parse(newCode, {
+        sourceType: 'module',
+    });
+
+    // 获取函数声明中的函数体语句
+    const functionDeclaration = newAst.program.body[0];
+    const functionBodyStatements = functionDeclaration.body.body;
+
+    // 获取目标方法体的语句数组
+    const methodBody = p.node.body.body;
+
+    // 将函数体中的语句插入到目标方法体的开头
+    methodBody.unshift(...functionBodyStatements);
+
+    p.stop()
+}
+
+const validateMethod = (p, options) => {
+    if (types.isClassMethod(p.node) === false) return false
+    if (p.node.kind !== 'method') return false
+    if (p.node.key.name !== '_markSubDynamic') return false
+    return p.parentPath.parent.id.name === options.className
+}
+
+const wrapperDynamicInterpreter = (ast, options) => {
+    traverse(ast, {
+        enter: (p) => {
+            if (validateMethod(p, options)) wrapperMethod(p)
+        }
+    })
+}
+const validateDynamicInterpreter = (options) => {
+    return options.className === 'DynamicInterpreter'
+}
+
+module.exports = {
+    wrapperDynamicInterpreter,
+    validateDynamicInterpreter,
+}