@supersoniks/concorde 4.8.0 → 4.9.0

package/scripts/github-export.mjs

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/**
+ * Prépare une arborescence « lib publique » pour GitHub :
+ * - sans site doc (src/docs, index.html, …)
+ * - sans sonic-captcha (altcha.supersoniks.org)
+ * - sans scripts / jobs GitLab internes
+ *
+ * Usage :
+ *   node scripts/github-export.mjs [répertoire_cible]
+ *
+ * Par défaut : ../concorde-github-export
+ */
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, "..");
+const IGNORE_FILE = path.join(ROOT, ".github-export-ignore");
+const DEFAULT_OUT = path.resolve(ROOT, "../concorde-github-export");
+
+const EXPORT_FILTER_KEY =
+  /(?:^|\/)(?:docs|mock-api|undefined)(?:\/|$)|captcha|\.demo\.|\.stories\.|TestUtils|\/prism\/|\/search\/|\/tailwind\/|\/header\/|\/navigation\/|\/layout\.ts$|\/code\.ts$|^code$|^docs$|^layout$/;
+
+function readIgnorePatterns() {
+  if (!fs.existsSync(IGNORE_FILE)) return [];
+  return fs
+    .readFileSync(IGNORE_FILE, "utf8")
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l && !l.startsWith("#"));
+}
+
+function globToRegExp(pattern) {
+  const escaped = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*\*/g, "{{GLOBSTAR}}")
+    .replace(/\*/g, "[^/]*")
+    .replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+
+function shouldExclude(relativePath, patterns) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  for (const pattern of patterns) {
+    const re = globToRegExp(pattern);
+    if (re.test(normalized)) return true;
+    if (normalized.startsWith(pattern.endsWith("/") ? pattern : `${pattern}/`))
+      return true;
+    if (normalized === pattern) return true;
+  }
+  return false;
+}
+
+function listAllFiles(dir, base = dir) {
+  const out = [];
+  for (const name of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (name.name === ".git" || name.name === "node_modules") continue;
+    const full = path.join(dir, name.name);
+    const rel = path.relative(base, full).replace(/\\/g, "/");
+    if (name.isDirectory()) {
+      if (shouldExclude(rel, ignorePatterns)) continue;
+      out.push(...listAllFiles(full, base));
+    } else {
+      if (!shouldExclude(rel, ignorePatterns)) out.push(rel);
+    }
+  }
+  return out;
+}
+
+function copyFile(rel, destRoot) {
+  const src = path.join(ROOT, rel);
+  const dest = path.join(destRoot, rel);
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+function patchUiTs(destRoot) {
+  const uiPath = path.join(
+    destRoot,
+    "src/core/components/ui/ui.ts",
+  );
+  if (!fs.existsSync(uiPath)) return;
+  const content = fs.readFileSync(uiPath, "utf8");
+  const patched = content.replace(
+    /import "\.\/captcha\/captcha";\n?/,
+    "",
+  );
+  fs.writeFileSync(uiPath, patched);
+}
+
+function exportHaystack(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") {
+    return `${value.types ?? ""}${value.default ?? ""}`;
+  }
+  return String(value);
+}
+
+function filterPackageJson(destRoot) {
+  const pkgPath = path.join(destRoot, "package.json");
+  if (!fs.existsSync(pkgPath)) return;
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  if (pkg.exports && typeof pkg.exports === "object") {
+    const next = {};
+    for (const [key, value] of Object.entries(pkg.exports)) {
+      const hay = `${key}:${exportHaystack(value)}`;
+      if (EXPORT_FILTER_KEY.test(hay)) continue;
+      if (exportHaystack(value).includes("/captcha/")) continue;
+      if (exportHaystack(value).includes("/docs/")) continue;
+      if (exportHaystack(value).includes(".demo.")) continue;
+      if (exportHaystack(value).includes(".stories.")) continue;
+      next[key] = value;
+    }
+    pkg.exports = next;
+  }
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+
+function patchReadme(destRoot) {
+  const readmePath = path.join(destRoot, "README.md");
+  if (!fs.existsSync(readmePath)) return;
+  let text = fs.readFileSync(readmePath, "utf8");
+  text = text.replace(
+    /Le dépôt GitHub est un \*\*miroir\*\* synchronisé depuis GitLab \(voir \[OPEN_SOURCE_CHECKPOINT\.md\]\(OPEN_SOURCE_CHECKPOINT\.md\)\)\./,
+    "Le dépôt GitHub est un **export filtré** depuis GitLab (librairie uniquement, sans site doc ni composant captcha — voir [OPEN_SOURCE_CHECKPOINT.md](OPEN_SOURCE_CHECKPOINT.md)).",
+  );
+  fs.writeFileSync(readmePath, text);
+}
+
+const ignorePatterns = readIgnorePatterns();
+const outDir = path.resolve(process.argv[2] || DEFAULT_OUT);
+
+if (fs.existsSync(outDir)) {
+  fs.rmSync(outDir, { recursive: true, force: true });
+}
+fs.mkdirSync(outDir, { recursive: true });
+
+const files = listAllFiles(ROOT);
+for (const rel of files) {
+  copyFile(rel, outDir);
+}
+
+patchUiTs(outDir);
+filterPackageJson(outDir);
+patchReadme(outDir);
+
+console.log(`✅ Export GitHub : ${files.length} fichiers → ${outDir}`);
+console.log("   Exclusions : .github-export-ignore");
+console.log("   Patches    : ui.ts (sans captcha), package.json exports");

package/scripts/post-build.mjs

@@ -2,6 +2,11 @@
 
 import fs from "fs";
 import path from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(__dirname, "..");
 
 //copy concorde-core.bundle.js and concorde-core.es.js from docs to the root of the project
 fs.copyFileSync(
@@ -12,3 +17,41 @@ fs.copyFileSync(
   path.resolve("dist/concorde-core.es.js"),
   path.resolve("concorde-core.es.js")
 );
+
+for (const file of ["concorde-core.bundle.js", "concorde-core.es.js"]) {
+  const content = fs.readFileSync(path.resolve(file), "utf8");
+  const checks = [
+    ["concordeIsLoaded", "signal de chargement"],
+    ["customElements.define", "enregistrement des web components"],
+    ["concorde-loaded", "événement concorde-loaded"],
+  ];
+  for (const [needle, label] of checks) {
+    if (!content.includes(needle)) {
+      console.error(`❌ ${file} : marqueur manquant (${label})`);
+      process.exit(1);
+    }
+  }
+}
+console.log("✅ Bundles concorde-core vérifiés");
+
+console.log("🚀 Génération des types (.d.ts)");
+const fetcherPath = path.join(root, "src/core/mixins/Fetcher.ts");
+const fetcherOriginal = fs.readFileSync(fetcherPath, "utf8");
+fs.writeFileSync(
+  fetcherPath,
+  fetcherOriginal.replace("protected async _fetchData()", "async _fetchData()")
+);
+try {
+  execSync("tsc -p src/tsconfig.declarations.json", {
+    cwd: root,
+    stdio: "inherit",
+  });
+} finally {
+  fs.writeFileSync(fetcherPath, fetcherOriginal);
+}
+
+console.log("🚀 Génération du JavaScript (dist/js/)");
+execSync("tsc -p src/tsconfig.emit.json", {
+  cwd: root,
+  stdio: "inherit",
+});

package/scripts/pre-build.mjs

@@ -43,10 +43,14 @@ function listFiles(dir) {
   return files;
 }
 const componentsFiles = listFiles(path.resolve(__dirname, "../src"));
+const isPublishableTs = (file) =>
+  file.match(/\.ts$/) &&
+  !file.match(/\.(spec|test|demo|stories|type-test)\.ts$/) &&
+  !file.includes("/docs/");
 //short notation for ts file
 const shortPathMapping = {};
 componentsFiles.forEach((file) => {
-  if (!file.match(/\.ts$/)) {
+  if (!isPublishableTs(file)) {
     return;
   }
   //add simplified path to tsconfig paths
@@ -108,6 +112,27 @@ fs.writeFileSync(tsConfigPath, JSON.stringify(tsConfig, null, 2));
 
 //Do the same using shrotpathMapping to fill the exports un package.json
 
+function typesPath(srcRelative) {
+  if (!srcRelative.endsWith(".ts")) return null;
+  return srcRelative
+    .replace(/^\.\/src\//, "./dist/types/")
+    .replace(/\.ts$/, ".d.ts");
+}
+
+function jsPath(srcRelative) {
+  if (!srcRelative.endsWith(".ts")) return null;
+  return srcRelative
+    .replace(/^\.\/src\//, "./dist/js/")
+    .replace(/\.ts$/, ".js");
+}
+
+function exportEntry(srcRelative) {
+  const types = typesPath(srcRelative);
+  const js = jsPath(srcRelative);
+  if (!types || !js) return srcRelative;
+  return { types, default: js };
+}
+
 const packageJsonPath = path.resolve(__dirname, "../package.json");
 let packageJson = JSON.parse(fs.readFileSync(packageJsonPath));
 
@@ -116,8 +141,11 @@ const pExports = {
     "./src/core/components/ui/icon/icons.json",
   "./core/components/functional/sdui/default-library.json":
     "./src/core/components/functional/sdui/default-library.json",
-  "./dataProviderKey": "./src/core/utils/dataProviderKey.ts",
-  "./*": "./src/*.ts",
+  "./dataProviderKey": exportEntry("./src/core/utils/dataProviderKey.ts"),
+  "./*": {
+    types: "./dist/types/*.d.ts",
+    default: "./dist/js/*.js",
+  },
   "./vite-config": "./vite/config.js",
   "./rollup-plugin-*": "./rollup/plugin-*.js",
 };
@@ -127,7 +155,7 @@ for (let key in shortPathMapping) {
   let p = shortPathMapping[key][0];
   //set path relative to project source
   p = p.replace(path.resolve(__dirname, "../src") + "/", "./src/");
-  pExports[key] = p;
+  pExports[key] = exportEntry(p);
 }
 
 packageJson.exports = pExports;

package/scripts/pre-publish.mjs

@@ -4,6 +4,8 @@ import fs from "fs";
 const requiredFiles = [
   'concorde-core.bundle.js',
   'concorde-core.es.js',
+  'dist/types/decorators.d.ts',
+  'dist/js/decorators.js',
   'ai/AGENTS.md',
   'scripts/ai-init.mjs',
 ];

package/src/core/components/functional/queue/queue.ts

@@ -60,7 +60,7 @@ export default class Queue extends Subscriber(LitElement, {} as QueueProps) {
   @property() filteredFields = "";
   disconnectedCallback() {
     for (const dataProvider of this.listDataProviders) {
-      PublisherManager.delete(dataProvider);
+      PublisherManager.getInstance().delete(dataProvider);
       this.listDataProviders = [];
     }
     this.filterPublisher?.offInternalMutation(this.updateFilteredContent);
@@ -167,7 +167,7 @@ export default class Queue extends Subscriber(LitElement, {} as QueueProps) {
      */
 
     for (const dataProvider of this.listDataProviders) {
-      PublisherManager.delete(dataProvider);
+      PublisherManager.getInstance().delete(dataProvider);
       // this.publisher.lastFetchedData = {};
     }
     this.listDataProviders = [];

package/src/core/components/ui/modal/modal.ts

@@ -445,7 +445,7 @@ export class Modal extends Subscriber(LitElement) {
   }
 
   // Show the modal
-  async show(): Promise<void> {
+  private async show(): Promise<void> {
     this._modalElement.show();
     this._animationState = "in";
     await this.animation("in");

package/src/core/decorators/Subscriber.ts

@@ -7,3 +7,4 @@ export type { HandleOptions } from "./subscriber/handle";
 export { autoSubscribe } from "./subscriber/autoSubscribe";
 export { autoFill } from "./subscriber/autoFill";
 export { ancestorAttribute } from "./subscriber/ancestorAttribute";
+export type { AncestorAttributeOptions } from "./subscriber/ancestorAttribute";

package/src/core/decorators/api.ts

@@ -522,7 +522,8 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
       : maybeOptions;
     const configurationKeyPath = configurationKey?.path;
     const triggerKeyPath = options?.triggerKey?.path;
-    const endpointDynamicDependencies = extractDynamicDependencies(pathTemplate);
+    const endpointDynamicDependencies =
+      extractDynamicDependencies(pathTemplate);
     const bodyKeyDynamicDependencies = extractDynamicDependencies(bodyKeyPath);
     const configKeyDynamicDependencies = configurationKeyPath
       ? extractDynamicDependencies(configurationKeyPath)
@@ -861,9 +862,8 @@ export function post<T, B, Ue = any, Uk = any, Ut = any>(
   target: object & { [P in K]?: ApiResult<T> | null | undefined },
   propertyKey: K,
 ) => void {
-  return createApiSendDecorator<T, B, Ue, Uk, Ut>(
-    "POST",
-    (api, path, body) => api.postDetailed<T, B>(path, body as B),
+  return createApiSendDecorator<T, B, Ue, Uk, Ut>("POST", (api, path, body) =>
+    api.postDetailed<T, B>(path, body as B),
   )(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions);
 }
 
@@ -921,9 +921,8 @@ export function put<T, B, Ue = any, Uk = any, Ut = any>(
   target: object & { [P in K]?: ApiResult<T> | null | undefined },
   propertyKey: K,
 ) => void {
-  return createApiSendDecorator<T, B, Ue, Uk, Ut>(
-    "PUT",
-    (api, path, body) => api.putDetailed<T, B>(path, body as B),
+  return createApiSendDecorator<T, B, Ue, Uk, Ut>("PUT", (api, path, body) =>
+    api.putDetailed<T, B>(path, body as B),
   )(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions);
 }
 
@@ -981,8 +980,7 @@ export function patch<T, B, Ue = any, Uk = any, Ut = any>(
   target: object & { [P in K]?: ApiResult<T> | null | undefined },
   propertyKey: K,
 ) => void {
-  return createApiSendDecorator<T, B, Ue, Uk, Ut>(
-    "PATCH",
-    (api, path, body) => api.patchDetailed<T, B>(path, body as B),
+  return createApiSendDecorator<T, B, Ue, Uk, Ut>("PATCH", (api, path, body) =>
+    api.patchDetailed<T, B>(path, body as B),
   )(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions);
 }

package/src/core/decorators/subscriber/ancestorAttribute.spec.ts

@@ -0,0 +1,197 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { ancestorAttribute } from "./ancestorAttribute";
+
+async function flushFrames(count = 2): Promise<void> {
+  for (let i = 0; i < count; i += 1) {
+    await new Promise<void>((resolve) => {
+      requestAnimationFrame(() => resolve());
+    });
+  }
+}
+
+describe("ancestorAttribute", () => {
+  afterEach(() => {
+    document.body.replaceChildren();
+  });
+
+  it("lit la valeur initiale au connect (mode statique par défaut)", () => {
+    const tag = "test-ancestor-attr-static-init";
+    class C extends HTMLElement {
+      @ancestorAttribute("dataProvider")
+      dataProvider: string | null = null;
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const wrap = document.createElement("div");
+    wrap.setAttribute("dataProvider", "scope-a");
+    const el = document.createElement(tag) as InstanceType<typeof C>;
+    wrap.appendChild(el);
+    document.body.appendChild(wrap);
+
+    expect(el.dataProvider).toBe("scope-a");
+  });
+
+  it("ne réagit pas aux mutations en mode statique (défaut)", async () => {
+    const tag = "test-ancestor-attr-static-no-react";
+    class C extends HTMLElement {
+      @ancestorAttribute("dataProvider")
+      dataProvider: string | null = null;
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const wrap = document.createElement("div");
+    wrap.setAttribute("dataProvider", "scope-a");
+    const el = document.createElement(tag) as InstanceType<typeof C>;
+    wrap.appendChild(el);
+    document.body.appendChild(wrap);
+
+    wrap.setAttribute("dataProvider", "scope-b");
+    await flushFrames();
+
+    expect(el.dataProvider).toBe("scope-a");
+  });
+
+  it("met à jour la propriété quand un ancêtre change (mode dynamique)", async () => {
+    const tag = "test-ancestor-attr-dynamic-mutation";
+    class C extends HTMLElement {
+      @ancestorAttribute("dataProvider", { dynamic: true })
+      dataProvider: string | null = null;
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const wrap = document.createElement("div");
+    wrap.setAttribute("dataProvider", "scope-a");
+    const el = document.createElement(tag) as InstanceType<typeof C>;
+    wrap.appendChild(el);
+    document.body.appendChild(wrap);
+
+    expect(el.dataProvider).toBe("scope-a");
+
+    wrap.setAttribute("dataProvider", "scope-b");
+    await flushFrames();
+
+    expect(el.dataProvider).toBe("scope-b");
+  });
+
+  it("assigne null si l'attribut ancêtre est retiré (mode dynamique)", async () => {
+    const tag = "test-ancestor-attr-dynamic-null";
+    class C extends HTMLElement {
+      @ancestorAttribute("dataProvider", { dynamic: true })
+      dataProvider: string | null = "initial";
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const wrap = document.createElement("div");
+    wrap.setAttribute("dataProvider", "scope-a");
+    const el = document.createElement(tag) as InstanceType<typeof C>;
+    wrap.appendChild(el);
+    document.body.appendChild(wrap);
+
+    wrap.removeAttribute("dataProvider");
+    await flushFrames();
+
+    expect(el.dataProvider).toBeNull();
+  });
+
+  it("retombe sur l'ancêtre suivant quand le plus proche perd l'attribut", async () => {
+    const tag = "test-ancestor-attr-dynamic-fallback";
+    class C extends HTMLElement {
+      @ancestorAttribute("dataProvider", { dynamic: true })
+      dataProvider: string | null = null;
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const outer = document.createElement("div");
+    outer.setAttribute("dataProvider", "from-outer");
+    const parent = document.createElement("div");
+    parent.setAttribute("dataProvider", "from-parent");
+    const el = document.createElement(tag) as InstanceType<typeof C>;
+    parent.appendChild(el);
+    outer.appendChild(parent);
+    document.body.appendChild(outer);
+
+    expect(el.dataProvider).toBe("from-parent");
+
+    parent.removeAttribute("dataProvider");
+    await flushFrames();
+
+    expect(el.dataProvider).toBe("from-outer");
+  });
+
+  it("met à jour dans un shadow root (Lit)", async () => {
+    const hostTag = "test-ancestor-shadow-host";
+    const childTag = "test-ancestor-shadow-child";
+
+    class Host extends HTMLElement {
+      connectedCallback() {
+        const shadow = this.attachShadow({ mode: "open" });
+        const wrap = document.createElement("div");
+        wrap.setAttribute("dataProvider", "scope-a");
+        const child = document.createElement(childTag);
+        wrap.appendChild(child);
+        shadow.append(wrap);
+      }
+    }
+
+    class Child extends HTMLElement {
+      @ancestorAttribute("dataProvider", { dynamic: true })
+      dataProvider: string | null = null;
+    }
+
+    if (!customElements.get(hostTag)) {
+      customElements.define(hostTag, Host);
+    }
+    if (!customElements.get(childTag)) {
+      customElements.define(childTag, Child);
+    }
+
+    const host = document.createElement(hostTag);
+    document.body.appendChild(host);
+    await flushFrames();
+
+    const wrap = host.shadowRoot!.querySelector("div")!;
+    const child = host.shadowRoot!.querySelector(childTag) as InstanceType<
+      typeof Child
+    >;
+
+    expect(child.dataProvider).toBe("scope-a");
+
+    wrap.setAttribute("dataProvider", "scope-b");
+    await flushFrames();
+
+    expect(child.dataProvider).toBe("scope-b");
+  });
+
+  it("ne met plus à jour après disconnect (mode dynamique)", async () => {
+    const tag = "test-ancestor-attr-dynamic-disconnect";
+    class C extends HTMLElement {
+      @ancestorAttribute("dataProvider", { dynamic: true })
+      dataProvider: string | null = null;
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const wrap = document.createElement("div");
+    wrap.setAttribute("dataProvider", "scope-a");
+    const el = document.createElement(tag) as InstanceType<typeof C>;
+    wrap.appendChild(el);
+    document.body.appendChild(wrap);
+
+    el.remove();
+    wrap.setAttribute("dataProvider", "scope-b");
+    await flushFrames();
+
+    expect(el.dataProvider).toBe("scope-a");
+  });
+});

package/src/core/decorators/subscriber/ancestorAttribute.ts

@@ -1,18 +1,51 @@
-import HTML from "../../utils/HTML";
+import AncestorAttributeObserver, {
+  syncAncestorAttributeValue,
+} from "../../utils/AncestorAttributeObserver";
 import { ConnectedComponent, setSubscribable } from "./common";
 
-export function ancestorAttribute(attributeName: string) {
+export type AncestorAttributeOptions = {
+  /**
+   * Si true, le composant reste synchronisé avec les attributs ancêtres via
+   * `AncestorAttributeObserver` (mutations + reparenting). Requis pour que
+   * `@bind` / `@subscribe` avec `${dataProvider}` se re-lient quand le scope change.
+   * Défaut : false (lecture unique au connect, rétrocompat).
+   */
+  dynamic?: boolean;
+};
+
+export function ancestorAttribute(
+  attributeName: string,
+  options?: AncestorAttributeOptions,
+) {
+  const dynamic = options?.dynamic ?? false;
+  const assignNull = dynamic;
+
   return function (target: unknown, propertyKey: string) {
     if (!target) return;
     setSubscribable(target);
+
     (target as ConnectedComponent).__onBeforeConnected__((component) => {
-      const value = HTML.getAncestorAttributeValue(
-        component as any,
+      syncAncestorAttributeValue(component, attributeName, propertyKey, {
+        assignNull,
+      });
+    });
+
+    if (!dynamic) return;
+
+    let unsubscribe: (() => void) | null = null;
+
+    (target as ConnectedComponent).__onConnected__((component) => {
+      unsubscribe = AncestorAttributeObserver.subscribe(
+        component as unknown as HTMLElement,
         attributeName,
+        propertyKey,
+        { assignNull: true },
       );
-      if (value !== null) {
-        component[propertyKey] = value;
-      }
+    });
+
+    (target as ConnectedComponent).__onDisconnected__(() => {
+      unsubscribe?.();
+      unsubscribe = null;
     });
   };
 }

package/src/core/decorators/subscriber/autoSubscribe.ts

@@ -1,4 +1,8 @@
-import { PublisherProxy, PublisherManager } from "../../utils/PublisherProxy";
+import {
+  PublisherProxy,
+  collectModifiedPublisher,
+  getModifiedPublishers,
+} from "../../utils/PublisherProxy";
 
 export function autoSubscribe() {
   return function (
@@ -33,10 +37,10 @@ export function autoSubscribe() {
       publishers.forEach((publisher: PublisherProxy) => {
         publisher.offAssign(onAssign);
       });
-      PublisherManager.collectModifiedPublisher();
+      collectModifiedPublisher();
       const result = originalMethod.apply(this, args);
       publishers =
-        PublisherManager.getModifiedPublishers() || new Set<PublisherProxy>();
+        getModifiedPublishers() || new Set<PublisherProxy>();
 
       publishers.forEach((publisher: PublisherProxy) => {
         publisher.onAssign(onAssign, false);