@ptengine/widgets 0.0.0-stage → 0.1.0

package/dist/cjs/index.cjs.js

@@ -0,0 +1,107 @@
+'use strict';
+
+/**
+ * 依赖注入：Web Components 社区的 Context Protocol。
+ *
+ * 业务组件不自己创建 client，也不读全局变量，而是在挂载时向上冒泡一个
+ * `context-request` 事件，由最近的 `<pt-provider>` 回调返回 client。
+ *
+ * 选它而不是各框架自己的 context 机制，是因为它走的是 DOM 事件：
+ * React、Vue、Angular、原生 HTML 里行为完全一致，也能穿透 Shadow DOM
+ * （事件带 composed: true）。两层因此可以独立发版、独立测试。
+ *
+ * 协议出处：https://github.com/webcomponents-cg/community-protocols
+ */
+/**
+ * context 的标识。
+ *
+ * 用字符串而不是 Symbol：页面上同时存在两份打包产物时（比如宿主应用装了一份、
+ * 某个微前端子应用又装了一份），两个 Symbol 不相等，注入会静默失败；
+ * 字符串永远相等。代价是理论上可能与别人撞名，所以带上包名前缀。
+ */
+const PT_CLIENT_CONTEXT = '@ptengine/client';
+/** provider 挂到文档上时广播的事件名（协议里的 context-provider）：未得到应答的消费者据此再问一次 */
+const CONTEXT_PROVIDER_EVENT = 'context-provider';
+class ContextRequestEvent extends Event {
+    constructor(context, callback, subscribe = false) {
+        super('context-request', { bubbles: true, composed: true, cancelable: true });
+        this.context = context;
+        this.callback = callback;
+        this.subscribe = subscribe;
+    }
+}
+/**
+ * 向上请求一个 client。
+ *
+ * `subscribe: true` 时，provider 换了 client 会再次回调（例如切换账号），
+ * 返回值是退订函数 —— 组件在 disconnectedCallback 里调用它。
+ *
+ * 找不到 provider 时回调不会被触发，组件应当据此降级（显示「未接入」而不是报错）。
+ */
+function requestClient(element, callback, subscribe = true) {
+    let unsubscribe;
+    let answered = false;
+    let released = false;
+    /** 发出去的请求编号与被接受的那一个：同一个消费者只能持有一份订阅 */
+    let latest = 0;
+    let accepted = 0;
+    const fire = () => {
+        const id = ++latest;
+        element.dispatchEvent(new ContextRequestEvent(PT_CLIENT_CONTEXT, (value, dispose) => {
+            /* 组件已经退订（卸载）后才姗姗来迟的应答，直接丢掉。
+             * 另一种迟到：兜底重试发了第二个请求，而第一个其实被 provider 排队了
+             * （Stencil 在实例就绪前会把 @Listen 收到的事件先攒着、就绪后重放），
+             * 两个都被应答就成了两份订阅 —— 只认第一份，其余的当场退订。 */
+            if (released || (answered && id !== accepted)) {
+                dispose?.();
+                return;
+            }
+            answered = true;
+            accepted = id;
+            /* 只记住最新的退订函数，**不要**调用旧的：provider 每次通知都会给一个新的
+             * dispose，而它们删除的是同一个订阅。调旧的等于把自己退订 ——
+             * 消费者从此只能收到两次值，第二次换 client 之后永久停更。 */
+            if (dispose)
+                unsubscribe = dispose;
+            callback(value);
+        }, subscribe));
+    };
+    fire();
+    /**
+     * 没人应答时不能就此放弃：上层的 <pt-provider> 未必比子组件先就绪。
+     *
+     * 两种情况，两条兜底：
+     *  1. provider 的类还没注册（懒加载，Vue / Nuxt 里实测子组件先 upgrade）：
+     *     等 whenDefined 兑现后再要一次；
+     *  2. provider 后插入文档、或在 DOM 里被移动（keep-alive、列表重排）：
+     *     它 connected 时会广播 context-provider，听到就再要一次。
+     * 此刻 provider 的 client 可能仍是 undefined（框架还没把 prop 写进来），没关系：
+     * subscribe 已经挂上，等 prop 写进来时 @Watch 会再通知一次。
+     */
+    const retry = () => {
+        if (!answered && !released && element.isConnected)
+            fire();
+    };
+    if (!answered && typeof customElements !== 'undefined') {
+        void customElements.whenDefined('pt-provider').then(retry);
+    }
+    /* 挂在 document 上：provider 的广播带 composed，从任何影子树里都能冒到这里 */
+    const onProviderAvailable = () => retry();
+    if (!answered && typeof document !== 'undefined') {
+        document.addEventListener(CONTEXT_PROVIDER_EVENT, onProviderAvailable);
+    }
+    return () => {
+        released = true;
+        if (typeof document !== 'undefined')
+            document.removeEventListener(CONTEXT_PROVIDER_EVENT, onProviderAvailable);
+        unsubscribe?.();
+    };
+}
+
+exports.CONTEXT_PROVIDER_EVENT = CONTEXT_PROVIDER_EVENT;
+exports.ContextRequestEvent = ContextRequestEvent;
+exports.PT_CLIENT_CONTEXT = PT_CLIENT_CONTEXT;
+exports.requestClient = requestClient;
+//# sourceMappingURL=index.cjs.js.map
+
+//# sourceMappingURL=index.cjs.js.map

package/dist/cjs/index.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs.js","sources":["src/utils/context.ts"],"sourcesContent":["/**\n * 依赖注入：Web Components 社区的 Context Protocol。\n *\n * 业务组件不自己创建 client，也不读全局变量，而是在挂载时向上冒泡一个\n * `context-request` 事件，由最近的 `<pt-provider>` 回调返回 client。\n *\n * 选它而不是各框架自己的 context 机制，是因为它走的是 DOM 事件：\n * React、Vue、Angular、原生 HTML 里行为完全一致，也能穿透 Shadow DOM\n * （事件带 composed: true）。两层因此可以独立发版、独立测试。\n *\n * 协议出处：https://github.com/webcomponents-cg/community-protocols\n */\n\n/**\n * 注入给子树的 client。\n *\n * 能力层 SDK 暂时移除，这里是它的占位：provider 只做引用传递，不关心 client 长什么样。\n * 将来 SDK 加回来时换成 `@ptengine/sdk` 的 `Client`。\n */\nexport type Client = object;\n\n/**\n * context 的标识。\n *\n * 用字符串而不是 Symbol：页面上同时存在两份打包产物时（比如宿主应用装了一份、\n * 某个微前端子应用又装了一份），两个 Symbol 不相等，注入会静默失败；\n * 字符串永远相等。代价是理论上可能与别人撞名，所以带上包名前缀。\n */\nexport const PT_CLIENT_CONTEXT = '@ptengine/client' as const;\n\n/** provider 挂到文档上时广播的事件名（协议里的 context-provider）：未得到应答的消费者据此再问一次 */\nexport const CONTEXT_PROVIDER_EVENT = 'context-provider' as const;\n\nexport type ContextCallback<T> = (value: T, unsubscribe?: () => void) => void;\n\nexport class ContextRequestEvent<T> extends Event {\n  readonly context: string;\n  readonly callback: ContextCallback<T>;\n  readonly subscribe: boolean;\n\n  constructor(context: string, callback: ContextCallback<T>, subscribe = false) {\n    super('context-request', { bubbles: true, composed: true, cancelable: true });\n    this.context = context;\n    this.callback = callback;\n    this.subscribe = subscribe;\n  }\n}\n\n/**\n * 向上请求一个 client。\n *\n * `subscribe: true` 时，provider 换了 client 会再次回调（例如切换账号），\n * 返回值是退订函数 —— 组件在 disconnectedCallback 里调用它。\n *\n * 找不到 provider 时回调不会被触发，组件应当据此降级（显示「未接入」而不是报错）。\n */\nexport function requestClient(\n  element: HTMLElement,\n  callback: ContextCallback<Client | undefined>,\n  subscribe = true\n): () => void {\n  let unsubscribe: (() => void) | undefined;\n  let answered = false;\n  let released = false;\n  /** 发出去的请求编号与被接受的那一个：同一个消费者只能持有一份订阅 */\n  let latest = 0;\n  let accepted = 0;\n\n  const fire = () => {\n    const id = ++latest;\n    element.dispatchEvent(\n      new ContextRequestEvent<Client | undefined>(\n        PT_CLIENT_CONTEXT,\n        (value, dispose) => {\n          /* 组件已经退订（卸载）后才姗姗来迟的应答，直接丢掉。\n           * 另一种迟到：兜底重试发了第二个请求，而第一个其实被 provider 排队了\n           * （Stencil 在实例就绪前会把 @Listen 收到的事件先攒着、就绪后重放），\n           * 两个都被应答就成了两份订阅 —— 只认第一份，其余的当场退订。 */\n          if (released || (answered && id !== accepted)) {\n            dispose?.();\n            return;\n          }\n          answered = true;\n          accepted = id;\n          /* 只记住最新的退订函数，**不要**调用旧的：provider 每次通知都会给一个新的\n           * dispose，而它们删除的是同一个订阅。调旧的等于把自己退订 ——\n           * 消费者从此只能收到两次值，第二次换 client 之后永久停更。 */\n          if (dispose) unsubscribe = dispose;\n          callback(value);\n        },\n        subscribe\n      )\n    );\n  };\n\n  fire();\n\n  /**\n   * 没人应答时不能就此放弃：上层的 <pt-provider> 未必比子组件先就绪。\n   *\n   * 两种情况，两条兜底：\n   *  1. provider 的类还没注册（懒加载，Vue / Nuxt 里实测子组件先 upgrade）：\n   *     等 whenDefined 兑现后再要一次；\n   *  2. provider 后插入文档、或在 DOM 里被移动（keep-alive、列表重排）：\n   *     它 connected 时会广播 context-provider，听到就再要一次。\n   * 此刻 provider 的 client 可能仍是 undefined（框架还没把 prop 写进来），没关系：\n   * subscribe 已经挂上，等 prop 写进来时 @Watch 会再通知一次。\n   */\n  const retry = () => {\n    if (!answered && !released && element.isConnected) fire();\n  };\n\n  if (!answered && typeof customElements !== 'undefined') {\n    void customElements.whenDefined('pt-provider').then(retry);\n  }\n\n  /* 挂在 document 上：provider 的广播带 composed，从任何影子树里都能冒到这里 */\n  const onProviderAvailable = () => retry();\n  if (!answered && typeof document !== 'undefined') {\n    document.addEventListener(CONTEXT_PROVIDER_EVENT, onProviderAvailable);\n  }\n\n  return () => {\n    released = true;\n    if (typeof document !== 'undefined')\n      document.removeEventListener(CONTEXT_PROVIDER_EVENT, onProviderAvailable);\n    unsubscribe?.();\n  };\n}\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;AAWG;AAUH;;;;;;AAMG;AACI,MAAM,iBAAiB,GAAG;AAEjC;AACO,MAAM,sBAAsB,GAAG;AAIhC,MAAO,mBAAuB,SAAQ,KAAK,CAAA;AAK/C,IAAA,WAAA,CAAY,OAAe,EAAE,QAA4B,EAAE,SAAS,GAAG,KAAK,EAAA;AAC1E,QAAA,KAAK,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AAC7E,QAAA,IAAI,CAAC,OAAO,GAAG,OAAO;AACtB,QAAA,IAAI,CAAC,QAAQ,GAAG,QAAQ;AACxB,QAAA,IAAI,CAAC,SAAS,GAAG,SAAS;;AAE7B;AAED;;;;;;;AAOG;AACG,SAAU,aAAa,CAC3B,OAAoB,EACpB,QAA6C,EAC7C,SAAS,GAAG,IAAI,EAAA;AAEhB,IAAA,IAAI,WAAqC;IACzC,IAAI,QAAQ,GAAG,KAAK;IACpB,IAAI,QAAQ,GAAG,KAAK;;IAEpB,IAAI,MAAM,GAAG,CAAC;IACd,IAAI,QAAQ,GAAG,CAAC;IAEhB,MAAM,IAAI,GAAG,MAAK;AAChB,QAAA,MAAM,EAAE,GAAG,EAAE,MAAM;AACnB,QAAA,OAAO,CAAC,aAAa,CACnB,IAAI,mBAAmB,CACrB,iBAAiB,EACjB,CAAC,KAAK,EAAE,OAAO,KAAI;AACjB;;;AAGqC;YACrC,IAAI,QAAQ,KAAK,QAAQ,IAAI,EAAE,KAAK,QAAQ,CAAC,EAAE;gBAC7C,OAAO,IAAI;gBACX;;YAEF,QAAQ,GAAG,IAAI;YACf,QAAQ,GAAG,EAAE;AACb;;AAEsC;AACtC,YAAA,IAAI,OAAO;gBAAE,WAAW,GAAG,OAAO;YAClC,QAAQ,CAAC,KAAK,CAAC;AACjB,SAAC,EACD,SAAS,CACV,CACF;AACH,KAAC;AAED,IAAA,IAAI,EAAE;AAEN;;;;;;;;;;AAUG;IACH,MAAM,KAAK,GAAG,MAAK;QACjB,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,WAAW;AAAE,YAAA,IAAI,EAAE;AAC3D,KAAC;IAED,IAAI,CAAC,QAAQ,IAAI,OAAO,cAAc,KAAK,WAAW,EAAE;QACtD,KAAK,cAAc,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;;;AAI5D,IAAA,MAAM,mBAAmB,GAAG,MAAM,KAAK,EAAE;IACzC,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,WAAW,EAAE;AAChD,QAAA,QAAQ,CAAC,gBAAgB,CAAC,sBAAsB,EAAE,mBAAmB,CAAC;;AAGxE,IAAA,OAAO,MAAK;QACV,QAAQ,GAAG,IAAI;QACf,IAAI,OAAO,QAAQ,KAAK,WAAW;AACjC,YAAA,QAAQ,CAAC,mBAAmB,CAAC,sBAAsB,EAAE,mBAAmB,CAAC;QAC3E,WAAW,IAAI;AACjB,KAAC;AACH;;;;;;;"}

package/dist/cjs/loader.cjs.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var index = require('./index-DRCOne2Q.js');
+var appGlobals = require('./app-globals-V2Kpy_OQ.js');
+
+const defineCustomElements = async (win, options) => {
+  if (typeof window === 'undefined') return undefined;
+  await appGlobals.globalScripts();
+  return index.bootstrapLazy([["pt-provider.cjs",[[0,"pt-provider",{"client":[16]},[[0,"context-request","handleContextRequest"]],{"client":[{"onClientChange":0}]}]]]], options);
+};
+
+exports.setNonce = index.setNonce;
+exports.defineCustomElements = defineCustomElements;
+//# sourceMappingURL=loader.cjs.js.map
+
+//# sourceMappingURL=loader.cjs.js.map

package/dist/cjs/loader.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.cjs.js","sources":["@lazy-external-entrypoint?app-data=conditional"],"sourcesContent":["export { setNonce } from '@stencil/core';\nimport { bootstrapLazy } from '@stencil/core';\nimport { globalScripts } from '@stencil/core/internal/app-globals';\nexport const defineCustomElements = async (win, options) => {\n  if (typeof window === 'undefined') return undefined;\n  await globalScripts();\n  return bootstrapLazy([/*!__STENCIL_LAZY_DATA__*/], options);\n};\n"],"names":["globalScripts","bootstrapLazy"],"mappings":";;;;;AAGY,MAAC,oBAAoB,GAAG,OAAO,GAAG,EAAE,OAAO,KAAK;AAC5D,EAAE,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,OAAO,SAAS;AACrD,EAAE,MAAMA,wBAAa,EAAE;AACvB,EAAE,OAAOC,mBAAa,CAAC,4BAA4B,EAAE,OAAO,CAAC;AAC7D;;;;;"}

package/dist/cjs/pt-provider.cjs.entry.js

@@ -0,0 +1,85 @@
+'use strict';
+
+var index = require('./index-DRCOne2Q.js');
+var index$1 = require('./index.cjs.js');
+
+const PtProvider = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        /**
+         * 订阅者 → 最近一次交给它的值。
+         *
+         * client 变了要逐个通知，而不是让它们自己轮询；记住上次的值是为了不重复通知：
+         * 同一个 client 发两遍只是多一次无意义的重渲染。
+         */
+        this.subscribers = new Map();
+    }
+    onClientChange(next) {
+        for (const [callback, last] of this.subscribers) {
+            if (last === next)
+                continue;
+            this.subscribers.set(callback, next);
+            callback(next, () => this.subscribers.delete(callback));
+        }
+    }
+    /**
+     * 挂到文档上就广播一声（协议里的 context-provider）。
+     *
+     * 子组件先于 provider 就绪、或 provider 后来才插进文档 / 在 DOM 里被移动时，
+     * 它们之前的请求都没人接；听到这一声会再请求一次。
+     */
+    connectedCallback() {
+        this.host.dispatchEvent(new Event(index$1.CONTEXT_PROVIDER_EVENT, { bubbles: true, composed: true }));
+    }
+    /**
+     * 首次渲染完成后补一次通知。
+     *
+     * @Watch 只在组件进入 watch-ready 之后才触发；在那之前写进来的 client
+     * 会被 Stencil 静默当成初始值。Angular 正好落在这个窗口里：它先把元素接进
+     * 文档（子组件随即发出 context 请求，拿到 undefined 并订阅），再在第一轮变更
+     * 检测里写 [client] —— 没有这一次补发，订阅者会永远停在「没有 client」。
+     * 已经拿到这个 client 的订阅者不会被重复通知（见 onClientChange）。
+     */
+    componentDidLoad() {
+        if (this.client)
+            this.onClientChange(this.client);
+    }
+    /*
+     * 断开时**不**清空订阅者。
+     *
+     * 消费者各自持有退订函数并在自己卸载时调用；provider 只是在 DOM 里被移动
+     * （框架 keep-alive、列表重排）时，订阅要原样保留 —— 清掉的话子组件永远停在旧 client 上，
+     * 而它们自己没断连，不会重新请求。provider 真的被丢弃时，这个 Set 随它一起被回收。
+     */
+    /**
+     * 拦下子树冒泡上来的 context 请求。
+     *
+     * `stopPropagation()` 是必须的：不拦住的话，嵌套 provider 时外层也会响应，
+     * 子组件会先后收到两个 client，最后一个赢 —— 恰好与「就近取用」的直觉相反。
+     */
+    handleContextRequest(event) {
+        const request = event;
+        if (request.context !== index$1.PT_CLIENT_CONTEXT || typeof request.callback !== 'function')
+            return;
+        event.stopPropagation();
+        if (request.subscribe) {
+            const callback = request.callback;
+            this.subscribers.set(callback, this.client);
+            callback(this.client, () => this.subscribers.delete(callback));
+        }
+        else {
+            request.callback(this.client);
+        }
+    }
+    get host() { return index.getElement(this); }
+    static get watchers() { return {
+        "client": [{
+                "onClientChange": 0
+            }]
+    }; }
+};
+
+exports.pt_provider = PtProvider;
+//# sourceMappingURL=pt-provider.entry.cjs.js.map
+
+//# sourceMappingURL=pt-provider.cjs.entry.js.map

package/dist/cjs/pt-provider.cjs.entry.js.map

@@ -0,0 +1 @@
+{"file":"pt-provider.cjs.entry.js","mappings":";;;;;MAkDa,UAAU,GAAA,MAAA;AApBvB,IAAA,WAAA,CAAA,OAAA,EAAA;;AA0BE;;;;;AAKG;AACK,QAAA,IAAA,CAAA,WAAW,GAAG,IAAI,GAAG,EAA2D;AAmEzF;AAhEC,IAAA,cAAc,CAAC,IAAwB,EAAA;QACrC,KAAK,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,WAAW,EAAE;YAC/C,IAAI,IAAI,KAAK,IAAI;gBAAE;YACnB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC;AACpC,YAAA,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;;;AAI3D;;;;;AAKG;IACH,iBAAiB,GAAA;QACf,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,KAAK,CAACA,8BAAsB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;;AAG/F;;;;;;;;AAQG;IACH,gBAAgB,GAAA;QACd,IAAI,IAAI,CAAC,MAAM;AAAE,YAAA,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC;;AAGnD;;;;;;AAMG;AAEH;;;;;AAKG;AAEH,IAAA,oBAAoB,CAAC,KAAY,EAAA;QAC/B,MAAM,OAAO,GAAG,KAIf;QACD,IAAI,OAAO,CAAC,OAAO,KAAKC,yBAAiB,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,UAAU;YAAE;QAErF,KAAK,CAAC,eAAe,EAAE;AAEvB,QAAA,IAAI,OAAO,CAAC,SAAS,EAAE;AACrB,YAAA,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ;YACjC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC;AAC3C,YAAA,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;;aACzD;AACL,YAAA,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;;;;;;;;;;;;;","names":["CONTEXT_PROVIDER_EVENT","PT_CLIENT_CONTEXT"],"sources":["src/components/pt-provider/pt-provider.tsx"],"sourcesContent":["import { Component, Element, Listen, Prop, Watch } from '@stencil/core';\n\nimport {\n  CONTEXT_PROVIDER_EVENT,\n  PT_CLIENT_CONTEXT,\n  type Client,\n  type ContextCallback\n} from '../../utils/context';\n\n/**\n * 向子树提供一个 client。\n *\n * 业务组件暂时都移除了，这个元素是 widgets 层的占位：注入机制先留着，业务组件以后再加。\n *\n * ```html\n * <pt-provider id=\"root\">\n *   <!-- 使用 client 的业务组件 -->\n * </pt-provider>\n * <script type=\"module\">\n *   document.querySelector('#root').client = client;\n * </script>\n * ```\n *\n * `client` 是对象，只能走 property，不能走 attribute —— 原生 HTML 下\n * attribute 只能传字符串（docs/component-api.md §2 的属性约定）。\n *\n * 可以嵌套：内层 provider 会拦下请求，子树因此可以对接不同的账号或环境。\n *\n * @slot - 使用这个 client 的子树\n */\n@Component({\n  tag: 'pt-provider',\n  /**\n   * 不用 Shadow DOM，而且**故意不实现 render()**。\n   *\n   * 这个组件的职责是纯运行时的依赖注入，不该在 DOM 上留下任何痕迹。\n   * 另外两种写法都试过，都有实际代价：\n   *\n   *  · `shadow: false` + `render() { return <slot /> }`\n   *    SSR 时 Stencil 会在 slot 位置写入标记节点，客户端渲染没有它们，\n   *    React 报 hydration #418 并把整棵子树重渲一遍（首屏闪烁）。\n   *  · `shadow: true` + `<slot />`\n   *    Nuxt / Vue 的 SSR 会把子树序列化进 Declarative Shadow DOM 模板里，\n   *    客户端接管后又在 light DOM 建了一份 —— 页面上出现两个子组件。\n   *\n   * 不写 render() 时 Stencil 完全不碰宿主的子节点：SSR 输出就是原样的\n   * `<pt-provider>…children…</pt-provider>`，两个框架都没有任何可错配的东西。\n   */\n  shadow: false\n})\nexport class PtProvider {\n  @Element() host!: HTMLPtProviderElement;\n\n  /** 注入给子树的 client。用 property 赋值 */\n  @Prop() client?: Client;\n\n  /**\n   * 订阅者 → 最近一次交给它的值。\n   *\n   * client 变了要逐个通知，而不是让它们自己轮询；记住上次的值是为了不重复通知：\n   * 同一个 client 发两遍只是多一次无意义的重渲染。\n   */\n  private subscribers = new Map<ContextCallback<Client | undefined>, Client | undefined>();\n\n  @Watch('client')\n  onClientChange(next: Client | undefined) {\n    for (const [callback, last] of this.subscribers) {\n      if (last === next) continue;\n      this.subscribers.set(callback, next);\n      callback(next, () => this.subscribers.delete(callback));\n    }\n  }\n\n  /**\n   * 挂到文档上就广播一声（协议里的 context-provider）。\n   *\n   * 子组件先于 provider 就绪、或 provider 后来才插进文档 / 在 DOM 里被移动时，\n   * 它们之前的请求都没人接；听到这一声会再请求一次。\n   */\n  connectedCallback() {\n    this.host.dispatchEvent(new Event(CONTEXT_PROVIDER_EVENT, { bubbles: true, composed: true }));\n  }\n\n  /**\n   * 首次渲染完成后补一次通知。\n   *\n   * @Watch 只在组件进入 watch-ready 之后才触发；在那之前写进来的 client\n   * 会被 Stencil 静默当成初始值。Angular 正好落在这个窗口里：它先把元素接进\n   * 文档（子组件随即发出 context 请求，拿到 undefined 并订阅），再在第一轮变更\n   * 检测里写 [client] —— 没有这一次补发，订阅者会永远停在「没有 client」。\n   * 已经拿到这个 client 的订阅者不会被重复通知（见 onClientChange）。\n   */\n  componentDidLoad() {\n    if (this.client) this.onClientChange(this.client);\n  }\n\n  /*\n   * 断开时**不**清空订阅者。\n   *\n   * 消费者各自持有退订函数并在自己卸载时调用；provider 只是在 DOM 里被移动\n   * （框架 keep-alive、列表重排）时，订阅要原样保留 —— 清掉的话子组件永远停在旧 client 上，\n   * 而它们自己没断连，不会重新请求。provider 真的被丢弃时，这个 Set 随它一起被回收。\n   */\n\n  /**\n   * 拦下子树冒泡上来的 context 请求。\n   *\n   * `stopPropagation()` 是必须的：不拦住的话，嵌套 provider 时外层也会响应，\n   * 子组件会先后收到两个 client，最后一个赢 —— 恰好与「就近取用」的直觉相反。\n   */\n  @Listen('context-request')\n  handleContextRequest(event: Event) {\n    const request = event as Event & {\n      context?: string;\n      callback?: ContextCallback<Client | undefined>;\n      subscribe?: boolean;\n    };\n    if (request.context !== PT_CLIENT_CONTEXT || typeof request.callback !== 'function') return;\n\n    event.stopPropagation();\n\n    if (request.subscribe) {\n      const callback = request.callback;\n      this.subscribers.set(callback, this.client);\n      callback(this.client, () => this.subscribers.delete(callback));\n    } else {\n      request.callback(this.client);\n    }\n  }\n}\n"],"version":3}

package/dist/cjs/ptengine-widgets.cjs.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var index = require('./index-DRCOne2Q.js');
+var appGlobals = require('./app-globals-V2Kpy_OQ.js');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+/*
+ Stencil Client Patch Browser v4.45.0 | MIT Licensed | https://stenciljs.com
+ */
+
+var patchBrowser = () => {
+  const importMeta = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('ptengine-widgets.cjs.js', document.baseURI).href));
+  const opts = {};
+  if (importMeta !== "") {
+    opts.resourcesUrl = new URL(".", importMeta).href;
+  }
+  return index.promiseResolve(opts);
+};
+
+patchBrowser().then(async (options) => {
+  await appGlobals.globalScripts();
+  return index.bootstrapLazy([["pt-provider.cjs",[[0,"pt-provider",{"client":[16]},[[0,"context-request","handleContextRequest"]],{"client":[{"onClientChange":0}]}]]]], options);
+});
+
+exports.setNonce = index.setNonce;
+//# sourceMappingURL=ptengine-widgets.cjs.js.map
+
+//# sourceMappingURL=ptengine-widgets.cjs.js.map

package/dist/cjs/ptengine-widgets.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ptengine-widgets.cjs.js","sources":["../../node_modules/.pnpm/@stencil+core@4.45.0/node_modules/@stencil/core/internal/client/patch-browser.js","@lazy-browser-entrypoint?app-data=conditional"],"sourcesContent":["/*\n Stencil Client Patch Browser v4.45.0 | MIT Licensed | https://stenciljs.com\n */\n\n// src/client/client-patch-browser.ts\nimport { BUILD, NAMESPACE } from \"@stencil/core/internal/app-data\";\nimport { consoleDevInfo, H, promiseResolve, win } from \"@stencil/core\";\nvar patchBrowser = () => {\n  if (BUILD.isDev && !BUILD.isTesting) {\n    consoleDevInfo(\"Running in development mode.\");\n  }\n  if (BUILD.cloneNodeFix) {\n    patchCloneNodeFix(H.prototype);\n  }\n  const scriptElm = BUILD.scriptDataOpts ? win.document && Array.from(win.document.querySelectorAll(\"script\")).find(\n    (s) => new RegExp(`/${NAMESPACE}(\\\\.esm)?\\\\.js($|\\\\?|#)`).test(s.src) || s.getAttribute(\"data-stencil-namespace\") === NAMESPACE\n  ) : null;\n  const importMeta = import.meta.url;\n  const opts = BUILD.scriptDataOpts ? (scriptElm || {})[\"data-opts\"] || {} : {};\n  if (importMeta !== \"\") {\n    opts.resourcesUrl = new URL(\".\", importMeta).href;\n  }\n  return promiseResolve(opts);\n};\nvar patchCloneNodeFix = (HTMLElementPrototype) => {\n  const nativeCloneNodeFn = HTMLElementPrototype.cloneNode;\n  HTMLElementPrototype.cloneNode = function(deep) {\n    if (this.nodeName === \"TEMPLATE\") {\n      return nativeCloneNodeFn.call(this, deep);\n    }\n    const clonedNode = nativeCloneNodeFn.call(this, false);\n    const srcChildNodes = this.childNodes;\n    if (deep) {\n      for (let i = 0; i < srcChildNodes.length; i++) {\n        if (srcChildNodes[i].nodeType !== 2) {\n          clonedNode.appendChild(srcChildNodes[i].cloneNode(true));\n        }\n      }\n    }\n    return clonedNode;\n  };\n};\nexport {\n  patchBrowser\n};\n","export { setNonce } from '@stencil/core';\nimport { bootstrapLazy } from '@stencil/core';\nimport { patchBrowser } from '@stencil/core/internal/client/patch-browser';\nimport { globalScripts } from '@stencil/core/internal/app-globals';\npatchBrowser().then(async (options) => {\n  await globalScripts();\n  return bootstrapLazy([/*!__STENCIL_LAZY_DATA__*/], options);\n});\n"],"names":["promiseResolve","globalScripts","bootstrapLazy"],"mappings":";;;;;;AAAA;AACA;AACA;;AAKA,IAAI,YAAY,GAAG,MAAM;AAUzB,EAAE,MAAM,UAAU,GAAG,yQAAe;AACpC,EAAE,MAAM,IAAI,GAAiE,EAAE;AAC/E,EAAE,IAAI,UAAU,KAAK,EAAE,EAAE;AACzB,IAAI,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC,IAAI;AACrD;AACA,EAAE,OAAOA,oBAAc,CAAC,IAAI,CAAC;AAC7B,CAAC;;ACnBD,YAAY,EAAE,CAAC,IAAI,CAAC,OAAO,OAAO,KAAK;AACvC,EAAE,MAAMC,wBAAa,EAAE;AACvB,EAAE,OAAOC,mBAAa,CAAC,4BAA4B,EAAE,OAAO,CAAC;AAC7D,CAAC,CAAC;;;;","x_google_ignoreList":[0]}

package/dist/collection/collection-manifest.json

@@ -0,0 +1,13 @@
+{
+  "entries": [
+    "components/pt-provider/pt-provider.js"
+  ],
+  "mixins": [],
+  "compiler": {
+    "name": "@stencil/core",
+    "version": "4.45.0",
+    "typescriptVersion": "5.8.3"
+  },
+  "collections": [],
+  "bundles": []
+}

package/dist/collection/components/pt-provider/pt-provider.js

@@ -0,0 +1,136 @@
+import { CONTEXT_PROVIDER_EVENT, PT_CLIENT_CONTEXT } from "../../utils/context";
+/**
+ * 向子树提供一个 client。
+ *
+ * 业务组件暂时都移除了，这个元素是 widgets 层的占位：注入机制先留着，业务组件以后再加。
+ *
+ * ```html
+ * <pt-provider id="root">
+ *   <!-- 使用 client 的业务组件 -->
+ * </pt-provider>
+ * <script type="module">
+ *   document.querySelector('#root').client = client;
+ * </script>
+ * ```
+ *
+ * `client` 是对象，只能走 property，不能走 attribute —— 原生 HTML 下
+ * attribute 只能传字符串（docs/component-api.md §2 的属性约定）。
+ *
+ * 可以嵌套：内层 provider 会拦下请求，子树因此可以对接不同的账号或环境。
+ *
+ * @slot - 使用这个 client 的子树
+ */
+export class PtProvider {
+    constructor() {
+        /**
+         * 订阅者 → 最近一次交给它的值。
+         *
+         * client 变了要逐个通知，而不是让它们自己轮询；记住上次的值是为了不重复通知：
+         * 同一个 client 发两遍只是多一次无意义的重渲染。
+         */
+        this.subscribers = new Map();
+    }
+    onClientChange(next) {
+        for (const [callback, last] of this.subscribers) {
+            if (last === next)
+                continue;
+            this.subscribers.set(callback, next);
+            callback(next, () => this.subscribers.delete(callback));
+        }
+    }
+    /**
+     * 挂到文档上就广播一声（协议里的 context-provider）。
+     *
+     * 子组件先于 provider 就绪、或 provider 后来才插进文档 / 在 DOM 里被移动时，
+     * 它们之前的请求都没人接；听到这一声会再请求一次。
+     */
+    connectedCallback() {
+        this.host.dispatchEvent(new Event(CONTEXT_PROVIDER_EVENT, { bubbles: true, composed: true }));
+    }
+    /**
+     * 首次渲染完成后补一次通知。
+     *
+     * @Watch 只在组件进入 watch-ready 之后才触发；在那之前写进来的 client
+     * 会被 Stencil 静默当成初始值。Angular 正好落在这个窗口里：它先把元素接进
+     * 文档（子组件随即发出 context 请求，拿到 undefined 并订阅），再在第一轮变更
+     * 检测里写 [client] —— 没有这一次补发，订阅者会永远停在「没有 client」。
+     * 已经拿到这个 client 的订阅者不会被重复通知（见 onClientChange）。
+     */
+    componentDidLoad() {
+        if (this.client)
+            this.onClientChange(this.client);
+    }
+    /*
+     * 断开时**不**清空订阅者。
+     *
+     * 消费者各自持有退订函数并在自己卸载时调用；provider 只是在 DOM 里被移动
+     * （框架 keep-alive、列表重排）时，订阅要原样保留 —— 清掉的话子组件永远停在旧 client 上，
+     * 而它们自己没断连，不会重新请求。provider 真的被丢弃时，这个 Set 随它一起被回收。
+     */
+    /**
+     * 拦下子树冒泡上来的 context 请求。
+     *
+     * `stopPropagation()` 是必须的：不拦住的话，嵌套 provider 时外层也会响应，
+     * 子组件会先后收到两个 client，最后一个赢 —— 恰好与「就近取用」的直觉相反。
+     */
+    handleContextRequest(event) {
+        const request = event;
+        if (request.context !== PT_CLIENT_CONTEXT || typeof request.callback !== 'function')
+            return;
+        event.stopPropagation();
+        if (request.subscribe) {
+            const callback = request.callback;
+            this.subscribers.set(callback, this.client);
+            callback(this.client, () => this.subscribers.delete(callback));
+        }
+        else {
+            request.callback(this.client);
+        }
+    }
+    static get is() { return "pt-provider"; }
+    static get properties() {
+        return {
+            "client": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Client",
+                    "resolved": "object | undefined",
+                    "references": {
+                        "Client": {
+                            "location": "import",
+                            "path": "../../utils/context",
+                            "id": "src/utils/context.ts::Client",
+                            "referenceLocation": "Client"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "\u6CE8\u5165\u7ED9\u5B50\u6811\u7684 client\u3002\u7528 property \u8D4B\u503C"
+                },
+                "getter": false,
+                "setter": false
+            }
+        };
+    }
+    static get elementRef() { return "host"; }
+    static get watchers() {
+        return [{
+                "propName": "client",
+                "methodName": "onClientChange"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "context-request",
+                "method": "handleContextRequest",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
+    }
+}
+//# sourceMappingURL=pt-provider.js.map

package/dist/collection/components/pt-provider/pt-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pt-provider.js","sourceRoot":"","sources":["../../../src/components/pt-provider/pt-provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAExE,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EAGlB,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;GAoBG;AAqBH,MAAM,OAAO,UAAU;IApBvB;QA0BE;;;;;WAKG;QACK,gBAAW,GAAG,IAAI,GAAG,EAA2D,CAAC;KAmE1F;IAhEC,cAAc,CAAC,IAAwB;QACrC,KAAK,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YAChD,IAAI,IAAI,KAAK,IAAI;gBAAE,SAAS;YAC5B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;YACrC,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC1D,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,iBAAiB;QACf,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,KAAK,CAAC,sBAAsB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAChG,CAAC;IAED;;;;;;;;OAQG;IACH,gBAAgB;QACd,IAAI,IAAI,CAAC,MAAM;YAAE,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;OAMG;IAEH;;;;;OAKG;IAEH,oBAAoB,CAAC,KAAY;QAC/B,MAAM,OAAO,GAAG,KAIf,CAAC;QACF,IAAI,OAAO,CAAC,OAAO,KAAK,iBAAiB,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,UAAU;YAAE,OAAO;QAE5F,KAAK,CAAC,eAAe,EAAE,CAAC;QAExB,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YACtB,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;YAClC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YAC5C,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QACjE,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CACF","sourcesContent":["import { Component, Element, Listen, Prop, Watch } from '@stencil/core';\n\nimport {\n  CONTEXT_PROVIDER_EVENT,\n  PT_CLIENT_CONTEXT,\n  type Client,\n  type ContextCallback\n} from '../../utils/context';\n\n/**\n * 向子树提供一个 client。\n *\n * 业务组件暂时都移除了，这个元素是 widgets 层的占位：注入机制先留着，业务组件以后再加。\n *\n * ```html\n * <pt-provider id=\"root\">\n *   <!-- 使用 client 的业务组件 -->\n * </pt-provider>\n * <script type=\"module\">\n *   document.querySelector('#root').client = client;\n * </script>\n * ```\n *\n * `client` 是对象，只能走 property，不能走 attribute —— 原生 HTML 下\n * attribute 只能传字符串（docs/component-api.md §2 的属性约定）。\n *\n * 可以嵌套：内层 provider 会拦下请求，子树因此可以对接不同的账号或环境。\n *\n * @slot - 使用这个 client 的子树\n */\n@Component({\n  tag: 'pt-provider',\n  /**\n   * 不用 Shadow DOM，而且**故意不实现 render()**。\n   *\n   * 这个组件的职责是纯运行时的依赖注入，不该在 DOM 上留下任何痕迹。\n   * 另外两种写法都试过，都有实际代价：\n   *\n   *  · `shadow: false` + `render() { return <slot /> }`\n   *    SSR 时 Stencil 会在 slot 位置写入标记节点，客户端渲染没有它们，\n   *    React 报 hydration #418 并把整棵子树重渲一遍（首屏闪烁）。\n   *  · `shadow: true` + `<slot />`\n   *    Nuxt / Vue 的 SSR 会把子树序列化进 Declarative Shadow DOM 模板里，\n   *    客户端接管后又在 light DOM 建了一份 —— 页面上出现两个子组件。\n   *\n   * 不写 render() 时 Stencil 完全不碰宿主的子节点：SSR 输出就是原样的\n   * `<pt-provider>…children…</pt-provider>`，两个框架都没有任何可错配的东西。\n   */\n  shadow: false\n})\nexport class PtProvider {\n  @Element() host!: HTMLPtProviderElement;\n\n  /** 注入给子树的 client。用 property 赋值 */\n  @Prop() client?: Client;\n\n  /**\n   * 订阅者 → 最近一次交给它的值。\n   *\n   * client 变了要逐个通知，而不是让它们自己轮询；记住上次的值是为了不重复通知：\n   * 同一个 client 发两遍只是多一次无意义的重渲染。\n   */\n  private subscribers = new Map<ContextCallback<Client | undefined>, Client | undefined>();\n\n  @Watch('client')\n  onClientChange(next: Client | undefined) {\n    for (const [callback, last] of this.subscribers) {\n      if (last === next) continue;\n      this.subscribers.set(callback, next);\n      callback(next, () => this.subscribers.delete(callback));\n    }\n  }\n\n  /**\n   * 挂到文档上就广播一声（协议里的 context-provider）。\n   *\n   * 子组件先于 provider 就绪、或 provider 后来才插进文档 / 在 DOM 里被移动时，\n   * 它们之前的请求都没人接；听到这一声会再请求一次。\n   */\n  connectedCallback() {\n    this.host.dispatchEvent(new Event(CONTEXT_PROVIDER_EVENT, { bubbles: true, composed: true }));\n  }\n\n  /**\n   * 首次渲染完成后补一次通知。\n   *\n   * @Watch 只在组件进入 watch-ready 之后才触发；在那之前写进来的 client\n   * 会被 Stencil 静默当成初始值。Angular 正好落在这个窗口里：它先把元素接进\n   * 文档（子组件随即发出 context 请求，拿到 undefined 并订阅），再在第一轮变更\n   * 检测里写 [client] —— 没有这一次补发，订阅者会永远停在「没有 client」。\n   * 已经拿到这个 client 的订阅者不会被重复通知（见 onClientChange）。\n   */\n  componentDidLoad() {\n    if (this.client) this.onClientChange(this.client);\n  }\n\n  /*\n   * 断开时**不**清空订阅者。\n   *\n   * 消费者各自持有退订函数并在自己卸载时调用；provider 只是在 DOM 里被移动\n   * （框架 keep-alive、列表重排）时，订阅要原样保留 —— 清掉的话子组件永远停在旧 client 上，\n   * 而它们自己没断连，不会重新请求。provider 真的被丢弃时，这个 Set 随它一起被回收。\n   */\n\n  /**\n   * 拦下子树冒泡上来的 context 请求。\n   *\n   * `stopPropagation()` 是必须的：不拦住的话，嵌套 provider 时外层也会响应，\n   * 子组件会先后收到两个 client，最后一个赢 —— 恰好与「就近取用」的直觉相反。\n   */\n  @Listen('context-request')\n  handleContextRequest(event: Event) {\n    const request = event as Event & {\n      context?: string;\n      callback?: ContextCallback<Client | undefined>;\n      subscribe?: boolean;\n    };\n    if (request.context !== PT_CLIENT_CONTEXT || typeof request.callback !== 'function') return;\n\n    event.stopPropagation();\n\n    if (request.subscribe) {\n      const callback = request.callback;\n      this.subscribers.set(callback, this.client);\n      callback(this.client, () => this.subscribers.delete(callback));\n    } else {\n      request.callback(this.client);\n    }\n  }\n}\n"]}

package/dist/collection/index.js

@@ -0,0 +1,9 @@
+/**
+ * @ptengine/widgets —— 业务组件内核的公共入口。
+ *
+ * 业务组件不自己创建 client：把它们放在 `<pt-provider>` 里，
+ * 组件挂载时会向上请求一个 client（Context Protocol，走 DOM 事件，跨框架一致）。
+ */
+export { CONTEXT_PROVIDER_EVENT, PT_CLIENT_CONTEXT, ContextRequestEvent, requestClient } from './utils/context';
+export * from './components';
+//# sourceMappingURL=index.js.map

package/dist/collection/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,EACd,MAAM,iBAAiB,CAAC;AAGzB,cAAc,cAAc,CAAC","sourcesContent":["/**\n * @ptengine/widgets —— 业务组件内核的公共入口。\n *\n * 业务组件不自己创建 client：把它们放在 `<pt-provider>` 里，\n * 组件挂载时会向上请求一个 client（Context Protocol，走 DOM 事件，跨框架一致）。\n */\nexport {\n  CONTEXT_PROVIDER_EVENT,\n  PT_CLIENT_CONTEXT,\n  ContextRequestEvent,\n  requestClient\n} from './utils/context';\nexport type { Client, ContextCallback } from './utils/context';\n\nexport * from './components';\n"]}

package/dist/collection/utils/context.js

@@ -0,0 +1,98 @@
+/**
+ * 依赖注入：Web Components 社区的 Context Protocol。
+ *
+ * 业务组件不自己创建 client，也不读全局变量，而是在挂载时向上冒泡一个
+ * `context-request` 事件，由最近的 `<pt-provider>` 回调返回 client。
+ *
+ * 选它而不是各框架自己的 context 机制，是因为它走的是 DOM 事件：
+ * React、Vue、Angular、原生 HTML 里行为完全一致，也能穿透 Shadow DOM
+ * （事件带 composed: true）。两层因此可以独立发版、独立测试。
+ *
+ * 协议出处：https://github.com/webcomponents-cg/community-protocols
+ */
+/**
+ * context 的标识。
+ *
+ * 用字符串而不是 Symbol：页面上同时存在两份打包产物时（比如宿主应用装了一份、
+ * 某个微前端子应用又装了一份），两个 Symbol 不相等，注入会静默失败；
+ * 字符串永远相等。代价是理论上可能与别人撞名，所以带上包名前缀。
+ */
+export const PT_CLIENT_CONTEXT = '@ptengine/client';
+/** provider 挂到文档上时广播的事件名（协议里的 context-provider）：未得到应答的消费者据此再问一次 */
+export const CONTEXT_PROVIDER_EVENT = 'context-provider';
+export class ContextRequestEvent extends Event {
+    constructor(context, callback, subscribe = false) {
+        super('context-request', { bubbles: true, composed: true, cancelable: true });
+        this.context = context;
+        this.callback = callback;
+        this.subscribe = subscribe;
+    }
+}
+/**
+ * 向上请求一个 client。
+ *
+ * `subscribe: true` 时，provider 换了 client 会再次回调（例如切换账号），
+ * 返回值是退订函数 —— 组件在 disconnectedCallback 里调用它。
+ *
+ * 找不到 provider 时回调不会被触发，组件应当据此降级（显示「未接入」而不是报错）。
+ */
+export function requestClient(element, callback, subscribe = true) {
+    let unsubscribe;
+    let answered = false;
+    let released = false;
+    /** 发出去的请求编号与被接受的那一个：同一个消费者只能持有一份订阅 */
+    let latest = 0;
+    let accepted = 0;
+    const fire = () => {
+        const id = ++latest;
+        element.dispatchEvent(new ContextRequestEvent(PT_CLIENT_CONTEXT, (value, dispose) => {
+            /* 组件已经退订（卸载）后才姗姗来迟的应答，直接丢掉。
+             * 另一种迟到：兜底重试发了第二个请求，而第一个其实被 provider 排队了
+             * （Stencil 在实例就绪前会把 @Listen 收到的事件先攒着、就绪后重放），
+             * 两个都被应答就成了两份订阅 —— 只认第一份，其余的当场退订。 */
+            if (released || (answered && id !== accepted)) {
+                dispose?.();
+                return;
+            }
+            answered = true;
+            accepted = id;
+            /* 只记住最新的退订函数，**不要**调用旧的：provider 每次通知都会给一个新的
+             * dispose，而它们删除的是同一个订阅。调旧的等于把自己退订 ——
+             * 消费者从此只能收到两次值，第二次换 client 之后永久停更。 */
+            if (dispose)
+                unsubscribe = dispose;
+            callback(value);
+        }, subscribe));
+    };
+    fire();
+    /**
+     * 没人应答时不能就此放弃：上层的 <pt-provider> 未必比子组件先就绪。
+     *
+     * 两种情况，两条兜底：
+     *  1. provider 的类还没注册（懒加载，Vue / Nuxt 里实测子组件先 upgrade）：
+     *     等 whenDefined 兑现后再要一次；
+     *  2. provider 后插入文档、或在 DOM 里被移动（keep-alive、列表重排）：
+     *     它 connected 时会广播 context-provider，听到就再要一次。
+     * 此刻 provider 的 client 可能仍是 undefined（框架还没把 prop 写进来），没关系：
+     * subscribe 已经挂上，等 prop 写进来时 @Watch 会再通知一次。
+     */
+    const retry = () => {
+        if (!answered && !released && element.isConnected)
+            fire();
+    };
+    if (!answered && typeof customElements !== 'undefined') {
+        void customElements.whenDefined('pt-provider').then(retry);
+    }
+    /* 挂在 document 上：provider 的广播带 composed，从任何影子树里都能冒到这里 */
+    const onProviderAvailable = () => retry();
+    if (!answered && typeof document !== 'undefined') {
+        document.addEventListener(CONTEXT_PROVIDER_EVENT, onProviderAvailable);
+    }
+    return () => {
+        released = true;
+        if (typeof document !== 'undefined')
+            document.removeEventListener(CONTEXT_PROVIDER_EVENT, onProviderAvailable);
+        unsubscribe?.();
+    };
+}
+//# sourceMappingURL=context.js.map

package/dist/collection/utils/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/utils/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAUH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,kBAA2B,CAAC;AAE7D,mEAAmE;AACnE,MAAM,CAAC,MAAM,sBAAsB,GAAG,kBAA2B,CAAC;AAIlE,MAAM,OAAO,mBAAuB,SAAQ,KAAK;IAK/C,YAAY,OAAe,EAAE,QAA4B,EAAE,SAAS,GAAG,KAAK;QAC1E,KAAK,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;QAC9E,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAoB,EACpB,QAA6C,EAC7C,SAAS,GAAG,IAAI;IAEhB,IAAI,WAAqC,CAAC;IAC1C,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,sCAAsC;IACtC,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,QAAQ,GAAG,CAAC,CAAC;IAEjB,MAAM,IAAI,GAAG,GAAG,EAAE;QAChB,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,aAAa,CACnB,IAAI,mBAAmB,CACrB,iBAAiB,EACjB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;YACjB;;;iDAGqC;YACrC,IAAI,QAAQ,IAAI,CAAC,QAAQ,IAAI,EAAE,KAAK,QAAQ,CAAC,EAAE,CAAC;gBAC9C,OAAO,EAAE,EAAE,CAAC;gBACZ,OAAO;YACT,CAAC;YACD,QAAQ,GAAG,IAAI,CAAC;YAChB,QAAQ,GAAG,EAAE,CAAC;YACd;;kDAEsC;YACtC,IAAI,OAAO;gBAAE,WAAW,GAAG,OAAO,CAAC;YACnC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAClB,CAAC,EACD,SAAS,CACV,CACF,CAAC;IACJ,CAAC,CAAC;IAEF,IAAI,EAAE,CAAC;IAEP;;;;;;;;;;OAUG;IACH,MAAM,KAAK,GAAG,GAAG,EAAE;QACjB,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,WAAW;YAAE,IAAI,EAAE,CAAC;IAC5D,CAAC,CAAC;IAEF,IAAI,CAAC,QAAQ,IAAI,OAAO,cAAc,KAAK,WAAW,EAAE,CAAC;QACvD,KAAK,cAAc,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7D,CAAC;IAED,wDAAwD;IACxD,MAAM,mBAAmB,GAAG,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC;IAC1C,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,WAAW,EAAE,CAAC;QACjD,QAAQ,CAAC,gBAAgB,CAAC,sBAAsB,EAAE,mBAAmB,CAAC,CAAC;IACzE,CAAC;IAED,OAAO,GAAG,EAAE;QACV,QAAQ,GAAG,IAAI,CAAC;QAChB,IAAI,OAAO,QAAQ,KAAK,WAAW;YACjC,QAAQ,CAAC,mBAAmB,CAAC,sBAAsB,EAAE,mBAAmB,CAAC,CAAC;QAC5E,WAAW,EAAE,EAAE,CAAC;IAClB,CAAC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * 依赖注入：Web Components 社区的 Context Protocol。\n *\n * 业务组件不自己创建 client，也不读全局变量，而是在挂载时向上冒泡一个\n * `context-request` 事件，由最近的 `<pt-provider>` 回调返回 client。\n *\n * 选它而不是各框架自己的 context 机制，是因为它走的是 DOM 事件：\n * React、Vue、Angular、原生 HTML 里行为完全一致，也能穿透 Shadow DOM\n * （事件带 composed: true）。两层因此可以独立发版、独立测试。\n *\n * 协议出处：https://github.com/webcomponents-cg/community-protocols\n */\n\n/**\n * 注入给子树的 client。\n *\n * 能力层 SDK 暂时移除，这里是它的占位：provider 只做引用传递，不关心 client 长什么样。\n * 将来 SDK 加回来时换成 `@ptengine/sdk` 的 `Client`。\n */\nexport type Client = object;\n\n/**\n * context 的标识。\n *\n * 用字符串而不是 Symbol：页面上同时存在两份打包产物时（比如宿主应用装了一份、\n * 某个微前端子应用又装了一份），两个 Symbol 不相等，注入会静默失败；\n * 字符串永远相等。代价是理论上可能与别人撞名，所以带上包名前缀。\n */\nexport const PT_CLIENT_CONTEXT = '@ptengine/client' as const;\n\n/** provider 挂到文档上时广播的事件名（协议里的 context-provider）：未得到应答的消费者据此再问一次 */\nexport const CONTEXT_PROVIDER_EVENT = 'context-provider' as const;\n\nexport type ContextCallback<T> = (value: T, unsubscribe?: () => void) => void;\n\nexport class ContextRequestEvent<T> extends Event {\n  readonly context: string;\n  readonly callback: ContextCallback<T>;\n  readonly subscribe: boolean;\n\n  constructor(context: string, callback: ContextCallback<T>, subscribe = false) {\n    super('context-request', { bubbles: true, composed: true, cancelable: true });\n    this.context = context;\n    this.callback = callback;\n    this.subscribe = subscribe;\n  }\n}\n\n/**\n * 向上请求一个 client。\n *\n * `subscribe: true` 时，provider 换了 client 会再次回调（例如切换账号），\n * 返回值是退订函数 —— 组件在 disconnectedCallback 里调用它。\n *\n * 找不到 provider 时回调不会被触发，组件应当据此降级（显示「未接入」而不是报错）。\n */\nexport function requestClient(\n  element: HTMLElement,\n  callback: ContextCallback<Client | undefined>,\n  subscribe = true\n): () => void {\n  let unsubscribe: (() => void) | undefined;\n  let answered = false;\n  let released = false;\n  /** 发出去的请求编号与被接受的那一个：同一个消费者只能持有一份订阅 */\n  let latest = 0;\n  let accepted = 0;\n\n  const fire = () => {\n    const id = ++latest;\n    element.dispatchEvent(\n      new ContextRequestEvent<Client | undefined>(\n        PT_CLIENT_CONTEXT,\n        (value, dispose) => {\n          /* 组件已经退订（卸载）后才姗姗来迟的应答，直接丢掉。\n           * 另一种迟到：兜底重试发了第二个请求，而第一个其实被 provider 排队了\n           * （Stencil 在实例就绪前会把 @Listen 收到的事件先攒着、就绪后重放），\n           * 两个都被应答就成了两份订阅 —— 只认第一份，其余的当场退订。 */\n          if (released || (answered && id !== accepted)) {\n            dispose?.();\n            return;\n          }\n          answered = true;\n          accepted = id;\n          /* 只记住最新的退订函数，**不要**调用旧的：provider 每次通知都会给一个新的\n           * dispose，而它们删除的是同一个订阅。调旧的等于把自己退订 ——\n           * 消费者从此只能收到两次值，第二次换 client 之后永久停更。 */\n          if (dispose) unsubscribe = dispose;\n          callback(value);\n        },\n        subscribe\n      )\n    );\n  };\n\n  fire();\n\n  /**\n   * 没人应答时不能就此放弃：上层的 <pt-provider> 未必比子组件先就绪。\n   *\n   * 两种情况，两条兜底：\n   *  1. provider 的类还没注册（懒加载，Vue / Nuxt 里实测子组件先 upgrade）：\n   *     等 whenDefined 兑现后再要一次；\n   *  2. provider 后插入文档、或在 DOM 里被移动（keep-alive、列表重排）：\n   *     它 connected 时会广播 context-provider，听到就再要一次。\n   * 此刻 provider 的 client 可能仍是 undefined（框架还没把 prop 写进来），没关系：\n   * subscribe 已经挂上，等 prop 写进来时 @Watch 会再通知一次。\n   */\n  const retry = () => {\n    if (!answered && !released && element.isConnected) fire();\n  };\n\n  if (!answered && typeof customElements !== 'undefined') {\n    void customElements.whenDefined('pt-provider').then(retry);\n  }\n\n  /* 挂在 document 上：provider 的广播带 composed，从任何影子树里都能冒到这里 */\n  const onProviderAvailable = () => retry();\n  if (!answered && typeof document !== 'undefined') {\n    document.addEventListener(CONTEXT_PROVIDER_EVENT, onProviderAvailable);\n  }\n\n  return () => {\n    released = true;\n    if (typeof document !== 'undefined')\n      document.removeEventListener(CONTEXT_PROVIDER_EVENT, onProviderAvailable);\n    unsubscribe?.();\n  };\n}\n"]}

package/dist/components/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Get the base path to where the assets can be found. Use "setAssetPath(path)"
+ * if the path needs to be customized.
+ */
+export declare const getAssetPath: (path: string) => string;
+
+/**
+ * Used to manually set the base path where assets can be found.
+ * If the script is used as "module", it's recommended to use "import.meta.url",
+ * such as "setAssetPath(import.meta.url)". Other options include
+ * "setAssetPath(document.currentScript.src)", or using a bundler's replace plugin to
+ * dynamically set the path at build time, such as "setAssetPath(process.env.ASSET_PATH)".
+ * But do note that this configuration depends on how your script is bundled, or lack of
+ * bundling, and where your assets can be loaded from. Additionally custom bundling
+ * will have to ensure the static assets are copied to its build directory.
+ */
+export declare const setAssetPath: (path: string) => void;
+
+/**
+ * Used to specify a nonce value that corresponds with an application's CSP.
+ * When set, the nonce will be added to all dynamically created script and style tags at runtime.
+ * Alternatively, the nonce value can be set on a meta tag in the DOM head
+ * (<meta name="csp-nonce" content="{ nonce value here }" />) which
+ * will result in the same behavior.
+ */
+export declare const setNonce: (nonce: string) => void
+
+export interface SetPlatformOptions {
+  raf?: (c: FrameRequestCallback) => number;
+  ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+}
+export declare const setPlatformOptions: (opts: SetPlatformOptions) => void;
+
+export * from '../types';