@vyr/engine 0.0.33 → 0.0.35

package/src/scripts/ConditionScriptable.ts

@@ -0,0 +1,196 @@
+import z from 'zod'
+import { language } from '../locale'
+import { Graphics } from '../graphics/Graphics'
+import { Scriptable, ScriptableArgs } from '../Scriptable'
+
+const DataTypeSchema = z.enum([
+    'string',
+    'number',
+    'boolean',
+    'bigint',
+    'symbol',
+    'object',
+    'array',
+    'regexp',
+])
+
+const CompareOperatorSchema = z.enum([
+    '=',
+    '!=',
+    '>',
+    '>=',
+    '<',
+    '<=',
+    '===',
+    '!==',
+    'in',
+    'notIn',
+    'between',
+    'notBetween',
+    'contains',
+    'startsWith',
+    'endsWith',
+    'matches',
+]).describe(language.get('scriptable.condition.operator.description'))
+
+const LogicOperatorSchema = z.enum(['AND', 'OR', 'NOT', 'XOR', 'NAND', 'NOR']).describe(
+    language.get('scriptable.condition.logic.description')
+)
+
+const CompareSchema = z.object({
+    op: CompareOperatorSchema,
+    value: z.any().describe(language.get('scriptable.condition.operator.value')),
+    value2: z.any().optional().describe(language.get('scriptable.condition.operator.value2'))
+})
+
+const LogicSchema = z.object({
+    op: LogicOperatorSchema,
+    rules: z.array(z.lazy(() => RuleSchema)).describe(language.get('scriptable.condition.logic.rules'))
+})
+
+const RuleSchema: z.ZodType<any> = z.object({
+    type: DataTypeSchema.describe(language.get('scriptable.condition.rule.type')),
+    field: z.string().optional().describe(language.get('scriptable.condition.rule.field')),
+    compare: CompareSchema.optional().describe(language.get('scriptable.condition.rule.compare')),
+    logic: LogicSchema.optional().describe(language.get('scriptable.condition.rule.logic'))
+})
+
+export class ConditionScriptable extends Scriptable {
+    static id = 'condition'
+    static name = language.get('scriptable.condition.name')
+    static inputSchame = z.object({
+        nodeId: z.string().default('').describe(language.get('scriptable.condition.input.nodeId')),
+        rules: z.array(RuleSchema).default([]).describe(language.get('scriptable.condition.input.rules'))
+    })
+    static outputSchame = z.object({ success: z.boolean().describe(language.get('scriptable.condition.output.success')) })
+
+    execute(graphics: Graphics, trigger: string, input: z.infer<typeof ConditionScriptable.inputSchame>, args?: ScriptableArgs) {
+        if (args === undefined) return { success: false }
+        if (input.rules.length === 0) return { success: true }
+
+        const value = args.result.get(input.nodeId) ?? args.result.get(args.previous)
+
+        const success = input.rules.every(rule => this.validateRule(value, rule))
+
+        return { success }
+    }
+
+    /**
+     * 根据规则验证值
+     */
+    private validateRule(value: any, rule: any): boolean {
+        if (rule.type === undefined) return false
+
+        const actualValue = rule.field ? this.getFieldValue(value, rule.field) : value
+
+        if (this.validateType(actualValue, rule.type) === false) {
+            return false
+        }
+
+        if (rule.compare && this.validateCompare(actualValue, rule.compare) === false) {
+            return false
+        }
+
+        if (rule.logic && this.validateLogic(actualValue, rule.logic) === false) {
+            return false
+        }
+
+        return true
+    }
+
+    /**
+     * 获取字段值（支持点号访问嵌套属性）
+     */
+    private getFieldValue(obj: any, field: string): any {
+        return field.split('.').reduce((acc, key) => {
+            return acc && typeof acc === 'object' ? acc[key] : undefined
+        }, obj)
+    }
+
+    /**
+     * 验证类型
+     */
+    private validateType(value: any, type: string): boolean {
+        if (type === 'array') {
+            return Array.isArray(value)
+        }
+        if (type === 'regexp') {
+            return value instanceof RegExp
+        }
+        return typeof value === type
+    }
+
+    /**
+     * 验证比较操作
+     */
+    private validateCompare(value: any, compare: { op: string; value: any; value2?: any }): boolean {
+        const { op, value: targetValue, value2 } = compare
+
+        switch (op) {
+            case '=':
+                return value == targetValue
+            case '!=':
+                return value != targetValue
+            case '>':
+                return value > targetValue
+            case '>=':
+                return value >= targetValue
+            case '<':
+                return value < targetValue
+            case '<=':
+                return value <= targetValue
+            case '===':
+                return value === targetValue
+            case '!==':
+                return value !== targetValue
+            case 'in':
+                return Array.isArray(targetValue) && targetValue.includes(value)
+            case 'notIn':
+                return !Array.isArray(targetValue) || !targetValue.includes(value)
+            case 'between':
+                return value2 !== undefined && value >= targetValue && value <= value2
+            case 'notBetween':
+                return value2 !== undefined && (value < targetValue || value > value2)
+            case 'contains':
+                return typeof value === 'string' && value.includes(targetValue)
+            case 'startsWith':
+                return typeof value === 'string' && value.startsWith(targetValue)
+            case 'endsWith':
+                return typeof value === 'string' && value.endsWith(targetValue)
+            case 'matches':
+                return typeof value === 'string' && new RegExp(targetValue).test(value)
+            default:
+                return false
+        }
+    }
+
+    /**
+     * 验证逻辑组合
+     */
+    private validateLogic(value: any, logic: { op: string; rules: any[] }): boolean {
+        const { op, rules } = logic
+
+        if (rules.length === 0) return true
+
+        const results = rules.map(rule => this.validateRule(value, rule))
+
+        switch (op) {
+            case 'AND':
+                return results.every(result => result)
+            case 'OR':
+                return results.some(result => result)
+            case 'NOT':
+                return !results[0]
+            case 'XOR':
+                return results.filter(Boolean).length === 1
+            case 'NAND':
+                return !results.every(result => result)
+            case 'NOR':
+                return !results.some(result => result)
+            default:
+                return false
+        }
+    }
+}
+Scriptable.register(ConditionScriptable)
+

package/src/scripts/FetchScriptable.ts

@@ -0,0 +1,51 @@
+import z from 'zod'
+import { language } from '../locale'
+import { Graphics } from '../graphics/Graphics';
+import { Scriptable, ScriptableArgs } from '../Scriptable'
+import { http, HttpType } from '../utils'
+
+const BaseInputSchema = z.object({
+    requestData: z.object().catchall(z.any()).default({}).describe(language.get('scriptable.fetch.input.requestData')),
+})
+
+const HttpInputSchema = BaseInputSchema.extend({
+    url: z.string().default('').describe(language.get('scriptable.fetch.input.url')),
+    type: z.enum(Object.values(HttpType)).default(HttpType.GET).describe(language.get('scriptable.fetch.input.type')),
+    nodeIds: z.string().default('').describe(language.get('scriptable.fetch.input.nodeIds')),
+})
+
+const InterfaceInputSchema = BaseInputSchema.extend({
+    type: z.literal('interface').default('interface').describe(language.get('scriptable.fetch.input.type.interface')),
+    interfaceId: z.string().describe(language.get('scriptable.fetch.input.interfaceId')),
+})
+
+export class FetchScriptable extends Scriptable {
+    static id = 'fetch'
+    static name = language.get('scriptable.fetch.name')
+    static inputSchame = z.union([
+        HttpInputSchema,
+        InterfaceInputSchema
+    ])
+
+    async execute(graphics: Graphics, trigger: string, input: z.infer<typeof FetchScriptable.inputSchame>, args?: ScriptableArgs) {
+        let url
+        let type
+        let result
+        if (input.type === 'interface') {
+            url = '/vyr/dataset.interface.execute'
+            type = HttpType.POST
+            result = { id: input.interfaceId, params: input.requestData }
+        } else {
+            url = input.url
+            type = input.type
+            result = this.aggregateResults(input.requestData, input.nodeIds, args)
+        }
+
+        const res = await http(url, type, result)
+
+        return res.result
+    }
+}
+Scriptable.register(FetchScriptable)
+
+

package/src/scripts/FindScriptable.ts

@@ -0,0 +1,23 @@
+import z from 'zod'
+import { language } from '../locale'
+import { Descriptor } from '../descriptor'
+import { Graphics } from '../graphics/Graphics'
+import { Scriptable, ScriptableArgs } from '../Scriptable'
+
+export class FindScriptable extends Scriptable {
+    static id = 'find'
+    static name = language.get('scriptable.find.name')
+    static inputSchame = z.object({
+        target: z.string().default('').describe(language.get('scriptable.find.input.target')),
+    })
+    static outputSchame = z.object().catchall(z.any()).or(z.null()).describe(language.get('scriptable.find.output.descriptor'))
+
+    execute(graphics: Graphics, trigger: string, input: z.infer<typeof FindScriptable.inputSchame>, args?: ScriptableArgs) {
+        const target = Descriptor.get<Descriptor>(input.target)
+
+        return target
+    }
+}
+Scriptable.register(FindScriptable)
+
+

package/src/scripts/InvokeScriptable.ts

@@ -0,0 +1,13 @@
+import z from 'zod'
+import { language } from '../locale'
+import { Scriptable } from '../Scriptable'
+
+export class InvokeScriptable extends Scriptable {
+    static id = 'invoke'
+    static name = language.get('scriptable.invoke.name')
+    static inputSchame = z.object({
+        target: z.string().default('').describe(language.get('scriptable.invoke.input.target')),
+        interactionType: z.string().default('click').describe(language.get('scriptable.invoke.input.interactionType')),
+    })
+}
+Scriptable.register(InvokeScriptable)

package/src/scripts/SwitchSceneScriptable.ts

@@ -0,0 +1,18 @@
+import z from 'zod'
+import { language } from '../locale'
+import { Graphics } from '../graphics/Graphics';
+import { Scriptable, ScriptableArgs } from '../Scriptable';
+
+export class SwitchSceneScriptable extends Scriptable {
+    static id = 'switch.scene'
+    static name = language.get('scriptable.switchScene.name')
+    static inputSchame = z.object({
+        scene: z.string().describe(language.get('scriptable.switchScene.input.scene')),
+    })
+
+    execute(graphics: Graphics, trigger: string, input: z.infer<typeof SwitchSceneScriptable.inputSchame>, args?: ScriptableArgs) {
+        console.log(trigger)
+        console.log(input)
+    }
+}
+Scriptable.register(SwitchSceneScriptable)

package/src/scripts/UpdateScriptable.ts

@@ -0,0 +1,60 @@
+import z from 'zod'
+import { language } from '../locale'
+import { ObjectUtils } from '../ObjectUtils';
+import { Descriptor } from '../descriptor'
+import { Graphics } from '../graphics/Graphics';
+import { Scriptable, ScriptableArgs } from '../Scriptable'
+
+export class UpdateScriptable extends Scriptable {
+    static id = 'update'
+    static name = language.get('scriptable.update.name')
+    static inputSchame = z.object({
+        target: z.string().default('').describe(language.get('scriptable.update.input.target')),
+        propertyPath: z.string().default('').describe(language.get('scriptable.update.input.propertyPath')),
+        data: z.object().catchall(z.any()).default({}).describe(language.get('scriptable.update.input.data')),
+        nodeId: z.string().optional().describe(language.get('scriptable.update.input.nodeId')),
+    })
+
+    updateObject(property: any, key: string, updateData: any) {
+        const value = property[key]
+        if (ObjectUtils.isObject(value)) {
+            if (Array.isArray(value)) {
+                property[key] = updateData
+            } else {
+                const keys = Object.keys(value)
+                for (const key of keys) {
+                    const updateValue = updateData[key]
+                    if (updateValue === undefined) continue
+                    this.updateObject(value, key, updateValue)
+                }
+            }
+        } else {
+            property[key] = updateData
+        }
+    }
+
+    execute(graphics: Graphics, trigger: string, input: z.infer<typeof UpdateScriptable.inputSchame>, args?: ScriptableArgs) {
+        if (args === undefined) return
+        const target = Descriptor.get<Descriptor>(input.target)
+
+        let updateData
+        if (input.nodeId) {
+            updateData = args.result.get(input.nodeId)
+            if (updateData === undefined) updateData = input.data
+        } else {
+            updateData = input.data
+        }
+        if (input.propertyPath) {
+            ObjectUtils.nextByPropertyPath(target, input.propertyPath, (property, key) => {
+                this.updateObject(property, key, updateData)
+                target.setNeedsUpdate()
+            })
+        } else {
+            target.syncWith(updateData)
+            target.setNeedsUpdate()
+        }
+    }
+}
+Scriptable.register(UpdateScriptable)
+
+

package/src/scripts/index.ts

@@ -0,0 +1,6 @@
+export * from './FindScriptable'
+export * from './UpdateScriptable'
+export * from './ConditionScriptable'
+export * from './InvokeScriptable'
+export * from './FetchScriptable'
+export * from './SwitchSceneScriptable'

package/src/utils/AssetProvider.ts

@@ -1,90 +1,17 @@
-import { InteractionDescriptor, InteractionNode, InteractionProperty } from "../interaction"
-import { Descriptor, DynamicDescriptor, PrefabInstanceDescriptor, HTMLDescriptor, StyleDescriptor, DatasetDescriptor, DivDescriptor } 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 })
-    }
-}
+import { Descriptor } from "../descriptor"
+import { AssetGraph, Port } from "../asset"
 
 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 DatasetDescriptorProvider = (descriptor: DatasetDescriptor, port: Port) => {
-    if (descriptor.dataConfigs.length > 0) {
-        for (let i = 0; i < descriptor.dataConfigs.length; i++) {
-            const dataConfig = descriptor.dataConfigs[i]
-            if (dataConfig.url && dataConfig.url.startsWith('/') && dataConfig.url.endsWith('.json')) {
-                port.edges.push({ key: `dataConfig[${i}].url`, category: Category.json, asset: dataConfig.url })
-            }
-        }
-    }
-}
-
-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 DivDescriptorProvider = (descriptor: DivDescriptor, port: Port) => {
-    if (descriptor.backroundIamge) port.edges.push({ key: 'backroundIamge', category: Category.image, asset: descriptor.backroundIamge })
-}
-
-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 })
+    if (descriptor.store) port.edges.push({ key: 'store', category: Category.store, asset: descriptor.store })
 }
 
-AssetGraph.register(Descriptor.type, DescriptorProvider)
-AssetGraph.register(DatasetDescriptor.type, DatasetDescriptorProvider)
-AssetGraph.register(StyleDescriptor.type, StyleDescriptorProvider)
-AssetGraph.register(InteractionDescriptor.type, InteractionDescriptorProvider)
-AssetGraph.register(HTMLDescriptor.type, HTMLDescriptorProvider)
-AssetGraph.register(DivDescriptor.type, DivDescriptorProvider)
-AssetGraph.register(DynamicDescriptor.type, DynamicDescriptorProvider)
-AssetGraph.register(PrefabInstanceDescriptor.type, PrefabInstanceDescriptorProvider)
+AssetGraph.register(Descriptor.type, DescriptorProvider)

package/src/utils/DOM.ts

@@ -0,0 +1,37 @@
+import { HTMLActor } from "../actor/HTMLActor"
+
+export const createEngineDOM = () => {
+    const DOM = document.createElement('div')
+    DOM.style.width = '100%'
+    DOM.style.height = '100%'
+    DOM.style.position = 'relative'
+    DOM.style.top = '0'
+    DOM.style.left = '0'
+    DOM.style.overflow = 'hidden'
+    DOM.classList.add('vyr-engine')
+    DOM.style.whiteSpace = 'pre-wrap'
+    DOM.setAttribute('data-vyr', `vyr-engine`)
+    DOM.addEventListener('contextmenu', (e) => e.preventDefault())
+    return DOM
+}
+
+export const createHTMLDOM = (uuid: string) => {
+    const DOM = document.createElement('div')
+    DOM.setAttribute('class', HTMLActor.className)
+    DOM.setAttribute(HTMLActor.uuidKey, uuid)
+    return DOM
+}
+
+export const createInputDOM = (uuid: string) => {
+    const DOM = document.createElement('input')
+    DOM.setAttribute('class', HTMLActor.className)
+    DOM.setAttribute(HTMLActor.uuidKey, uuid)
+    return DOM
+}
+
+export const createTextDOM = (uuid: string) => {
+    const DOM = document.createElement('span')
+    DOM.setAttribute('class', HTMLActor.className)
+    DOM.setAttribute(HTMLActor.uuidKey, uuid)
+    return DOM
+}

package/src/utils/HTML.ts

@@ -0,0 +1,5 @@
+import { HTML } from "../descriptor"
+
+export const isHTML = (obj: any): obj is HTML => {
+    return obj && typeof obj === 'object' && obj.isHTML === true
+}

package/src/utils/Service.ts

@@ -0,0 +1,40 @@
+import { ArrayUtils } from "../ArrayUtils"
+import { Descriptor } from "../descriptor/Descriptor"
+import { Service } from "../descriptor/Service"
+import { DeserializationObject } from "../Serialization"
+
+const services: string[] = []
+export const registerService = (type: string) => {
+    ArrayUtils.insert(services, type)
+}
+
+/**
+  * 检查描述器是否为服务节点
+  * 类型守卫函数，用于安全地判断一个描述器是否为Service类型
+  * @param descriptor - 要检查的描述器对象或反序列化对象
+  * @returns 类型谓词，true表示是Service类型
+  */
+export const isService = <D extends Service = Service>(descriptor: DeserializationObject<Descriptor> | null): descriptor is D => {
+    if (descriptor === null) return false
+    return services.includes(descriptor.type)
+}
+
+
+
+/**
+ * 追踪获取当前节点的父服务节点
+ * 沿节点树向上查找最近的服务节点
+ * 
+ * 注意：在渲染流程中应使用Graphics的同名方法，因为某些动态节点可能尚未插入节点树
+ * @param descriptor - 起始描述器节点
+ * @returns 找到的父服务节点，不存在则返回null
+ */
+export const traceService = (descriptor: Descriptor | null): Service | null => {
+    if (descriptor === null) return null
+    if (isService(descriptor)) {
+        return descriptor
+    } else {
+        const ancestor = descriptor.traceAncestor(false)
+        return traceService(ancestor.parent)
+    }
+}

package/src/utils/constants.ts

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

package/src/utils/http.ts

@@ -1,9 +1,8 @@
-import { ScriptableArgs } from "../interaction";
 import { Asset } from "../asset";
 import { HttpType } from "./constants";
 
 const headers = {}
-const setHttpHeaders = (options: { [k: string]: any }) => {
+export const setHttpHeaders = (options: { [k: string]: any }) => {
     Object.assign(headers, options)
 }
 
@@ -20,20 +19,7 @@ const joinUrl = (url: string, requestData: any) => {
     return urlObj.toString()
 }
 
-const http = async (url: string, type: string, data: string, result: ScriptableArgs['result']) => {
-    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 ?? {})
-    }
-
+export const http = async (url: string, type: string, requestData: any) => {
     url = url.replace(/\${(\w+)}/g, (match: any, key: string) => {
         return requestData.hasOwnProperty(key) ? requestData[key] : match;
     })
@@ -55,9 +41,4 @@ const http = async (url: string, type: string, data: string, result: ScriptableA
     const json = await res.json()
 
     return json
-}
-
-export {
-    setHttpHeaders,
-    http,
 }

package/src/utils/index.ts

@@ -1,4 +1,6 @@
+export * from './DOM'
+export * from './HTML'
+export * from './Service'
 export * from './constants'
 export * from './http'
-export * from './compile'
 export * from './AssetProvider'