@vyr/cli 0.0.12 → 0.0.13

package/output/engine/src/math/index.ts

@@ -0,0 +1,5 @@
+export * from './Vector2'
+export * from './Vector3'
+export * from './Euler'
+export * from './Quaternion'
+export * from './Matrix4'

package/output/engine/src/math/utils.ts

@@ -0,0 +1,17 @@
+/**
+ * Clamps the given value between min and max.
+ *
+ * @param {number} value - The value to clamp.
+ * @param {number} min - The min value.
+ * @param {number} max - The max value.
+ * @return {number} The clamped value.
+ */
+function clamp(value: number, min: number, max: number) {
+
+    return Math.max(min, Math.min(max, value));
+
+}
+
+export {
+    clamp
+}

package/output/engine/src/preset/execute/dataset/compile.ts

@@ -0,0 +1,99 @@
+import { language } from "../../../locale";
+import { Asset } from "../../../asset";
+import { InteractionNode, Scriptable, ScriptableArgs } from "../../../interaction";
+import { DatasetDescriptor, Descriptor, HttpDataConfig } from "../../../descriptor";
+import { Graphics } from "../../../graphics";
+import { ExecuteScriptable as HttpScriptable } from "../net/http";
+
+const scriptable = Asset.createVirtualUrl('preset/dataset/compile.ts')
+class ExecuteScriptable extends Scriptable {
+
+    async getData(config: HttpDataConfig, http: HttpScriptable, trigger: Descriptor, graphics: Graphics) {
+        const args: ScriptableArgs = {
+            input: {
+                previous: '',
+                user: {
+                    type: { value: config.type },
+                    url: { value: config.url },
+                    data: { value: '' },
+                },
+                default: {}
+            },
+            result: new Map(),
+            trigger: trigger
+        }
+
+        const data = await http.execute(graphics, args)
+
+        return this.transformData(data, config)
+    }
+
+    transformData(data: any, config: HttpDataConfig) {
+        return data
+    }
+
+    async execute(graphics: Graphics, args: ScriptableArgs) {
+        const { trigger } = args
+
+        if (trigger instanceof DatasetDescriptor && trigger.dataConfigs.length > 0) {
+            const dataConfigs = trigger.dataConfigs as HttpDataConfig[]
+            const http = new HttpScriptable(Asset.createVirtualUrl('preset/dataset/compile/http.ts'))
+
+            let mergeData: any[] | any
+            if (dataConfigs.length === 1) {
+                const config = dataConfigs[0]
+                const finalData = await this.getData(config, http, trigger, graphics)
+                mergeData = config.key ? { [config.key]: finalData } : finalData
+            } else {
+                const keys = new Set<string>()
+                const queue: Promise<any>[] = []
+                for (const config of dataConfigs) {
+                    keys.add(config.key)
+
+                    const task = this.getData(config, http, trigger, graphics).then(finalData => {
+                        const first = keys.values().next().value
+                        if (keys.size === 1 && (first === '' || first === undefined)) {
+                            if (!mergeData) mergeData = []
+                            mergeData.push(finalData)
+                        } else {
+                            if (!mergeData) mergeData = {}
+                            mergeData[config.key] ? Object.assign(mergeData[config.key], finalData) : mergeData[config.key] = finalData
+                        }
+                    })
+                    queue.push(task)
+                }
+                await Promise.all(queue)
+            }
+
+            trigger.setData(mergeData)
+        }
+    }
+}
+Asset.provider(scriptable, async () => ({ default: ExecuteScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: InteractionNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        interaction: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/output/engine/src/preset/execute/dataset/index.ts

@@ -0,0 +1,2 @@
+export * as update from './update'
+export * as compile from './compile'

package/output/engine/src/preset/execute/dataset/update.ts

@@ -0,0 +1,51 @@
+import { language } from "../../../locale";
+import { Asset } from "../../../asset";
+import { DatasetDescriptor } from "../../../descriptor";
+import { InteractionNode, Scriptable, ScriptableArgs } from "../../../interaction";
+import { Graphics } from "../../../graphics";
+import { Category } from "../../../Category";
+
+const scriptable = Asset.createVirtualUrl('preset/dataset/update.ts')
+class ExecuteScriptable extends Scriptable {
+    async execute(graphics: Graphics, args: ScriptableArgs) {
+        const { input, result } = args
+        const dataset = input?.user?.dataset.value ?? input.default.dataset.value
+
+        const previous = result.get(input.previous)
+        const datasetDescriptor = Asset.get<DatasetDescriptor>(dataset)
+        if (datasetDescriptor instanceof DatasetDescriptor) {
+            if (previous) datasetDescriptor.setData(previous)
+        }
+
+        return {}
+    }
+}
+Asset.provider(scriptable, async () => ({ default: ExecuteScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+        dataset: { value: args.dataset ?? '', type: Category.dataset }
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: InteractionNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        interaction: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/output/engine/src/preset/execute/graphics/index.ts

@@ -0,0 +1 @@
+export * as invoke from './invoke'

package/output/engine/src/preset/execute/graphics/invoke.ts

@@ -0,0 +1,48 @@
+import { language } from "../../../locale";
+import { Asset } from "../../../asset";
+import { Descriptor } from "../../../descriptor";
+import { InteractionNode, Scriptable, ScriptableArgs } from "../../../interaction";
+import { Graphics } from "../../../graphics";
+
+const scriptable = Asset.createVirtualUrl('preset/graphics/invoke.ts')
+class ExecuteScriptable extends Scriptable {
+    async execute(graphics: Graphics, args: ScriptableArgs) {
+        const { input } = args
+        const interaction = input?.user?.interaction.value ?? input.default.interaction.value
+        const target = input?.user?.target.value ?? input.default.target.value
+        const targetDescriptor = Descriptor.get<Descriptor>(target)
+        if (interaction && targetDescriptor) {
+            graphics.invoke(interaction, targetDescriptor)
+        }
+    }
+}
+Asset.provider(scriptable, async () => ({ default: ExecuteScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+        target: { value: args.target ?? '' },
+        interaction: { value: args.interaction ?? '' },
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: InteractionNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        interaction: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/output/engine/src/preset/execute/index.ts

@@ -0,0 +1,4 @@
+export * as net from './net'
+export * as dataset from './dataset'
+export * as scheduler from './scheduler'
+export * as graphics from './graphics'

package/output/engine/src/preset/execute/net/http.ts

@@ -0,0 +1,95 @@
+import { language } from "../../../locale";
+import { Asset } from "../../../asset";
+import { HttpType } from "../../../utils";
+import { Graphics } from "../../../graphics";
+import { Scriptable, InteractionNode, ScriptableArgs } from "../../../interaction";
+
+const scriptable = Asset.createVirtualUrl('preset/net/http.ts')
+class ExecuteScriptable extends Scriptable {
+
+    joinUrl(url: string, requestData: any) {
+        const urlObj = new URL(Asset.joinUrl(url));
+
+        // 直接将requestData添加到urlObj的searchParams中
+        Object.entries(requestData).forEach(([key, value]) => {
+            if (value !== null && value !== undefined) {
+                urlObj.searchParams.set(key, String(value));
+            }
+        });
+
+        return urlObj.toString()
+    }
+
+    async execute(graphics: Graphics, args: ScriptableArgs) {
+        const { input, result } = args
+        let url = input?.user?.url.value ?? input.default.url.value
+        const type: string = input?.user?.type.value ?? input.default.type.value
+        const data: string = input?.user?.data.value ?? input.default.data.value
+
+        const requestData: { [k: string]: any } = {}
+        const keys: string[] = []
+        if (data.trim().length === 0) {
+            keys.push(...result.keys())
+        } else {
+            keys.push(...data.split(','))
+        }
+
+        for (const key of keys) {
+            const value = result.get(key)
+            Object.assign(requestData, value ?? {})
+        }
+
+        url = url.replace(/\${(\w+)}/g, (match: any, key: string) => {
+            return requestData.hasOwnProperty(key) ? requestData[key] : match;
+        })
+
+        const config = {
+            method: type,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        }
+        let res
+        if (type === HttpType.GET) {
+            res = await fetch(this.joinUrl(url, requestData), config)
+        } else {
+            res = await fetch(url, { ...config, body: JSON.stringify(requestData) })
+        }
+
+        const json = await res.json()
+
+        return json
+    }
+}
+Asset.provider(scriptable, async () => ({ default: ExecuteScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+        url: { value: args.url ?? '' },
+        type: { value: args.type ?? '' },
+        data: { value: args.data ?? '' },
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: InteractionNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        interaction: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    ExecuteScriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/output/engine/src/preset/execute/net/index.ts

@@ -0,0 +1 @@
+export * as http from './http'

package/output/engine/src/preset/execute/scheduler/index.ts

@@ -0,0 +1 @@
+export * as switch from './switch'

package/output/engine/src/preset/execute/scheduler/switch.ts

@@ -0,0 +1,46 @@
+import { language } from "../../../locale";
+import { Asset } from "../../../asset";
+import { ServiceSchedulerDescriptor } from "../../../descriptor";
+import { InteractionNode, Scriptable, ScriptableArgs } from "../../../interaction";
+import { Graphics } from "../../../graphics";
+
+const scriptable = Asset.createVirtualUrl('preset/scheduler/switch.ts')
+class ExecuteScriptable extends Scriptable {
+    async execute(graphics: Graphics, args: ScriptableArgs) {
+        const scene = args.input?.user?.scene.value
+        if (!scene) return
+        await Asset.loadAll(scene)
+        await Asset.compileDataset(scene, graphics.engine)
+        const scheduler = Asset.get<ServiceSchedulerDescriptor>(scene)
+        graphics.engine.switch(scheduler)
+    }
+}
+Asset.provider(scriptable, async () => ({ default: ExecuteScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+        scene: { value: args.scene ?? '' },
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: InteractionNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        interaction: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/output/engine/src/preset/index.ts

@@ -0,0 +1,7 @@
+import * as executePreset from './execute'
+import * as interactionPreset from './interaction'
+
+export {
+    executePreset,
+    interactionPreset
+}

package/output/engine/src/preset/interaction/dataset/compile.ts

@@ -0,0 +1,27 @@
+import { Asset } from "../../../asset";
+import { InteractionDescriptor } from "../../../interaction";
+import { dataset } from "../../execute"
+
+const url = Asset.createVirtualUrl('preset/dataset/compile.interaction.json')
+const nodes = {
+    compile: 'compile'
+}
+let _currentInteraction: InteractionDescriptor | null = null
+const interactionProvider = async () => {
+    if (_currentInteraction === null) {
+        _currentInteraction = new InteractionDescriptor()
+        const compileNode = dataset.compile.createExecuteNode({ id: nodes.compile })
+        _currentInteraction.addNode([compileNode])
+        _currentInteraction.roots.push(compileNode.id)
+    }
+    return _currentInteraction
+}
+
+Asset.provider(url, interactionProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/output/engine/src/preset/interaction/dataset/index.ts

@@ -0,0 +1 @@
+export * as compile from "./compile"

package/output/engine/src/preset/interaction/graphics/index.ts

@@ -0,0 +1 @@
+export * as invoke from "./invoke"

package/output/engine/src/preset/interaction/graphics/invoke.ts

@@ -0,0 +1,27 @@
+import { Asset } from "../../../asset";
+import { InteractionDescriptor } from "../../../interaction";
+import { graphics } from "../../execute"
+
+const url = Asset.createVirtualUrl('preset/graphics/invoke.interaction.json')
+const nodes = {
+    invoke: 'invoke'
+}
+let _currentInteraction: InteractionDescriptor | null = null
+const interactionProvider = async () => {
+    if (_currentInteraction === null) {
+        _currentInteraction = new InteractionDescriptor()
+        const invokeNode = graphics.invoke.createExecuteNode({ id: nodes.invoke })
+        _currentInteraction.addNode([invokeNode])
+        _currentInteraction.roots.push(invokeNode.id)
+    }
+    return _currentInteraction
+}
+
+Asset.provider(url, interactionProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/output/engine/src/preset/interaction/index.ts

@@ -0,0 +1,3 @@
+export * as dataset from './dataset'
+export * as scheduler from './scheduler'
+export * as graphics from './graphics'

package/output/engine/src/preset/interaction/scheduler/index.ts

@@ -0,0 +1 @@
+export * as switch from "./switch"

package/output/engine/src/preset/interaction/scheduler/switch.ts

@@ -0,0 +1,27 @@
+import { Asset } from "../../../asset";
+import { InteractionDescriptor } from "../../../interaction";
+import { scheduler } from "../../execute"
+
+const url = Asset.createVirtualUrl('preset/scheduler/switch.interaction.json')
+const nodes = {
+    switch: 'switch',
+}
+let _currentInteraction: InteractionDescriptor | null = null
+const interactionProvider = async () => {
+    if (_currentInteraction === null) {
+        _currentInteraction = new InteractionDescriptor()
+        const switchNode = scheduler.switch.createExecuteNode({ id: nodes.switch })
+        _currentInteraction.addNode([switchNode])
+        _currentInteraction.roots.push(switchNode.id)
+    }
+    return _currentInteraction
+}
+
+Asset.provider(url, interactionProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/output/engine/src/setup/index.ts

@@ -0,0 +1,17 @@
+import { StyleDescriptor } from "../descriptor"
+import { StyleInterpreter } from "../interpreter"
+import { StyleActor } from "../actor"
+
+let needSetupStyle = false
+const setupStyle = () => {
+    if (needSetupStyle === true) return
+    needSetupStyle = true
+    const actor = new StyleActor()
+    actor.update(StyleDescriptor.basicStyle, StyleDescriptor.basicName)
+    const styleValues = actor.getStyleValue()
+    StyleInterpreter.insertRule(styleValues)
+}
+
+export {
+    setupStyle
+}

package/output/engine/src/utils/AssetProvider.ts

@@ -0,0 +1,73 @@
+import { InteractionDescriptor, InteractionNode, InteractionProperty } from "../interaction"
+import { Descriptor, DynamicDescriptor, PrefabInstanceDescriptor, HTMLDescriptor, StyleDescriptor } from "../descriptor"
+import { AssetGraph, Port } from "../asset"
+import { Category } from "../Category"
+
+const interactionExecutor = (interaction: InteractionProperty, path: string, port: Port) => {
+    const keys = Object.keys(interaction.inputs)
+    for (const key of keys) {
+        const input = interaction.inputs[key]
+        const params = Object.keys(input)
+        for (const param of params) {
+            const value = input[param]
+            if (value.type === undefined || Category.isDescriptor(value.type, 'category') === false) continue
+            if (value.value) port.edges.push({ key: `${path}.inputs.${key}.${param}.value`, category: value.type, asset: value.value })
+        }
+    }
+}
+const interactionNodeExecutor = (node: InteractionNode, path: string, port: Port) => {
+    const params = Object.keys(node.input)
+    for (const param of params) {
+        const value = node.input[param]
+        if (value.type === undefined || Category.isDescriptor(value.type, 'category') === false) continue
+        if (value.value) port.edges.push({ key: `${path}.input.${param}.value`, category: value.type, asset: value.value })
+    }
+}
+
+const DescriptorProvider = (descriptor: Descriptor, port: Port) => {
+    if (descriptor.interactions.length > 0) {
+        for (let i = 0; i < descriptor.interactions.length; i++) {
+            const interaction = descriptor.interactions[i]
+            if (interaction.url) {
+                interactionExecutor(interaction, `interactions[${i}]`, port)
+                port.edges.push({ key: `interactions[${i}].url`, category: Category.interaction, asset: interaction.url })
+            }
+        }
+    }
+    if (descriptor.dataset) port.edges.push({ key: 'dataset', category: Category.dataset, asset: descriptor.dataset })
+}
+
+const StyleDescriptorProvider = (descriptor: StyleDescriptor, port: Port) => {
+    if (descriptor.inherit) port.edges.push({ key: 'inherit', category: Category.style, asset: descriptor.inherit })
+}
+
+const InteractionDescriptorProvider = (descriptor: InteractionDescriptor, port: Port) => {
+    if (descriptor.nodes.length > 0) {
+        for (let i = 0; i < descriptor.nodes.length; i++) {
+            const node = descriptor.nodes[i]
+            if (node.url) {
+                interactionNodeExecutor(node, `nodes[${i}]`, port)
+                port.edges.push({ key: `nodes[${i}].url`, category: Category.ts, asset: node.url })
+            }
+        }
+    }
+}
+
+const HTMLDescriptorProvider = (descriptor: HTMLDescriptor, port: Port) => {
+    if (descriptor.style) port.edges.push({ key: 'style', category: Category.style, asset: descriptor.style })
+}
+
+const DynamicDescriptorProvider = (descriptor: DynamicDescriptor, port: Port) => {
+    if (descriptor.url) port.edges.push({ key: 'url', category: Category.prefab, asset: descriptor.url })
+}
+
+const PrefabInstanceDescriptorProvider = (descriptor: PrefabInstanceDescriptor, port: Port) => {
+    if (descriptor.url) port.edges.push({ key: 'url', category: Category.prefab, asset: descriptor.url })
+}
+
+AssetGraph.register(Descriptor.type, DescriptorProvider)
+AssetGraph.register(StyleDescriptor.type, StyleDescriptorProvider)
+AssetGraph.register(InteractionDescriptor.type, InteractionDescriptorProvider)
+AssetGraph.register(HTMLDescriptor.type, HTMLDescriptorProvider)
+AssetGraph.register(DynamicDescriptor.type, DynamicDescriptorProvider)
+AssetGraph.register(PrefabInstanceDescriptor.type, PrefabInstanceDescriptorProvider)

package/output/engine/src/utils/constants.ts

@@ -0,0 +1,10 @@
+enum HttpType {
+    GET = 'GET',
+    POST = 'POST',
+    PUT = 'PUT',
+    DELETE = 'DELETE',
+}
+
+export {
+    HttpType
+}

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

@@ -0,0 +1,2 @@
+export * from './constants'
+export * from './AssetProvider'

package/output/engine/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/locale/build/index.d.ts

@@ -0,0 +1,18 @@
+interface LanguageProvider {
+    id: string;
+    name: string;
+}
+declare class Language<T extends LanguageProvider = LanguageProvider> {
+    private _provider;
+    readonly name: string;
+    constructor(provider: T);
+    private _replaceParams;
+    get(key: keyof T, params?: Partial<Record<string, string | number>>): string;
+    setProvider(provider: T): void;
+}
+declare class Locale {
+    static register(language: LanguageProvider): void;
+    static use(id: string): void;
+    static getLanguage<T extends LanguageProvider = LanguageProvider>(name: string): Language<T>;
+}
+export { LanguageProvider, Language, Locale, };