@vyr/cli 0.0.12 → 0.0.13

package/output/locale/build/index.js

@@ -0,0 +1,71 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["__VYR_RUNTIME_@vyr/locale"] = {}));
+})(this, (function (exports) { 'use strict';
+
+    var __defProp = Object.defineProperty;
+    var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+    var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    class Language {
+      constructor(provider) {
+        __publicField(this, "_provider");
+        __publicField(this, "name");
+        this.name = provider.name;
+        this._provider = provider;
+      }
+      _replaceParams(text, params) {
+        if (!text || !text.includes("{{") || params === void 0) {
+          return text;
+        }
+        return text.replace(/\{\{\s*([^{}]+?)\s*\}\}/g, (match, key) => {
+          const trimmedKey = key.trim();
+          return params.hasOwnProperty(trimmedKey) ? String(params[trimmedKey]) : match;
+        });
+      }
+      get(key, params) {
+        const value = this._provider[key] ?? "";
+        return this._replaceParams(value, params);
+      }
+      setProvider(provider) {
+        this._provider = provider;
+      }
+    }
+    const privateState = {
+      languageProviderCollection: /* @__PURE__ */ new Map(),
+      languageCollection: /* @__PURE__ */ new Map(),
+      currentLanguageId: "zh_CN"
+    };
+    class Locale {
+      static register(language) {
+        privateState.languageProviderCollection.set(language.id + language.name, language);
+      }
+      static use(id) {
+        if (privateState.currentLanguageId === id) return;
+        privateState.currentLanguageId = id;
+        const languages = privateState.languageCollection.values();
+        for (const language of languages) {
+          const provider = privateState.languageProviderCollection.get(id + language.name);
+          if (provider === void 0) continue;
+          language.setProvider(provider);
+        }
+      }
+      static getLanguage(name) {
+        let language = privateState.languageCollection.get(name);
+        if (language === void 0) {
+          let provider = privateState.languageProviderCollection.get(privateState.currentLanguageId + name);
+          if (provider === void 0) {
+            provider = privateState.languageProviderCollection.get("zh_CN" + name);
+            if (provider === void 0) provider = { id: "zh_CN", name };
+          }
+          language = new Language(provider);
+          privateState.languageCollection.set(name, language);
+        }
+        return language;
+      }
+    }
+
+    exports.Language = Language;
+    exports.Locale = Locale;
+
+}));

package/output/locale/package.json

@@ -0,0 +1 @@
+{"name":"@vyr/locale","version":"0.0.13","description":"","main":"./build/index.js","author":"","license":"MIT","files":["package.json","build/"]}

package/output/locale/src/index.ts

@@ -0,0 +1,79 @@
+interface LanguageProvider {
+    id: string
+    name: string
+}
+
+class Language<T extends LanguageProvider = LanguageProvider> {
+    private _provider: T
+    readonly name
+
+    constructor(provider: T) {
+        this.name = provider.name
+        this._provider = provider
+    }
+
+    private _replaceParams(text: string, params?: Partial<Record<string, string | number>>): string {
+        if (!text || !text.includes('{{') || params === undefined) {
+            return text;
+        }
+
+        return text.replace(/\{\{\s*([^{}]+?)\s*\}\}/g, (match, key) => {
+            const trimmedKey = key.trim();
+            return params.hasOwnProperty(trimmedKey) ? String(params[trimmedKey]) : match;
+        });
+    }
+
+    get(key: keyof T, params?: Partial<Record<string, string | number>>) {
+        const value = (this._provider[key] ?? '') as string
+        return this._replaceParams(value, params)
+    }
+
+    setProvider(provider: T) {
+        this._provider = provider
+    }
+}
+
+const privateState = {
+    languageProviderCollection: new Map<string, LanguageProvider>(),
+    languageCollection: new Map<string, Language>(),
+    currentLanguageId: 'zh_CN',
+}
+
+class Locale {
+    static register(language: LanguageProvider) {
+        privateState.languageProviderCollection.set(language.id + language.name, language)
+    }
+
+    static use(id: string) {
+        if (privateState.currentLanguageId === id) return
+        privateState.currentLanguageId = id
+
+        const languages = privateState.languageCollection.values()
+        for (const language of languages) {
+            const provider = privateState.languageProviderCollection.get(id + language.name)
+            if (provider === undefined) continue
+            language.setProvider(provider)
+        }
+    }
+
+    static getLanguage<T extends LanguageProvider = LanguageProvider>(name: string) {
+        let language = privateState.languageCollection.get(name)
+        if (language === undefined) {
+            let provider = privateState.languageProviderCollection.get(privateState.currentLanguageId + name)
+            if (provider === undefined) {
+                provider = privateState.languageProviderCollection.get('zh_CN' + name)
+                if (provider === undefined) provider = { id: 'zh_CN', name }
+            }
+            language = new Language(provider)
+            privateState.languageCollection.set(name, language)
+        }
+        return language as Language<T>
+    }
+}
+
+
+export {
+    LanguageProvider,
+    Language,
+    Locale,
+}

package/output/locale/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "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": [],
+    "paths": {}
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": []
+}

package/output/remote/package.json

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

package/output/remote/src/Bridge.ts

@@ -0,0 +1,133 @@
+import { AsyncTask, Descriptor, Listener } from "@vyr/engine"
+import { Job } from "./job"
+
+interface RemoteConfig {
+  /**代理的唯一标识 */
+  id: string
+  /**远程服务的运行环境 */
+  env: 'window' | 'iframe'
+  /**远程服务是否执行任务 */
+  execute: boolean
+  /**是否启用远程服务的调用功能 */
+  invoke: boolean
+  /**远程服务运行后立即渲染的场景 */
+  scene?: string
+}
+
+interface BridgeConfig {
+  id: string
+  args?: any[]
+  useRemote?: () => Promise<Window>
+  autoConnect?: boolean
+}
+
+interface BridgeListener {
+  keydown: (event: KeyboardEvent) => void
+  keyup: (event: KeyboardEvent) => void
+  mouseup: (event: MouseEvent) => void
+  close: (args: {}) => void
+}
+
+/**
+ * 用于在远程环境之间传递信息的桥梁
+ */
+class Bridge {
+  static readonly key = '__VYR_RUNTIME_REMOTE'
+  static createBaseUrl() {
+    const { protocol, hostname, port } = window.location
+    return `${protocol}//${hostname}:${port}`
+  }
+  private _id
+  private _args
+  private _remote!: Window
+  private _closeId = -1
+  private _readyId = -1
+  private _listener = new Listener<BridgeListener>()
+  connected = new AsyncTask()
+  comm
+
+  constructor(config: BridgeConfig) {
+    this._id = config.id
+    this._args = config.args ?? []
+    this.comm = Bridge.createBaseUrl()
+    window.addEventListener('message', this.onReceive)
+    window.addEventListener('beforeunload', () => this.send(new Job.bridge.disconnect.Response({})))
+    if (config.useRemote) config.useRemote().then(this.checkReady)
+  }
+
+  private pipe = (remote: Window, message: Job) => {
+    remote.postMessage({ key: Bridge.key, id: this._id, message: Descriptor.serialization(message) }, this.comm)
+  }
+
+  private checkReady = (remote: Window) => {
+    if (this._remote) return
+    clearTimeout(this._readyId)
+    //@ts-ignore
+    this._readyId = setTimeout(() => this.checkReady(remote), 1000)
+    this.pipe(remote, new Job.bridge.connection.Response({}))
+  }
+
+  private isBridgeMessage = (event: MessageEvent) => {
+    return event.data.key === Bridge.key && event.data.id === this._id
+  }
+  private checkWindowClosed = () => {
+    if (this._remote.closed === false) return
+    this._listener.trigger('close', {})
+  }
+  private onDisconnect = () => {
+    clearTimeout(this._closeId)
+    this._closeId = setTimeout(this.checkWindowClosed, 5000) as unknown as number
+    this.connected = new AsyncTask()
+    const remote = this._remote
+    //@ts-ignore
+    this._remote = null
+    this.checkReady(remote)
+  }
+  private onReceive = (event: MessageEvent) => {
+    if (this.isBridgeMessage(event) === false) return
+    const task = Descriptor.deserialization<Job>(event.data.message)
+    switch (task.method) {
+      case Job.bridge.connection.Method:
+        clearTimeout(this._readyId)
+        this._remote = event.source as Window
+        this.connected.run()
+        const params = task.params as { stop?: boolean }
+        if (params.stop === undefined) {
+          this.send(new Job.bridge.connection.Response({ stop: true }))
+        }
+        break;
+      case Job.bridge.disconnect.Method:
+        this.onDisconnect()
+        break;
+      default:
+        this._listener.trigger(task.method, task, ...this._args)
+        break;
+    }
+  }
+
+  listen<T extends keyof BridgeListener>(method: T, cb: BridgeListener[T]): void
+  listen(method: string, cb: (...args: any[]) => void): void
+  listen(method: string, cb: (...args: any[]) => void) {
+    this._listener.listen(method, cb)
+  }
+
+  unlisten<T extends keyof BridgeListener>(method: T, cb: BridgeListener[T]): void
+  unlisten(method: string, cb: (...args: any[]) => void): void
+  unlisten(method: string, cb: (...args: any[]) => void) {
+    this._listener.unlisten(method, cb)
+  }
+
+  async send(message: Job) {
+    const serialization = Descriptor.serialization(message)
+    await this.connected.done()
+    this._remote.postMessage({ key: Bridge.key, id: this._id, message: serialization }, this.comm)
+  }
+
+  async close() {
+    await this.connected.done()
+    this._remote.close()
+    this._listener.trigger('close', {})
+  }
+}
+
+export { RemoteConfig, Bridge }

package/output/remote/src/ChangeScriptable.ts

@@ -0,0 +1,22 @@
+import { Descriptor, Graphics, HTMLTransformControllerChangeArgs, Scriptable } from "@vyr/engine";
+import { RemoteProcess } from "./RemoteProcess";
+import { Job } from "./job";
+
+class ChangeScriptable extends Scriptable<HTMLTransformControllerChangeArgs> {
+
+    execute(graphics: Graphics, args: HTMLTransformControllerChangeArgs) {
+        const process = RemoteProcess.get(graphics.engine)
+        if (process === null) return
+
+        if (args.event.type === 'contextmenu') {
+            process.bridge.send(new Job.invoke.pick.Response({ descriptor: '' }))
+        } else {
+            const target = Descriptor.get(args.event.target) as Descriptor
+            if (target === null) return
+            const params = { eventType: args.event.type, target: args.event.target, descriptor: target.clone(false) }
+            process.bridge.send(new Job.invoke.transform.Response(params))
+        }
+    }
+}
+
+export default ChangeScriptable

package/output/remote/src/Collection.ts

@@ -0,0 +1,36 @@
+interface Item {
+    [k: string]: any
+}
+
+class Collection {
+    private instance = new Map<Item, Item>()
+    private map = new Map<Item, Item>()
+
+    set(key: Item, value: Item) {
+        this.instance.set(key, value)
+        this.map.set(value, key)
+    }
+
+    get<T extends Item = Item>(key: Item) {
+        return (this.instance.get(key) ?? null) as T | null
+    }
+
+    getByMap<T extends Item = Item>(key: Item) {
+        return (this.map.get(key) ?? null) as T | null
+    }
+
+    delete(key: Item) {
+        const value = this.instance.get(key)
+        if (value === undefined) return
+        this.instance.delete(key)
+        this.map.delete(value)
+    }
+
+    values<T extends Item = Item>() {
+        return [...this.instance.values()] as T[]
+    }
+}
+
+export {
+    Collection
+}