@easytwin/devkit 0.1.2 → 0.1.3

package/dist/runtime/twin-app-host.js

@@ -0,0 +1,265 @@
+// src/twinAppHost.ts
+import { createAppInstance } from "@easytwin/apps";
+var LOCAL_LOAD_SCENE_ERROR = "\u672C\u5730\u9884\u89C8\u5355\u573A\u666F,\u4E0D\u80FD\u8C03\u7528 sceneManager.loadScene";
+var MISSING_TICK_ERROR = "\u5F53\u524D runtime \u4E0D\u652F\u6301\u5F15\u64CE\u65F6\u949F(\u7F3A\u5C11 registerEngineTickListener)\u3002\u65E0\u6CD5\u8FD0\u884C onUpdate\u3002";
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value;
+}
+var TwinAppPreviewHost = class {
+  constructor(options) {
+    this.options = options;
+    this.currentSceneId = options.sceneId;
+    this.onEngineTick = (engine) => this.handleTick(engine);
+  }
+  app = null;
+  engine = null;
+  disposed = false;
+  /** 用户应用已经成功 onSceneLoaded。 */
+  scenePresented = false;
+  tickAttached = false;
+  sceneLoadTask = null;
+  ctx = null;
+  cleanups = [];
+  sceneCleanups = [];
+  warnedAsyncUpdate = false;
+  userBlobUrl = null;
+  currentSceneId;
+  onEngineTick;
+  getEngine() {
+    return this.engine;
+  }
+  /** 给 spec 调用:场景字段取当前引擎主场景(不要求已 Run TwinApp)。 */
+  getTestContext() {
+    if (!this.engine) throw new Error("\u573A\u666F\u5C1A\u672A\u52A0\u8F7D\u5B8C\u6210,\u65E0\u6CD5\u8FD0\u884C\u6D4B\u8BD5");
+    const ctx = this.getContext();
+    const runtimeScene = this.engine.mainScene ?? null;
+    ctx.runtimeScene = runtimeScene;
+    ctx.scene = runtimeScene?.sceneObject ?? null;
+    ctx.camera = runtimeScene?.camera?.main ?? null;
+    return ctx;
+  }
+  async invokeTest(fn, input) {
+    if (this.disposed) throw new Error("\u9884\u89C8\u5BBF\u4E3B\u5DF2\u9500\u6BC1");
+    return fn(this.getTestContext(), input);
+  }
+  async boot() {
+    const { runtime, containerId, ossUrl, customComponentDeps } = this.options;
+    this.engine = await runtime.RuntimeEngine.create({
+      containerId,
+      baseOSSUrl: ossUrl,
+      customComponentDeps,
+      sceneResources: [],
+      componentRels: [],
+      enableResourcePersistence: false
+    });
+    await this.loadCurrentScene();
+  }
+  async run(code) {
+    if (this.disposed) throw new Error("\u9884\u89C8\u5BBF\u4E3B\u5DF2\u9500\u6BC1");
+    if (!this.engine) throw new Error("\u573A\u666F\u5C1A\u672A\u52A0\u8F7D\u5B8C\u6210,\u65E0\u6CD5 Run");
+    this.assertTickApi();
+    try {
+      await this.teardownApp({ keepEngine: true });
+      const mod = await this.importUser(code);
+      this.app = createAppInstance(mod.default);
+      await this.app.init?.(this.getContext());
+      await this.loadCurrentScene();
+      this.scenePresented = true;
+      await this.app.onSceneLoaded?.(this.getContext());
+      this.attachTick();
+    } catch (error) {
+      await this.teardownApp({ keepEngine: true, ignoreHookErrors: true });
+      throw error;
+    }
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    await this.teardownApp({ keepEngine: false, ignoreHookErrors: true });
+  }
+  assertTickApi() {
+    const { runtime } = this.options;
+    if (typeof runtime.registerEngineTickListener !== "function" || typeof runtime.unregisterEngineTickListener !== "function") {
+      throw new Error(MISSING_TICK_ERROR);
+    }
+  }
+  async importUser(code) {
+    if (this.options.importUserModule) return this.options.importUserModule(code);
+    if (this.userBlobUrl) {
+      try {
+        URL.revokeObjectURL(this.userBlobUrl);
+      } catch {
+      }
+      this.userBlobUrl = null;
+    }
+    const blob = new Blob([code], { type: "text/javascript" });
+    this.userBlobUrl = URL.createObjectURL(blob);
+    return import(
+      /* @vite-ignore */
+      this.userBlobUrl
+    );
+  }
+  async loadCurrentScene() {
+    if (!this.engine) throw new Error("Engine is not created");
+    if (this.sceneLoadTask) await this.sceneLoadTask;
+    this.sceneLoadTask = this.options.loadScene(this.engine, this.options.sceneJson).finally(() => {
+      this.sceneLoadTask = null;
+    });
+    await this.sceneLoadTask;
+  }
+  handleTick(engine) {
+    if (this.disposed || this.sceneLoadTask || !this.scenePresented) return;
+    try {
+      const result = this.app?.onUpdate?.(
+        this.getContext(),
+        engine.time.deltaTime,
+        engine.time.elapsedTime
+      );
+      if (isPromiseLike(result)) {
+        void Promise.resolve(result).catch((error) => {
+          console.error("async onUpdate rejected:", error);
+        });
+        if (!this.warnedAsyncUpdate) {
+          this.warnedAsyncUpdate = true;
+          console.warn("TwinApp.onUpdate \u5E94\u540C\u6B65\u6267\u884C\uFF1B\u672C\u6B21\u5DF2\u5FFD\u7565\u5176 Promise \u8FD4\u56DE\u503C");
+        }
+      }
+    } catch (error) {
+      this.handleUpdateError(error);
+    }
+  }
+  handleUpdateError(error) {
+    let shouldContinue = false;
+    try {
+      shouldContinue = this.app?.onError?.(this.getContext(), error) === true;
+    } catch (onError) {
+      void this.failRun(onError);
+      return;
+    }
+    if (shouldContinue) {
+      console.error("TwinApp.onUpdate threw:", error);
+      this.options.log?.(`onUpdate \u629B\u9519\u5DF2 continue: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+    void this.failRun(error);
+  }
+  async failRun(error) {
+    this.options.log?.(`Run \u5931\u8D25 ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+    await this.teardownApp({ keepEngine: true, ignoreHookErrors: true });
+  }
+  attachTick() {
+    if (!this.engine || this.tickAttached) return;
+    this.options.runtime.registerEngineTickListener?.(this.engine, this.onEngineTick);
+    this.tickAttached = true;
+  }
+  detachTick() {
+    if (!this.engine || !this.tickAttached) return;
+    this.options.runtime.unregisterEngineTickListener?.(this.engine, this.onEngineTick);
+    this.tickAttached = false;
+  }
+  async teardownApp(options) {
+    this.detachTick();
+    await this.unloadUserScene({ ignoreErrors: options.ignoreHookErrors });
+    if (this.app && this.engine) {
+      try {
+        await this.app.onDispose?.(this.getContext());
+      } catch (error) {
+        if (!options.ignoreHookErrors) throw error;
+        console.warn("TwinApp.onDispose failed:", error);
+      }
+    }
+    await this.runHooks(this.cleanups);
+    this.cleanups = [];
+    this.app = null;
+    this.ctx = null;
+    this.scenePresented = false;
+    if (!options.keepEngine) {
+      try {
+        this.engine?.destroy();
+      } catch {
+      }
+      this.engine = null;
+    }
+    if (this.userBlobUrl) {
+      try {
+        URL.revokeObjectURL(this.userBlobUrl);
+      } catch {
+      }
+      this.userBlobUrl = null;
+    }
+  }
+  async unloadUserScene(options) {
+    if (!this.scenePresented) return;
+    this.scenePresented = false;
+    try {
+      if (this.engine) await this.app?.onBeforeSceneUnload?.(this.getContext());
+    } catch (error) {
+      if (!options?.ignoreErrors) throw error;
+      console.warn("TwinApp.onBeforeSceneUnload failed:", error);
+    } finally {
+      await this.runHooks(this.sceneCleanups);
+      this.sceneCleanups = [];
+    }
+  }
+  async runHooks(hooks) {
+    for (const fn of [...hooks].reverse()) {
+      try {
+        await fn();
+      } catch (error) {
+        console.warn("TwinApp cleanup failed:", error);
+      }
+    }
+  }
+  getContext() {
+    if (!this.engine) throw new Error("Engine is not created");
+    const runtimeScene = this.scenePresented ? this.engine.mainScene ?? null : null;
+    const scene = runtimeScene?.sceneObject ?? null;
+    const camera = runtimeScene?.camera?.main ?? null;
+    const sceneManagerRuntime = this.engine.getManager(this.options.runtime.SceneManager);
+    if (!this.ctx) {
+      this.ctx = {
+        app: { id: this.options.appId, mode: "preview" },
+        engine: this.engine,
+        container: this.engine.container,
+        runtimeScene,
+        scene,
+        camera,
+        sceneManager: {
+          currentSceneId: this.currentSceneId,
+          runtime: sceneManagerRuntime,
+          loadScene: () => Promise.reject(new Error(LOCAL_LOAD_SCENE_ERROR))
+        },
+        logger: {
+          log: (...args) => console.log(...args),
+          info: (...args) => console.info(...args),
+          warn: (...args) => console.warn(...args),
+          error: (...args) => console.error(...args)
+        },
+        assets: {
+          text: (p) => this.options.readAsset(p),
+          json: async (p) => JSON.parse(await this.options.readAsset(p))
+        },
+        cleanup: (fn) => {
+          this.cleanups.push(fn);
+        },
+        sceneCleanup: (fn) => {
+          this.sceneCleanups.push(fn);
+        }
+      };
+      return this.ctx;
+    }
+    this.ctx.engine = this.engine;
+    this.ctx.container = this.engine.container;
+    this.ctx.runtimeScene = runtimeScene;
+    this.ctx.scene = scene;
+    this.ctx.camera = camera;
+    this.ctx.sceneManager.currentSceneId = this.currentSceneId;
+    this.ctx.sceneManager.runtime = sceneManagerRuntime;
+    return this.ctx;
+  }
+};
+export {
+  LOCAL_LOAD_SCENE_ERROR,
+  MISSING_TICK_ERROR,
+  TwinAppPreviewHost
+};

package/dist/runtime/twin-apps.js

@@ -0,0 +1,48 @@
+// src/apps.ts
+var PORTABLE_RUNTIME_EXPORTS = [
+  "THREE",
+  "RuntimeEngine",
+  "SceneManager",
+  "LoadSceneMode",
+  "convertObjToComponentJson"
+];
+var TwinApp = class {
+};
+function defineApp(app) {
+  return app;
+}
+var LIFECYCLE_NAMES = [
+  "init",
+  "onUpdate",
+  "onBeforeSceneUnload",
+  "onSceneLoaded",
+  "onDispose",
+  "onError"
+];
+function isLifecycleApp(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return LIFECYCLE_NAMES.some((name) => typeof Reflect.get(value, name) === "function");
+}
+function createAppInstance(appExport) {
+  if (typeof appExport === "function" && (appExport.prototype instanceof TwinApp || isLifecycleApp(appExport.prototype))) {
+    return new appExport();
+  }
+  if (isLifecycleApp(appExport)) return appExport;
+  throw new Error("\u5165\u53E3\u9ED8\u8BA4\u5BFC\u51FA\u5FC5\u987B\u662F TwinApp \u5B50\u7C7B\u6216 defineApp({...}) \u751F\u547D\u5468\u671F\u5BF9\u8C61");
+}
+function portableRuntimeWarning(names) {
+  const extra = [...new Set(names)].filter(
+    (n) => n !== "*" && !PORTABLE_RUNTIME_EXPORTS.includes(n)
+  );
+  const ns = [...names].includes("*");
+  if (!ns && extra.length === 0) return void 0;
+  const detail = ns ? "namespace import *" : extra.sort().join(", ");
+  return `\u68C0\u6D4B\u5230 @easytwin/runtime \u5BFC\u51FA ${detail} \u4E0D\u5728\u5728\u7EBF\u7F16\u8BD1\u767D\u540D\u5355(${PORTABLE_RUNTIME_EXPORTS.join(", ")})\u5185\u3002\u672C\u5730\u9884\u89C8\u53EF\u7528,\u4E0A\u4F20\u5230\u5728\u7EBF TwinApp \u53EF\u80FD\u7F16\u4E0D\u8FC7\u3002`;
+}
+export {
+  PORTABLE_RUNTIME_EXPORTS,
+  TwinApp,
+  createAppInstance,
+  defineApp,
+  portableRuntimeWarning
+};