cj-tauri 1.1.2 → 2.1.0

package/src/window_registry.cj

@@ -1,116 +1,116 @@
-package cjTauri
-
-import std.collection.*
-
-/**
- * 一个窗口的记录：label 唯一，config 是它创建时的窗口配置快照
- *
- * label 是窗口对外的**唯一身份**（Tauri 同样按 label 寻址）：前端页面只认 label，
- * C 侧句柄是跨 FFI 的不透明指针，留在宿主实现内部、不越过 IPC 协议（见
- * docs/架构演进-多平台与多窗口.md §7.2）。
- */
-public class WindowRecord {
-    public let label: String
-    public let host: WebViewHost
-    public let config: WindowConfig
-
-    public init(label: String, host: WebViewHost, config: WindowConfig) {
-        this.label = label
-        this.host = host
-        this.config = config
-    }
-}
-
-/**
- * label → 窗口记录（批次 2 的地基）
- *
- * 单窗口阶段只登记一条 "main"——与桥 JS 的 windowLabel 缺省值、旧代码里写死的 "main"
- * 是同一个约定（**默认值不能变**，否则现有示例与探针会静默收不到事件，见架构文档 §6.4）。
- * 多窗口落地后它是「label → 宿主」的唯一权威来源：事件定向投递（emitToWindow）与
- * 命令上下文（IpcContext.window）都从这里查。
- *
- * 为什么重复 label 直接抛而不是覆盖：覆盖会让「一个 label 后面挂着两个宿主」静默成立，
- * 而这类 bug 的表现是「事件忽而收得到、忽而收不到」，是最难查的一类。
- */
-class WindowRegistry {
-    private var windows: HashMap<String, WindowRecord> = HashMap<String, WindowRecord>()
-    // 为什么另存一份插入顺序：HashMap 不承诺迭代顺序，而广播要按确定顺序投递——
-    // 否则多窗口下事件的到达顺序随机，测试也没法断言（labels() 直接给这张表）。
-    private var order: ArrayList<String> = ArrayList<String>()
-
-    /**
-     * 登记一个窗口：label 非空且未被占用
-     */
-    func add(record: WindowRecord): Unit {
-        if (record.label.size == 0) {
-            throw Exception("window label 不能为空")
-        }
-        if (this.windows.contains(record.label)) {
-            throw Exception("duplicate window label: \"${record.label}\"")
-        }
-        this.windows.add(record.label, record)
-        this.order.add(record.label)
-    }
-
-    /**
-     * 按 label 取窗口；未登记返回 None（调用方决定是降级还是报错）
-     */
-    func get(label: String): Option<WindowRecord> {
-        return this.windows.get(label)
-    }
-
-    /**
-     * 全部 label，**按登记顺序**（广播路径据此保持确定顺序）
-     */
-    func labels(): ArrayList<String> {
-        let out = ArrayList<String>()
-        for (l in this.order) {
-            out.add(l)
-        }
-        return out
-    }
-
-    /**
-     * 解析投递目标：空串 = 广播（按登记顺序给出全部窗口），非空 = 命中则单元素、否则空表
-     *
-     * 路由决策放在这里而不是调用方：它是纯函数（不碰宿主）因而能单测，调用方只剩
-     * 「投给谁」与「一个都没命中时怎么报」两件事。**未注册的 label 不回落成广播**——
-     * 写错 label 就该什么都收不到（由调用方打一条 stderr），静默变成广播比丢事件更难查。
-     */
-    func targets(window: String): ArrayList<WindowRecord> {
-        let out = ArrayList<WindowRecord>()
-        if (window.size == 0) {
-            for (l in this.order) {
-                out.add(this.windows.get(l).getOrThrow())
-            }
-            return out
-        }
-        match (this.windows.get(window)) {
-            case Some(rec) => out.add(rec)
-            case None => ()
-        }
-        return out
-    }
-
-    /**
-     * 注销窗口；label 不存在时为空操作（关窗路径可能重复触发，不该被异常打断）
-     */
-    func remove(label: String): Unit {
-        if (!this.windows.contains(label)) {
-            return
-        }
-        let _ = this.windows.remove(label)
-        // 顺序表同步：重建一遍（窗口数以个位计，不值得为它引一个索引表）
-        let kept = ArrayList<String>()
-        for (l in this.order) {
-            if (l != label) {
-                kept.add(l)
-            }
-        }
-        this.order = kept
-    }
-
-    func size(): Int64 {
-        return this.windows.size
-    }
-}
+package cjTauri
+
+import std.collection.*
+
+/**
+ * 一个窗口的记录：label 唯一，config 是它创建时的窗口配置快照
+ *
+ * label 是窗口对外的**唯一身份**（Tauri 同样按 label 寻址）：前端页面只认 label，
+ * C 侧句柄是跨 FFI 的不透明指针，留在宿主实现内部、不越过 IPC 协议（见
+ * docs/架构演进-多平台与多窗口.md §7.2）。
+ */
+public class WindowRecord {
+    public let label: String
+    public let host: WebViewHost
+    public let config: WindowConfig
+
+    public init(label: String, host: WebViewHost, config: WindowConfig) {
+        this.label = label
+        this.host = host
+        this.config = config
+    }
+}
+
+/**
+ * label → 窗口记录（批次 2 的地基）
+ *
+ * 单窗口阶段只登记一条 "main"——与桥 JS 的 windowLabel 缺省值、旧代码里写死的 "main"
+ * 是同一个约定（**默认值不能变**，否则现有示例与探针会静默收不到事件，见架构文档 §6.4）。
+ * 多窗口落地后它是「label → 宿主」的唯一权威来源：事件定向投递（emitToWindow）与
+ * 命令上下文（IpcContext.window）都从这里查。
+ *
+ * 为什么重复 label 直接抛而不是覆盖：覆盖会让「一个 label 后面挂着两个宿主」静默成立，
+ * 而这类 bug 的表现是「事件忽而收得到、忽而收不到」，是最难查的一类。
+ */
+class WindowRegistry {
+    private var windows: HashMap<String, WindowRecord> = HashMap<String, WindowRecord>()
+    // 为什么另存一份插入顺序：HashMap 不承诺迭代顺序，而广播要按确定顺序投递——
+    // 否则多窗口下事件的到达顺序随机，测试也没法断言（labels() 直接给这张表）。
+    private var order: ArrayList<String> = ArrayList<String>()
+
+    /**
+     * 登记一个窗口：label 非空且未被占用
+     */
+    func add(record: WindowRecord): Unit {
+        if (record.label.size == 0) {
+            throw Exception("window label 不能为空")
+        }
+        if (this.windows.contains(record.label)) {
+            throw Exception("duplicate window label: \"${record.label}\"")
+        }
+        this.windows.add(record.label, record)
+        this.order.add(record.label)
+    }
+
+    /**
+     * 按 label 取窗口；未登记返回 None（调用方决定是降级还是报错）
+     */
+    func get(label: String): Option<WindowRecord> {
+        return this.windows.get(label)
+    }
+
+    /**
+     * 全部 label，**按登记顺序**（广播路径据此保持确定顺序）
+     */
+    func labels(): ArrayList<String> {
+        let out = ArrayList<String>()
+        for (l in this.order) {
+            out.add(l)
+        }
+        return out
+    }
+
+    /**
+     * 解析投递目标：空串 = 广播（按登记顺序给出全部窗口），非空 = 命中则单元素、否则空表
+     *
+     * 路由决策放在这里而不是调用方：它是纯函数（不碰宿主）因而能单测，调用方只剩
+     * 「投给谁」与「一个都没命中时怎么报」两件事。**未注册的 label 不回落成广播**——
+     * 写错 label 就该什么都收不到（由调用方打一条 stderr），静默变成广播比丢事件更难查。
+     */
+    func targets(window: String): ArrayList<WindowRecord> {
+        let out = ArrayList<WindowRecord>()
+        if (window.size == 0) {
+            for (l in this.order) {
+                out.add(this.windows.get(l).getOrThrow())
+            }
+            return out
+        }
+        match (this.windows.get(window)) {
+            case Some(rec) => out.add(rec)
+            case None => ()
+        }
+        return out
+    }
+
+    /**
+     * 注销窗口；label 不存在时为空操作（关窗路径可能重复触发，不该被异常打断）
+     */
+    func remove(label: String): Unit {
+        if (!this.windows.contains(label)) {
+            return
+        }
+        let _ = this.windows.remove(label)
+        // 顺序表同步：重建一遍（窗口数以个位计，不值得为它引一个索引表）
+        let kept = ArrayList<String>()
+        for (l in this.order) {
+            if (l != label) {
+                kept.add(l)
+            }
+        }
+        this.order = kept
+    }
+
+    func size(): Int64 {
+        return this.windows.size
+    }
+}

package/cli/templates/ohos-pc/entry/src/main/cangjie/index.cj

@@ -1,167 +0,0 @@
-package ohos_app_cangjie_entry
-
-import kit.ArkUI.*
-import kit.ArkWeb.*
-import kit.PerformanceAnalysisKit.Hilog
-import ohos.arkui.component.web.Web
-import ohos.arkui.state_macro_manage.*
-import cjTauri.*
-
-/*
- * 应用侧的 ArkWeb 宿主组件
- *
- * 这个 `@Component` **必须住在应用模块里**，不能由框架包提供：框架包一旦 import
- * `kit.ArkUI.*` / `kit.ArkWeb.*`，合并进应用动态库后包初始化链会跳到坏地址、启动即 SIGSEGV。
- * 框架侧只留 `arkWebProxyPost` / `arkWebProxyPoll` 两个不碰 ArkUI 的桥接函数。
- *
- * 单窗口版：label 用框架默认的 DEFAULT_WINDOW_LABEL。要做多窗口就照着加一份、
- * 换成别的 label（框架的宿主路由是按 label 查的，不会串台）。
- */
-
-/**
- * proxy 的 `post` 入口：先交给框架处理报文，再把队列里的脚本推回页面
- *
- * 为什么「顺手推」放在这里：`javaScriptProxy` 的回调就在 UI 线程上，而
- * `controller.runJavaScript` 也必须在 UI 线程调。页面 → 原生的**返回值通道不可用**
- * （实测恒为 `null`），所以鸿蒙侧只能「页面发心跳 → 原生在该回调里把待执行脚本推出去」，
- * 这是唯一的回投路径；框架会把它收到的 invoke 结果 / event 都排进这个队列。
- */
-func onProxyPost(label: String, raw: String, ctrl: WebviewController): String {
-    let ack = arkWebProxyPost(label, raw)
-    match (ArkWebRuntime.hostFor(label)) {
-        case Some(h) =>
-            let pending = h.takePendingScripts()
-            var i = 0
-            while (i < pending.size) {
-                ctrl.runJavaScript(pending[i], { _, _ => () })
-                i += 1
-            }
-        case None => ()
-    }
-    return ack
-}
-
-@Component
-class CjTauriWebView {
-    /* label 决定：①页面里 __CJ_TAURI_LABEL__ ②报文里的 window 字段 ③宿主取哪份页面来源。
-       必须是 `@Prop`：普通成员会被宏展开成 ObservedProperty 形参，外面传字符串进来会报
-       「expected 4 arguments」。 */
-    @Prop
-    var windowLabel: String
-
-    /* 组件生命周期内必须保持同一个 controller 实例（ArkWeb 的硬约束） */
-    private let controller: WebviewController = WebviewController()
-
-    /* 页面地址由宿主给定；@State 让它参与刷新（宿主登记页面往往晚于组件首次 build）。
-       `@State` 不允许与 private/public/static 同用——宏会直接拒绝。 */
-    @State
-    var pageUrl: String = ""
-
-    public func build() {
-        Column {
-            if (this.pageUrl.size > 0) {
-                Web(src: this.pageUrl, controller: this.controller)
-                    .width(100.percent)
-                    .height(100.percent)
-                    .fileAccess(true)
-                    .javaScriptProxy(
-                        funcList: [
-                            { raw => onProxyPost(this.windowLabel, raw, this.controller) },
-                            /* `poll` 只为兼容页面上可能残留的旧桥脚本：返回值传不回 JS，
-                               真正的脚本推送已在 `onProxyPost` 里完成。 */
-                            { _ => "" }
-                        ],
-                        name: ARKWEB_PROXY_NAME, methodList: ["post", "poll"],
-                        controller: this.controller
-                    )
-                    .onPageBegin({ _ => this.onPageBegin() })
-                    .onPageEnd({ _ => this.onPageEnd() })
-            }
-        }.width(100.percent).height(100.percent)
-    }
-
-    /**
-     * 组件挂载钩子（首次 `build()` 之前调用一次）
-     *
-     * **必须在这里同步宿主地址**：宿主把页面落盘后才把 `file://` 地址放进自己的字段，
-     * 而 `build()` 是声明式的一次性求值——`pageUrl` 仍为空就永远不建 `Web`，
-     * `onPageBegin` 也就永远不会来，页面白屏。
-     */
-    protected override func aboutToAppear(): Unit {
-        match (ArkWebRuntime.hostFor(this.windowLabel)) {
-            case Some(h) =>
-                let u = h.currentUrl()
-                if (u.size > 0) {
-                    this.pageUrl = u
-                }
-                Hilog.info(1, "CjTauri", "aboutToAppear label=${this.windowLabel} pageUrl=${u}")
-            case None => Hilog.info(1, "CjTauri", "aboutToAppear without host")
-        }
-    }
-
-    private func onPageBegin(): Unit {
-        Hilog.info(1, "CjTauri", "page begin label=${this.windowLabel}")
-        match (ArkWebRuntime.hostFor(this.windowLabel)) {
-            case Some(h) =>
-                h.notePageBegin()
-                let url = h.currentUrl()
-                if (url.size > 0 && url != this.pageUrl) {
-                    this.pageUrl = url
-                }
-                // 桥脚本与插件 shim 都在 initScripts 里：ArkWeb 没有 document-start 注入，
-                // `onPageBegin` 是能拿到的最早时机。
-                for (js in h.initScriptsSnapshot()) {
-                    this.runScript(js)
-                }
-                this.runScript(arkWebLabelScript(this.windowLabel))
-            case None => Hilog.info(1, "CjTauri", "page begin without host: label=${this.windowLabel}")
-        }
-    }
-
-    private func onPageEnd(): Unit {
-        Hilog.info(1, "CjTauri", "page end label=${this.windowLabel}")
-        match (ArkWebRuntime.hostFor(this.windowLabel)) {
-            case Some(h) =>
-                h.notePageEnd()
-                // 组件首次 build 时宿主可能还没登记（页面为空），这里再同步一次并触发刷新
-                let url = h.currentUrl()
-                if (url.size > 0 && url != this.pageUrl) {
-                    this.pageUrl = url
-                }
-            case None => ()
-        }
-    }
-
-    /** 单条脚本执行（ArkWeb 的 runJavaScript 是异步的，回调里只做失败日志） */
-    private func runScript(js: String): Unit {
-        if (js.size == 0) {
-            return
-        }
-        // runJavaScript(script, callback) 两个都是位置参数（命名参数前缀会被编译器拒）
-        this.controller.runJavaScript(
-            js,
-            {
-                err, result =>
-                    match (err) {
-                        case Some(e) => Hilog.info(1, "CjTauri", "runJavaScript failed: ${e.message}")
-                        case None => Hilog.info(1, "CjTauri", "runJavaScript ok")
-                    }
-                    let _ = result
-            }
-        )
-    }
-}
-
-@Entry
-@Component
-class EntryView {
-    func build() {
-        Column {
-            // 高度由**外层容器**给：自定义组件的调用点不能挂链式修饰（`.height(...)`），
-            // 那样宏展开时补不上 `__gen_parent`，报的是「missing arguments for parameter list」。
-            Column() {
-                CjTauriWebView(windowLabel: DEFAULT_WINDOW_LABEL)
-            }.width(100.percent).height(100.percent)
-        }.width(100.percent).height(100.percent)
-    }
-}

package/src/host_factory.cj

@@ -1,48 +0,0 @@
-package cjTauri
-
-/**
- * 应用侧注入的宿主工厂（自定义平台的装配入口）
- *
- * 内置平台（Windows / 桌面 Linux）由 `createHost()` 直接选实现；没有内置宿主的平台
- * （鸿蒙 ArkWeb，以及 ARM64 Linux——两者 `os` 都报 `Linux`，只能用 `arch` 分开）
- * 由应用在**构造 `TauriApp()` 之前**注册工厂：
- *
- * ```
- * setHostFactory({ label => MyArkWebHost(label) })
- * let app = TauriApp()
- * ```
- *
- * 为什么放在框架外：ArkWeb 的宿主必须直接建 ArkUI 组件（`Web` + `WebviewController`），
- * 框架核心一旦 import 这些 kit，桌面目标的构建也要跟着拉 ArkUI 依赖。把「建组件」留在应用、
- * 把「桥与事件」留在框架，两边各自只依赖自己的那半边。
- *
- * 单一职责：本文件只管「工厂登记」这一件事，装配时机与语义见上面注释。
- */
-private var HOST_FACTORY: Option<(String) -> WebViewHost> = None
-
-/**
- * 注册自定义 WebView 宿主工厂（必须在构造 `TauriApp()` 之前调用）
- *
- * label 与内置宿主同义（默认窗口是 `DEFAULT_WINDOW_LABEL`）：工厂会为每个窗口各调一次，
- * 实现方要保证「一个 label 一个宿主实例」，否则多窗口下事件会串台。
- * 重复调用＝替换而非叠加（只保留最后一次登记）。
- */
-public func setHostFactory(factory: (String) -> WebViewHost): Unit {
-    HOST_FACTORY = Some(factory)
-}
-
-/**
- * 取注入的宿主；没登记就抛一条**可照做**的错误
- *
- * 不静默回落到空实现：宿主缺席时应用会拿到一个永远开不出窗口的对象，
- * 比启动即失败更难排查（AGENTS §1 第 4 条：跑不起来要如实说明）。
- */
-func requireInjectedHost(label: String): WebViewHost {
-    match (HOST_FACTORY) {
-        case Some(factory) => return factory(label)
-        case None =>
-            throw CommandException(
-                "当前平台没有内置 WebView 宿主：请在构造 TauriApp() 之前调用 cjTauri.setHostFactory({ label => ... }) 注入实现（鸿蒙 ArkWeb 走这条通路）"
-            )
-    }
-}