@webiny/app-admin 0.0.0-unstable.6f45466a1d → 0.0.0-unstable.7be00a75a9

package/features/tenancy/TenantContext.js

@@ -1,61 +1,57 @@
 import { makeAutoObservable, runInAction } from "mobx";
-import { TenantContext as Abstraction } from "./abstractions.js";
+import { TenantContext } from "./abstractions.js";
 import { LocalStorage } from "@webiny/app/features/localStorage";
 const LOCAL_STORAGE_KEY = "tenantId";
 const DEFAULT_TENANT = "root";
 class TenantContextImpl {
-  currentTenant = null;
-  changeCallbacks = new Set();
-  constructor(localStorage) {
-    this.localStorage = localStorage;
-    makeAutoObservable(this, {}, {
-      autoBind: true
-    });
-    this.initialize();
-  }
-  initialize() {
-    const storedTenant = this.localStorage.get(LOCAL_STORAGE_KEY) || DEFAULT_TENANT;
-    this.currentTenant = storedTenant;
-    this.localStorage.set(LOCAL_STORAGE_KEY, storedTenant);
-  }
-  getCurrentTenant() {
-    return this.currentTenant;
-  }
-  setTenant(tenantId) {
-    const previousTenant = this.currentTenant;
-    runInAction(() => {
-      this.currentTenant = tenantId;
-    });
-    if (tenantId) {
-      this.localStorage.set(LOCAL_STORAGE_KEY, tenantId);
-    } else {
-      this.localStorage.remove(LOCAL_STORAGE_KEY);
+    constructor(localStorage){
+        this.localStorage = localStorage;
+        this.currentTenant = null;
+        this.changeCallbacks = new Set();
+        makeAutoObservable(this, {}, {
+            autoBind: true
+        });
+        this.initialize();
     }
-
-    // Only notify if tenant actually changed
-    if (previousTenant !== tenantId) {
-      this.notifyListeners(tenantId);
+    initialize() {
+        const storedTenant = this.localStorage.get(LOCAL_STORAGE_KEY) || DEFAULT_TENANT;
+        this.currentTenant = storedTenant;
+        this.localStorage.set(LOCAL_STORAGE_KEY, storedTenant);
+    }
+    getCurrentTenant() {
+        return this.currentTenant;
+    }
+    setTenant(tenantId) {
+        const previousTenant = this.currentTenant;
+        runInAction(()=>{
+            this.currentTenant = tenantId;
+        });
+        if (tenantId) this.localStorage.set(LOCAL_STORAGE_KEY, tenantId);
+        else this.localStorage.remove(LOCAL_STORAGE_KEY);
+        if (previousTenant !== tenantId) this.notifyListeners(tenantId);
+    }
+    onTenantChange(callback) {
+        this.changeCallbacks.add(callback);
+        return ()=>{
+            this.changeCallbacks.delete(callback);
+        };
+    }
+    notifyListeners(tenantId) {
+        this.changeCallbacks.forEach((callback)=>{
+            try {
+                callback(tenantId);
+            } catch (error) {
+                console.error("Tenant change callback error:", error);
+            }
+        });
     }
-  }
-  onTenantChange(callback) {
-    this.changeCallbacks.add(callback);
-    return () => {
-      this.changeCallbacks.delete(callback);
-    };
-  }
-  notifyListeners(tenantId) {
-    this.changeCallbacks.forEach(callback => {
-      try {
-        callback(tenantId);
-      } catch (error) {
-        console.error("Tenant change callback error:", error);
-      }
-    });
-  }
 }
-export const TenantContext = Abstraction.createImplementation({
-  implementation: TenantContextImpl,
-  dependencies: [LocalStorage]
+const TenantContext_TenantContext = TenantContext.createImplementation({
+    implementation: TenantContextImpl,
+    dependencies: [
+        LocalStorage
+    ]
 });
+export { TenantContext_TenantContext as TenantContext };
 
 //# sourceMappingURL=TenantContext.js.map

package/features/tenancy/TenantContext.js.map

@@ -1 +1 @@
-{"version":3,"names":["makeAutoObservable","runInAction","TenantContext","Abstraction","LocalStorage","LOCAL_STORAGE_KEY","DEFAULT_TENANT","TenantContextImpl","currentTenant","changeCallbacks","Set","constructor","localStorage","autoBind","initialize","storedTenant","get","set","getCurrentTenant","setTenant","tenantId","previousTenant","remove","notifyListeners","onTenantChange","callback","add","delete","forEach","error","console","createImplementation","implementation","dependencies"],"sources":["TenantContext.ts"],"sourcesContent":["import { makeAutoObservable, runInAction } from \"mobx\";\nimport { TenantContext as Abstraction } from \"./abstractions.js\";\nimport { LocalStorage } from \"@webiny/app/features/localStorage\";\n\nconst LOCAL_STORAGE_KEY = \"tenantId\";\nconst DEFAULT_TENANT = \"root\";\n\nclass TenantContextImpl implements Abstraction.Interface {\n    private currentTenant: string | null = null;\n    private changeCallbacks = new Set<(tenantId: string | null) => void>();\n\n    constructor(private localStorage: LocalStorage.Interface) {\n        makeAutoObservable(this, {}, { autoBind: true });\n        this.initialize();\n    }\n\n    private initialize(): void {\n        const storedTenant = this.localStorage.get<string>(LOCAL_STORAGE_KEY) || DEFAULT_TENANT;\n        this.currentTenant = storedTenant;\n        this.localStorage.set(LOCAL_STORAGE_KEY, storedTenant);\n    }\n\n    getCurrentTenant(): string | null {\n        return this.currentTenant;\n    }\n\n    setTenant(tenantId: string | null): void {\n        const previousTenant = this.currentTenant;\n\n        runInAction(() => {\n            this.currentTenant = tenantId;\n        });\n\n        if (tenantId) {\n            this.localStorage.set(LOCAL_STORAGE_KEY, tenantId);\n        } else {\n            this.localStorage.remove(LOCAL_STORAGE_KEY);\n        }\n\n        // Only notify if tenant actually changed\n        if (previousTenant !== tenantId) {\n            this.notifyListeners(tenantId);\n        }\n    }\n\n    onTenantChange(callback: (tenantId: string | null) => void): () => void {\n        this.changeCallbacks.add(callback);\n        return () => {\n            this.changeCallbacks.delete(callback);\n        };\n    }\n\n    private notifyListeners(tenantId: string | null): void {\n        this.changeCallbacks.forEach(callback => {\n            try {\n                callback(tenantId);\n            } catch (error) {\n                console.error(\"Tenant change callback error:\", error);\n            }\n        });\n    }\n}\n\nexport const TenantContext = Abstraction.createImplementation({\n    implementation: TenantContextImpl,\n    dependencies: [LocalStorage]\n});\n"],"mappings":"AAAA,SAASA,kBAAkB,EAAEC,WAAW,QAAQ,MAAM;AACtD,SAASC,aAAa,IAAIC,WAAW;AACrC,SAASC,YAAY,QAAQ,mCAAmC;AAEhE,MAAMC,iBAAiB,GAAG,UAAU;AACpC,MAAMC,cAAc,GAAG,MAAM;AAE7B,MAAMC,iBAAiB,CAAkC;EAC7CC,aAAa,GAAkB,IAAI;EACnCC,eAAe,GAAG,IAAIC,GAAG,CAAoC,CAAC;EAEtEC,WAAWA,CAASC,YAAoC,EAAE;IAAA,KAAtCA,YAAoC,GAApCA,YAAoC;IACpDZ,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE;MAAEa,QAAQ,EAAE;IAAK,CAAC,CAAC;IAChD,IAAI,CAACC,UAAU,CAAC,CAAC;EACrB;EAEQA,UAAUA,CAAA,EAAS;IACvB,MAAMC,YAAY,GAAG,IAAI,CAACH,YAAY,CAACI,GAAG,CAASX,iBAAiB,CAAC,IAAIC,cAAc;IACvF,IAAI,CAACE,aAAa,GAAGO,YAAY;IACjC,IAAI,CAACH,YAAY,CAACK,GAAG,CAACZ,iBAAiB,EAAEU,YAAY,CAAC;EAC1D;EAEAG,gBAAgBA,CAAA,EAAkB;IAC9B,OAAO,IAAI,CAACV,aAAa;EAC7B;EAEAW,SAASA,CAACC,QAAuB,EAAQ;IACrC,MAAMC,cAAc,GAAG,IAAI,CAACb,aAAa;IAEzCP,WAAW,CAAC,MAAM;MACd,IAAI,CAACO,aAAa,GAAGY,QAAQ;IACjC,CAAC,CAAC;IAEF,IAAIA,QAAQ,EAAE;MACV,IAAI,CAACR,YAAY,CAACK,GAAG,CAACZ,iBAAiB,EAAEe,QAAQ,CAAC;IACtD,CAAC,MAAM;MACH,IAAI,CAACR,YAAY,CAACU,MAAM,CAACjB,iBAAiB,CAAC;IAC/C;;IAEA;IACA,IAAIgB,cAAc,KAAKD,QAAQ,EAAE;MAC7B,IAAI,CAACG,eAAe,CAACH,QAAQ,CAAC;IAClC;EACJ;EAEAI,cAAcA,CAACC,QAA2C,EAAc;IACpE,IAAI,CAAChB,eAAe,CAACiB,GAAG,CAACD,QAAQ,CAAC;IAClC,OAAO,MAAM;MACT,IAAI,CAAChB,eAAe,CAACkB,MAAM,CAACF,QAAQ,CAAC;IACzC,CAAC;EACL;EAEQF,eAAeA,CAACH,QAAuB,EAAQ;IACnD,IAAI,CAACX,eAAe,CAACmB,OAAO,CAACH,QAAQ,IAAI;MACrC,IAAI;QACAA,QAAQ,CAACL,QAAQ,CAAC;MACtB,CAAC,CAAC,OAAOS,KAAK,EAAE;QACZC,OAAO,CAACD,KAAK,CAAC,+BAA+B,EAAEA,KAAK,CAAC;MACzD;IACJ,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAM3B,aAAa,GAAGC,WAAW,CAAC4B,oBAAoB,CAAC;EAC1DC,cAAc,EAAEzB,iBAAiB;EACjC0B,YAAY,EAAE,CAAC7B,YAAY;AAC/B,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/tenancy/TenantContext.js","sources":["../../../src/features/tenancy/TenantContext.ts"],"sourcesContent":["import { makeAutoObservable, runInAction } from \"mobx\";\nimport { TenantContext as Abstraction } from \"./abstractions.js\";\nimport { LocalStorage } from \"@webiny/app/features/localStorage\";\n\nconst LOCAL_STORAGE_KEY = \"tenantId\";\nconst DEFAULT_TENANT = \"root\";\n\nclass TenantContextImpl implements Abstraction.Interface {\n    private currentTenant: string | null = null;\n    private changeCallbacks = new Set<(tenantId: string | null) => void>();\n\n    constructor(private localStorage: LocalStorage.Interface) {\n        makeAutoObservable(this, {}, { autoBind: true });\n        this.initialize();\n    }\n\n    private initialize(): void {\n        const storedTenant = this.localStorage.get<string>(LOCAL_STORAGE_KEY) || DEFAULT_TENANT;\n        this.currentTenant = storedTenant;\n        this.localStorage.set(LOCAL_STORAGE_KEY, storedTenant);\n    }\n\n    getCurrentTenant(): string | null {\n        return this.currentTenant;\n    }\n\n    setTenant(tenantId: string | null): void {\n        const previousTenant = this.currentTenant;\n\n        runInAction(() => {\n            this.currentTenant = tenantId;\n        });\n\n        if (tenantId) {\n            this.localStorage.set(LOCAL_STORAGE_KEY, tenantId);\n        } else {\n            this.localStorage.remove(LOCAL_STORAGE_KEY);\n        }\n\n        // Only notify if tenant actually changed\n        if (previousTenant !== tenantId) {\n            this.notifyListeners(tenantId);\n        }\n    }\n\n    onTenantChange(callback: (tenantId: string | null) => void): () => void {\n        this.changeCallbacks.add(callback);\n        return () => {\n            this.changeCallbacks.delete(callback);\n        };\n    }\n\n    private notifyListeners(tenantId: string | null): void {\n        this.changeCallbacks.forEach(callback => {\n            try {\n                callback(tenantId);\n            } catch (error) {\n                console.error(\"Tenant change callback error:\", error);\n            }\n        });\n    }\n}\n\nexport const TenantContext = Abstraction.createImplementation({\n    implementation: TenantContextImpl,\n    dependencies: [LocalStorage]\n});\n"],"names":["LOCAL_STORAGE_KEY","DEFAULT_TENANT","TenantContextImpl","localStorage","Set","makeAutoObservable","storedTenant","tenantId","previousTenant","runInAction","callback","error","console","TenantContext","Abstraction","LocalStorage"],"mappings":";;;AAIA,MAAMA,oBAAoB;AAC1B,MAAMC,iBAAiB;AAEvB,MAAMC;IAIF,YAAoBC,YAAoC,CAAE;aAAtCA,YAAY,GAAZA;aAHZ,aAAa,GAAkB;aAC/B,eAAe,GAAG,IAAIC;QAG1BC,mBAAmB,IAAI,EAAE,CAAC,GAAG;YAAE,UAAU;QAAK;QAC9C,IAAI,CAAC,UAAU;IACnB;IAEQ,aAAmB;QACvB,MAAMC,eAAe,IAAI,CAAC,YAAY,CAAC,GAAG,CAASN,sBAAsBC;QACzE,IAAI,CAAC,aAAa,GAAGK;QACrB,IAAI,CAAC,YAAY,CAAC,GAAG,CAACN,mBAAmBM;IAC7C;IAEA,mBAAkC;QAC9B,OAAO,IAAI,CAAC,aAAa;IAC7B;IAEA,UAAUC,QAAuB,EAAQ;QACrC,MAAMC,iBAAiB,IAAI,CAAC,aAAa;QAEzCC,YAAY;YACR,IAAI,CAAC,aAAa,GAAGF;QACzB;QAEA,IAAIA,UACA,IAAI,CAAC,YAAY,CAAC,GAAG,CAACP,mBAAmBO;aAEzC,IAAI,CAAC,YAAY,CAAC,MAAM,CAACP;QAI7B,IAAIQ,mBAAmBD,UACnB,IAAI,CAAC,eAAe,CAACA;IAE7B;IAEA,eAAeG,QAA2C,EAAc;QACpE,IAAI,CAAC,eAAe,CAAC,GAAG,CAACA;QACzB,OAAO;YACH,IAAI,CAAC,eAAe,CAAC,MAAM,CAACA;QAChC;IACJ;IAEQ,gBAAgBH,QAAuB,EAAQ;QACnD,IAAI,CAAC,eAAe,CAAC,OAAO,CAACG,CAAAA;YACzB,IAAI;gBACAA,SAASH;YACb,EAAE,OAAOI,OAAO;gBACZC,QAAQ,KAAK,CAAC,iCAAiCD;YACnD;QACJ;IACJ;AACJ;AAEO,MAAME,8BAAgBC,cAAAA,oBAAgC,CAAC;IAC1D,gBAAgBZ;IAChB,cAAc;QAACa;KAAa;AAChC"}

package/features/tenancy/abstractions.js

@@ -1,4 +1,5 @@
 import { Abstraction } from "@webiny/di";
-export const TenantContext = new Abstraction("TenantContext");
+const TenantContext = new Abstraction("TenantContext");
+export { TenantContext };
 
 //# sourceMappingURL=abstractions.js.map

package/features/tenancy/abstractions.js.map

@@ -1 +1 @@
-{"version":3,"names":["Abstraction","TenantContext"],"sources":["abstractions.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\n\nexport interface Tenant {\n    id: string;\n    name: string;\n}\n\nexport interface ITenantContext {\n    getCurrentTenant(): string | null;\n    setTenant(tenantId: string | null): void;\n    onTenantChange(callback: (tenantId: string | null) => void): () => void;\n}\n\nexport const TenantContext = new Abstraction<ITenantContext>(\"TenantContext\");\n\nexport namespace TenantContext {\n    export type Interface = ITenantContext;\n}\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,YAAY;AAaxC,OAAO,MAAMC,aAAa,GAAG,IAAID,WAAW,CAAiB,eAAe,CAAC","ignoreList":[]}
+{"version":3,"file":"features/tenancy/abstractions.js","sources":["../../../src/features/tenancy/abstractions.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\n\nexport interface Tenant {\n    id: string;\n    name: string;\n}\n\nexport interface ITenantContext {\n    getCurrentTenant(): string | null;\n    setTenant(tenantId: string | null): void;\n    onTenantChange(callback: (tenantId: string | null) => void): () => void;\n}\n\nexport const TenantContext = new Abstraction<ITenantContext>(\"TenantContext\");\n\nexport namespace TenantContext {\n    export type Interface = ITenantContext;\n}\n"],"names":["TenantContext","Abstraction"],"mappings":";AAaO,MAAMA,gBAAgB,IAAIC,YAA4B"}

package/features/tenancy/feature.js

@@ -1,41 +1,31 @@
 import { createFeature } from "@webiny/feature/admin";
 import { LocalStorageFeature } from "@webiny/app/features/localStorage/feature.js";
-import { TenantContext as TenantContextAbstraction } from "./abstractions.js";
-import { TenantContext } from "./TenantContext.js";
+import { TenantContext } from "./abstractions.js";
+import { TenantContext as external_TenantContext_js_TenantContext } from "./TenantContext.js";
 import { GraphQLClientDecorator } from "./GraphQLClientDecorator.js";
-export const TenancyFeature = createFeature({
-  name: "Tenancy",
-  register(container) {
-    container.register(TenantContext).inSingletonScope();
-    container.registerDecorator(GraphQLClientDecorator);
-  },
-  resolve(container) {
-    const service = container.resolve(TenantContextAbstraction);
-    return {
-      service,
-      // Helper to create tenant-scoped container
-      createTenantContainer: () => {
-        const currentTenant = service.getCurrentTenant();
-        if (!currentTenant) {
-          return container;
-        }
-
-        // Get current localStorage config
-        const {
-          localStorageConfig
-        } = LocalStorageFeature.resolve(container);
-
-        // Create tenant-scoped child container
-        const tenantContainer = container.createChildContainer();
-
-        // Re-register localStorage with tenant-specific prefix
-        LocalStorageFeature.register(tenantContainer, {
-          prefix: `${localStorageConfig.prefix}/${currentTenant}`
-        });
-        return tenantContainer;
-      }
-    };
-  }
+const TenancyFeature = createFeature({
+    name: "Tenancy",
+    register (container) {
+        container.register(external_TenantContext_js_TenantContext).inSingletonScope();
+        container.registerDecorator(GraphQLClientDecorator);
+    },
+    resolve (container) {
+        const service = container.resolve(TenantContext);
+        return {
+            service,
+            createTenantContainer: ()=>{
+                const currentTenant = service.getCurrentTenant();
+                if (!currentTenant) return container;
+                const { localStorageConfig } = LocalStorageFeature.resolve(container);
+                const tenantContainer = container.createChildContainer();
+                LocalStorageFeature.register(tenantContainer, {
+                    prefix: `${localStorageConfig.prefix}/${currentTenant}`
+                });
+                return tenantContainer;
+            }
+        };
+    }
 });
+export { TenancyFeature };
 
 //# sourceMappingURL=feature.js.map

package/features/tenancy/feature.js.map

@@ -1 +1 @@
-{"version":3,"names":["createFeature","LocalStorageFeature","TenantContext","TenantContextAbstraction","GraphQLClientDecorator","TenancyFeature","name","register","container","inSingletonScope","registerDecorator","resolve","service","createTenantContainer","currentTenant","getCurrentTenant","localStorageConfig","tenantContainer","createChildContainer","prefix"],"sources":["feature.ts"],"sourcesContent":["import { Container } from \"@webiny/di\";\nimport { createFeature } from \"@webiny/feature/admin\";\nimport { LocalStorageFeature } from \"@webiny/app/features/localStorage/feature.js\";\nimport { TenantContext as TenantContextAbstraction } from \"./abstractions.js\";\nimport { TenantContext } from \"./TenantContext.js\";\nimport { GraphQLClientDecorator } from \"./GraphQLClientDecorator.js\";\n\nexport const TenancyFeature = createFeature({\n    name: \"Tenancy\",\n    register(container: Container) {\n        container.register(TenantContext).inSingletonScope();\n        container.registerDecorator(GraphQLClientDecorator);\n    },\n    resolve(container: Container) {\n        const service = container.resolve(TenantContextAbstraction);\n\n        return {\n            service,\n\n            // Helper to create tenant-scoped container\n            createTenantContainer: () => {\n                const currentTenant = service.getCurrentTenant();\n\n                if (!currentTenant) {\n                    return container;\n                }\n\n                // Get current localStorage config\n                const { localStorageConfig } = LocalStorageFeature.resolve(container);\n\n                // Create tenant-scoped child container\n                const tenantContainer = container.createChildContainer();\n\n                // Re-register localStorage with tenant-specific prefix\n                LocalStorageFeature.register(tenantContainer, {\n                    prefix: `${localStorageConfig.prefix}/${currentTenant}`\n                });\n\n                return tenantContainer;\n            }\n        };\n    }\n});\n"],"mappings":"AACA,SAASA,aAAa,QAAQ,uBAAuB;AACrD,SAASC,mBAAmB,QAAQ,8CAA8C;AAClF,SAASC,aAAa,IAAIC,wBAAwB;AAClD,SAASD,aAAa;AACtB,SAASE,sBAAsB;AAE/B,OAAO,MAAMC,cAAc,GAAGL,aAAa,CAAC;EACxCM,IAAI,EAAE,SAAS;EACfC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACD,QAAQ,CAACL,aAAa,CAAC,CAACO,gBAAgB,CAAC,CAAC;IACpDD,SAAS,CAACE,iBAAiB,CAACN,sBAAsB,CAAC;EACvD,CAAC;EACDO,OAAOA,CAACH,SAAoB,EAAE;IAC1B,MAAMI,OAAO,GAAGJ,SAAS,CAACG,OAAO,CAACR,wBAAwB,CAAC;IAE3D,OAAO;MACHS,OAAO;MAEP;MACAC,qBAAqB,EAAEA,CAAA,KAAM;QACzB,MAAMC,aAAa,GAAGF,OAAO,CAACG,gBAAgB,CAAC,CAAC;QAEhD,IAAI,CAACD,aAAa,EAAE;UAChB,OAAON,SAAS;QACpB;;QAEA;QACA,MAAM;UAAEQ;QAAmB,CAAC,GAAGf,mBAAmB,CAACU,OAAO,CAACH,SAAS,CAAC;;QAErE;QACA,MAAMS,eAAe,GAAGT,SAAS,CAACU,oBAAoB,CAAC,CAAC;;QAExD;QACAjB,mBAAmB,CAACM,QAAQ,CAACU,eAAe,EAAE;UAC1CE,MAAM,EAAE,GAAGH,kBAAkB,CAACG,MAAM,IAAIL,aAAa;QACzD,CAAC,CAAC;QAEF,OAAOG,eAAe;MAC1B;IACJ,CAAC;EACL;AACJ,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/tenancy/feature.js","sources":["../../../src/features/tenancy/feature.ts"],"sourcesContent":["import { Container } from \"@webiny/di\";\nimport { createFeature } from \"@webiny/feature/admin\";\nimport { LocalStorageFeature } from \"@webiny/app/features/localStorage/feature.js\";\nimport { TenantContext as TenantContextAbstraction } from \"./abstractions.js\";\nimport { TenantContext } from \"./TenantContext.js\";\nimport { GraphQLClientDecorator } from \"./GraphQLClientDecorator.js\";\n\nexport const TenancyFeature = createFeature({\n    name: \"Tenancy\",\n    register(container: Container) {\n        container.register(TenantContext).inSingletonScope();\n        container.registerDecorator(GraphQLClientDecorator);\n    },\n    resolve(container: Container) {\n        const service = container.resolve(TenantContextAbstraction);\n\n        return {\n            service,\n\n            // Helper to create tenant-scoped container\n            createTenantContainer: () => {\n                const currentTenant = service.getCurrentTenant();\n\n                if (!currentTenant) {\n                    return container;\n                }\n\n                // Get current localStorage config\n                const { localStorageConfig } = LocalStorageFeature.resolve(container);\n\n                // Create tenant-scoped child container\n                const tenantContainer = container.createChildContainer();\n\n                // Re-register localStorage with tenant-specific prefix\n                LocalStorageFeature.register(tenantContainer, {\n                    prefix: `${localStorageConfig.prefix}/${currentTenant}`\n                });\n\n                return tenantContainer;\n            }\n        };\n    }\n});\n"],"names":["TenancyFeature","createFeature","container","TenantContext","GraphQLClientDecorator","service","TenantContextAbstraction","currentTenant","localStorageConfig","LocalStorageFeature","tenantContainer"],"mappings":";;;;;AAOO,MAAMA,iBAAiBC,cAAc;IACxC,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC,yCAAe,gBAAgB;QAClDD,UAAU,iBAAiB,CAACE;IAChC;IACA,SAAQF,SAAoB;QACxB,MAAMG,UAAUH,UAAU,OAAO,CAACI;QAElC,OAAO;YACHD;YAGA,uBAAuB;gBACnB,MAAME,gBAAgBF,QAAQ,gBAAgB;gBAE9C,IAAI,CAACE,eACD,OAAOL;gBAIX,MAAM,EAAEM,kBAAkB,EAAE,GAAGC,oBAAoB,OAAO,CAACP;gBAG3D,MAAMQ,kBAAkBR,UAAU,oBAAoB;gBAGtDO,oBAAoB,QAAQ,CAACC,iBAAiB;oBAC1C,QAAQ,GAAGF,mBAAmB,MAAM,CAAC,CAAC,EAAED,eAAe;gBAC3D;gBAEA,OAAOG;YACX;QACJ;IACJ;AACJ"}

package/features/tenancy/types.js

@@ -1,3 +0,0 @@
-export {};
-
-//# sourceMappingURL=types.js.map

package/features/tools/LexicalContext/LexicalContext.d.ts

@@ -0,0 +1,14 @@
+import type { Klass, LexicalNode, LexicalNodeReplacement, EditorThemeClasses } from "lexical";
+import { LexicalContext as Abstraction } from "./abstractions.js";
+declare class LexicalContextImpl implements Abstraction.Interface {
+    private nodes;
+    private theme;
+    getNodes(): ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>;
+    setNodes(nodes: ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>): void;
+    getTheme(): EditorThemeClasses | undefined;
+    setTheme(theme: EditorThemeClasses): void;
+}
+export declare const LexicalContext: typeof LexicalContextImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ILexicalContext>;
+};
+export {};

package/features/tools/LexicalContext/LexicalContext.js

@@ -0,0 +1,25 @@
+import { LexicalContext } from "./abstractions.js";
+class LexicalContextImpl {
+    getNodes() {
+        return this.nodes;
+    }
+    setNodes(nodes) {
+        this.nodes = nodes;
+    }
+    getTheme() {
+        return this.theme;
+    }
+    setTheme(theme) {
+        this.theme = theme;
+    }
+    constructor(){
+        this.nodes = [];
+    }
+}
+const LexicalContext_LexicalContext = LexicalContext.createImplementation({
+    implementation: LexicalContextImpl,
+    dependencies: []
+});
+export { LexicalContext_LexicalContext as LexicalContext };
+
+//# sourceMappingURL=LexicalContext.js.map

package/features/tools/LexicalContext/LexicalContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tools/LexicalContext/LexicalContext.js","sources":["../../../../src/features/tools/LexicalContext/LexicalContext.ts"],"sourcesContent":["import type { Klass, LexicalNode, LexicalNodeReplacement, EditorThemeClasses } from \"lexical\";\nimport { LexicalContext as Abstraction } from \"./abstractions.js\";\n\nclass LexicalContextImpl implements Abstraction.Interface {\n    private nodes: ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement> = [];\n    private theme: EditorThemeClasses | undefined;\n\n    getNodes(): ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement> {\n        return this.nodes;\n    }\n\n    setNodes(nodes: ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>): void {\n        this.nodes = nodes;\n    }\n\n    getTheme(): EditorThemeClasses | undefined {\n        return this.theme;\n    }\n\n    setTheme(theme: EditorThemeClasses): void {\n        this.theme = theme;\n    }\n}\n\nexport const LexicalContext = Abstraction.createImplementation({\n    implementation: LexicalContextImpl,\n    dependencies: []\n});\n"],"names":["LexicalContextImpl","nodes","theme","LexicalContext","Abstraction"],"mappings":";AAGA,MAAMA;IAIF,WAAuE;QACnE,OAAO,IAAI,CAAC,KAAK;IACrB;IAEA,SAASC,KAAiE,EAAQ;QAC9E,IAAI,CAAC,KAAK,GAAGA;IACjB;IAEA,WAA2C;QACvC,OAAO,IAAI,CAAC,KAAK;IACrB;IAEA,SAASC,KAAyB,EAAQ;QACtC,IAAI,CAAC,KAAK,GAAGA;IACjB;;aAjBQ,KAAK,GAA+D,EAAE;;AAkBlF;AAEO,MAAMC,gCAAiBC,eAAAA,oBAAgC,CAAC;IAC3D,gBAAgBJ;IAChB,cAAc,EAAE;AACpB"}

package/features/tools/LexicalContext/abstractions.d.ts

@@ -0,0 +1,11 @@
+import type { Klass, LexicalNode, LexicalNodeReplacement, EditorThemeClasses } from "lexical";
+export interface ILexicalContext {
+    getNodes(): ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>;
+    setNodes(nodes: ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>): void;
+    getTheme(): EditorThemeClasses | undefined;
+    setTheme(theme: EditorThemeClasses): void;
+}
+export declare const LexicalContext: import("@webiny/di").Abstraction<ILexicalContext>;
+export declare namespace LexicalContext {
+    type Interface = ILexicalContext;
+}

package/features/tools/LexicalContext/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const LexicalContext = createAbstraction("LexicalContext");
+export { LexicalContext };
+
+//# sourceMappingURL=abstractions.js.map

package/features/tools/LexicalContext/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tools/LexicalContext/abstractions.js","sources":["../../../../src/features/tools/LexicalContext/abstractions.ts"],"sourcesContent":["import type { Klass, LexicalNode, LexicalNodeReplacement, EditorThemeClasses } from \"lexical\";\nimport { createAbstraction } from \"@webiny/feature/admin\";\n\nexport interface ILexicalContext {\n    getNodes(): ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>;\n    setNodes(nodes: ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>): void;\n    getTheme(): EditorThemeClasses | undefined;\n    setTheme(theme: EditorThemeClasses): void;\n}\n\nexport const LexicalContext = createAbstraction<ILexicalContext>(\"LexicalContext\");\n\nexport namespace LexicalContext {\n    export type Interface = ILexicalContext;\n}\n"],"names":["LexicalContext","createAbstraction"],"mappings":";AAUO,MAAMA,iBAAiBC,kBAAmC"}

package/features/tools/LexicalContext/index.d.ts

@@ -0,0 +1,2 @@
+export { LexicalContext } from "./abstractions.js";
+export type { ILexicalContext } from "./abstractions.js";

package/features/tools/LexicalContext/index.js

@@ -0,0 +1 @@
+export { LexicalContext } from "./abstractions.js";

package/features/tools/ToolPipelineRunner.d.ts

@@ -0,0 +1,10 @@
+import { type IToolPipelineRunner, type IToolRegistry } from "./abstractions.js";
+declare class PipelineRunnerImpl implements IToolPipelineRunner {
+    private toolRegistry;
+    constructor(toolRegistry: IToolRegistry);
+    resolve(data: unknown): Promise<unknown>;
+}
+export declare const ToolPipelineRunner: typeof PipelineRunnerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IToolPipelineRunner>;
+};
+export {};

package/features/tools/ToolPipelineRunner.js

@@ -0,0 +1,35 @@
+import { ToolPipelineRunner, ToolRegistry } from "./abstractions.js";
+function isToolEnvelope(value) {
+    return "object" == typeof value && null !== value && "tool" in value && "string" == typeof value.tool && "params" in value && "object" == typeof value.params;
+}
+class PipelineRunnerImpl {
+    constructor(toolRegistry){
+        this.toolRegistry = toolRegistry;
+    }
+    async resolve(data) {
+        if (null == data) return data;
+        if (isToolEnvelope(data)) {
+            const result = await this.toolRegistry.invoke(data.tool, data.params);
+            return this.resolve(result);
+        }
+        if (Array.isArray(data)) return Promise.all(data.map((item)=>this.resolve(item)));
+        if ("object" == typeof data) {
+            const entries = Object.entries(data);
+            const resolvedValues = await Promise.all(entries.map(([, value])=>this.resolve(value)));
+            return Object.fromEntries(entries.map(([key], i)=>[
+                    key,
+                    resolvedValues[i]
+                ]));
+        }
+        return data;
+    }
+}
+const ToolPipelineRunner_ToolPipelineRunner = ToolPipelineRunner.createImplementation({
+    implementation: PipelineRunnerImpl,
+    dependencies: [
+        ToolRegistry
+    ]
+});
+export { ToolPipelineRunner_ToolPipelineRunner as ToolPipelineRunner };
+
+//# sourceMappingURL=ToolPipelineRunner.js.map

package/features/tools/ToolPipelineRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tools/ToolPipelineRunner.js","sources":["../../../src/features/tools/ToolPipelineRunner.ts"],"sourcesContent":["import {\n    ToolPipelineRunner as Abstraction,\n    ToolRegistry,\n    type IToolPipelineRunner,\n    type IToolRegistry\n} from \"./abstractions.js\";\n\nfunction isToolEnvelope(\n    value: unknown\n): value is { tool: string; params: Record<string, unknown> } {\n    return (\n        typeof value === \"object\" &&\n        value !== null &&\n        \"tool\" in value &&\n        typeof (value as Record<string, unknown>).tool === \"string\" &&\n        \"params\" in value &&\n        typeof (value as Record<string, unknown>).params === \"object\"\n    );\n}\n\nclass PipelineRunnerImpl implements IToolPipelineRunner {\n    constructor(private toolRegistry: IToolRegistry) {}\n\n    async resolve(data: unknown): Promise<unknown> {\n        if (data === null || data === undefined) {\n            return data;\n        }\n\n        if (isToolEnvelope(data)) {\n            const result = await this.toolRegistry.invoke(data.tool, data.params);\n            return this.resolve(result);\n        }\n\n        if (Array.isArray(data)) {\n            return Promise.all(data.map(item => this.resolve(item)));\n        }\n\n        if (typeof data === \"object\") {\n            const entries = Object.entries(data as Record<string, unknown>);\n            const resolvedValues = await Promise.all(\n                entries.map(([, value]) => this.resolve(value))\n            );\n            return Object.fromEntries(entries.map(([key], i) => [key, resolvedValues[i]]));\n        }\n\n        return data;\n    }\n}\n\nexport const ToolPipelineRunner = Abstraction.createImplementation({\n    implementation: PipelineRunnerImpl,\n    dependencies: [ToolRegistry]\n});\n"],"names":["isToolEnvelope","value","PipelineRunnerImpl","toolRegistry","data","result","Array","Promise","item","entries","Object","resolvedValues","key","i","ToolPipelineRunner","Abstraction","ToolRegistry"],"mappings":";AAOA,SAASA,eACLC,KAAc;IAEd,OACI,AAAiB,YAAjB,OAAOA,SACPA,AAAU,SAAVA,SACA,UAAUA,SACV,AAAmD,YAAnD,OAAQA,MAAkC,IAAI,IAC9C,YAAYA,SACZ,AAAqD,YAArD,OAAQA,MAAkC,MAAM;AAExD;AAEA,MAAMC;IACF,YAAoBC,YAA2B,CAAE;aAA7BA,YAAY,GAAZA;IAA8B;IAElD,MAAM,QAAQC,IAAa,EAAoB;QAC3C,IAAIA,QAAAA,MACA,OAAOA;QAGX,IAAIJ,eAAeI,OAAO;YACtB,MAAMC,SAAS,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,CAACD,KAAK,IAAI,EAAEA,KAAK,MAAM;YACpE,OAAO,IAAI,CAAC,OAAO,CAACC;QACxB;QAEA,IAAIC,MAAM,OAAO,CAACF,OACd,OAAOG,QAAQ,GAAG,CAACH,KAAK,GAAG,CAACI,CAAAA,OAAQ,IAAI,CAAC,OAAO,CAACA;QAGrD,IAAI,AAAgB,YAAhB,OAAOJ,MAAmB;YAC1B,MAAMK,UAAUC,OAAO,OAAO,CAACN;YAC/B,MAAMO,iBAAiB,MAAMJ,QAAQ,GAAG,CACpCE,QAAQ,GAAG,CAAC,CAAC,GAAGR,MAAM,GAAK,IAAI,CAAC,OAAO,CAACA;YAE5C,OAAOS,OAAO,WAAW,CAACD,QAAQ,GAAG,CAAC,CAAC,CAACG,IAAI,EAAEC,IAAM;oBAACD;oBAAKD,cAAc,CAACE,EAAE;iBAAC;QAChF;QAEA,OAAOT;IACX;AACJ;AAEO,MAAMU,wCAAqBC,mBAAAA,oBAAgC,CAAC;IAC/D,gBAAgBb;IAChB,cAAc;QAACc;KAAa;AAChC"}

package/features/tools/ToolRegistry.d.ts

@@ -0,0 +1,12 @@
+import { type ITool, type IToolRegistry } from "./abstractions.js";
+declare class ToolRegistryImpl implements IToolRegistry {
+    private toolMap;
+    constructor(tools: ITool[]);
+    getTool(name: string): ITool;
+    getTools(): ITool[];
+    invoke(name: string, params: unknown): Promise<unknown>;
+}
+export declare const ToolRegistry: typeof ToolRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IToolRegistry>;
+};
+export {};

package/features/tools/ToolRegistry.js

@@ -0,0 +1,38 @@
+import { Tool, ToolRegistry } from "./abstractions.js";
+class ToolRegistryImpl {
+    constructor(tools){
+        this.toolMap = new Map(tools.map((t)=>[
+                t.name,
+                t
+            ]));
+    }
+    getTool(name) {
+        const tool = this.toolMap.get(name);
+        if (!tool) throw new Error(`Tool "${name}" is not registered.`);
+        return tool;
+    }
+    getTools() {
+        return [
+            ...this.toolMap.values()
+        ];
+    }
+    async invoke(name, params) {
+        const tool = this.getTool(name);
+        const validated = tool.inputSchema.parse(params);
+        return tool.execute(validated);
+    }
+}
+const ToolRegistry_ToolRegistry = ToolRegistry.createImplementation({
+    implementation: ToolRegistryImpl,
+    dependencies: [
+        [
+            Tool,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { ToolRegistry_ToolRegistry as ToolRegistry };
+
+//# sourceMappingURL=ToolRegistry.js.map

package/features/tools/ToolRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tools/ToolRegistry.js","sources":["../../../src/features/tools/ToolRegistry.ts"],"sourcesContent":["import {\n    Tool,\n    ToolRegistry as ToolRegistryAbstraction,\n    type ITool,\n    type IToolRegistry\n} from \"./abstractions.js\";\n\nclass ToolRegistryImpl implements IToolRegistry {\n    private toolMap: Map<string, ITool>;\n\n    constructor(tools: ITool[]) {\n        this.toolMap = new Map(tools.map(t => [t.name, t]));\n    }\n\n    getTool(name: string): ITool {\n        const tool = this.toolMap.get(name);\n        if (!tool) {\n            throw new Error(`Tool \"${name}\" is not registered.`);\n        }\n        return tool;\n    }\n\n    getTools(): ITool[] {\n        return [...this.toolMap.values()];\n    }\n\n    async invoke(name: string, params: unknown): Promise<unknown> {\n        const tool = this.getTool(name);\n        const validated = tool.inputSchema.parse(params);\n        return tool.execute(validated);\n    }\n}\n\nexport const ToolRegistry = ToolRegistryAbstraction.createImplementation({\n    implementation: ToolRegistryImpl,\n    dependencies: [[Tool, { multiple: true }]]\n});\n"],"names":["ToolRegistryImpl","tools","Map","t","name","tool","Error","params","validated","ToolRegistry","ToolRegistryAbstraction","Tool"],"mappings":";AAOA,MAAMA;IAGF,YAAYC,KAAc,CAAE;QACxB,IAAI,CAAC,OAAO,GAAG,IAAIC,IAAID,MAAM,GAAG,CAACE,CAAAA,IAAK;gBAACA,EAAE,IAAI;gBAAEA;aAAE;IACrD;IAEA,QAAQC,IAAY,EAAS;QACzB,MAAMC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAACD;QAC9B,IAAI,CAACC,MACD,MAAM,IAAIC,MAAM,CAAC,MAAM,EAAEF,KAAK,oBAAoB,CAAC;QAEvD,OAAOC;IACX;IAEA,WAAoB;QAChB,OAAO;eAAI,IAAI,CAAC,OAAO,CAAC,MAAM;SAAG;IACrC;IAEA,MAAM,OAAOD,IAAY,EAAEG,MAAe,EAAoB;QAC1D,MAAMF,OAAO,IAAI,CAAC,OAAO,CAACD;QAC1B,MAAMI,YAAYH,KAAK,WAAW,CAAC,KAAK,CAACE;QACzC,OAAOF,KAAK,OAAO,CAACG;IACxB;AACJ;AAEO,MAAMC,4BAAeC,aAAAA,oBAA4C,CAAC;IACrE,gBAAgBV;IAChB,cAAc;QAAC;YAACW;YAAM;gBAAE,UAAU;YAAK;SAAE;KAAC;AAC9C"}

package/features/tools/abstractions.d.ts

@@ -0,0 +1,28 @@
+import type { z } from "zod";
+export interface ITool<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType> {
+    name: string;
+    description: string;
+    inputSchema: TInput;
+    outputSchema: TOutput;
+    execute(input: z.infer<TInput>): Promise<z.infer<TOutput>>;
+}
+export declare const Tool: import("@webiny/di").Abstraction<ITool<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+export declare namespace Tool {
+    type Interface<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType> = ITool<TInput, TOutput>;
+}
+export interface IToolRegistry {
+    getTool(name: string): ITool;
+    getTools(): ITool[];
+    invoke(name: string, params: unknown): Promise<unknown>;
+}
+export declare const ToolRegistry: import("@webiny/di").Abstraction<IToolRegistry>;
+export declare namespace ToolRegistry {
+    type Interface = IToolRegistry;
+}
+export interface IToolPipelineRunner {
+    resolve(data: unknown): Promise<unknown>;
+}
+export declare const ToolPipelineRunner: import("@webiny/di").Abstraction<IToolPipelineRunner>;
+export declare namespace ToolPipelineRunner {
+    type Interface = IToolPipelineRunner;
+}

package/features/tools/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const Tool = createAbstraction("Tool");
+const ToolRegistry = createAbstraction("ToolRegistry");
+const ToolPipelineRunner = createAbstraction("ToolPipelineRunner");
+export { Tool, ToolPipelineRunner, ToolRegistry };
+
+//# sourceMappingURL=abstractions.js.map

package/features/tools/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tools/abstractions.js","sources":["../../../src/features/tools/abstractions.ts"],"sourcesContent":["import type { z } from \"zod\";\nimport { createAbstraction } from \"@webiny/feature/admin\";\n\nexport interface ITool<\n    TInput extends z.ZodType = z.ZodType,\n    TOutput extends z.ZodType = z.ZodType\n> {\n    name: string;\n    description: string;\n    inputSchema: TInput;\n    outputSchema: TOutput;\n    execute(input: z.infer<TInput>): Promise<z.infer<TOutput>>;\n}\n\nexport const Tool = createAbstraction<ITool>(\"Tool\");\n\nexport namespace Tool {\n    export type Interface<\n        TInput extends z.ZodType = z.ZodType,\n        TOutput extends z.ZodType = z.ZodType\n    > = ITool<TInput, TOutput>;\n}\n\nexport interface IToolRegistry {\n    getTool(name: string): ITool;\n    getTools(): ITool[];\n    invoke(name: string, params: unknown): Promise<unknown>;\n}\n\nexport const ToolRegistry = createAbstraction<IToolRegistry>(\"ToolRegistry\");\n\nexport namespace ToolRegistry {\n    export type Interface = IToolRegistry;\n}\n\nexport interface IToolPipelineRunner {\n    resolve(data: unknown): Promise<unknown>;\n}\n\nexport const ToolPipelineRunner = createAbstraction<IToolPipelineRunner>(\"ToolPipelineRunner\");\n\nexport namespace ToolPipelineRunner {\n    export type Interface = IToolPipelineRunner;\n}\n"],"names":["Tool","createAbstraction","ToolRegistry","ToolPipelineRunner"],"mappings":";AAcO,MAAMA,OAAOC,kBAAyB;AAetC,MAAMC,eAAeD,kBAAiC;AAUtD,MAAME,qBAAqBF,kBAAuC"}

package/features/tools/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const ToolsFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    toolRegistry: import("./abstractions.js").IToolRegistry;
+    pipelineRunner: import("./abstractions.js").IToolPipelineRunner;
+}, []>;

package/features/tools/feature.js

@@ -0,0 +1,22 @@
+import { createFeature } from "@webiny/feature/admin";
+import { ToolPipelineRunner, ToolRegistry } from "./abstractions.js";
+import { ToolRegistry as external_ToolRegistry_js_ToolRegistry } from "./ToolRegistry.js";
+import { ToolPipelineRunner as external_ToolPipelineRunner_js_ToolPipelineRunner } from "./ToolPipelineRunner.js";
+import { LexicalContext } from "./LexicalContext/LexicalContext.js";
+const ToolsFeature = createFeature({
+    name: "ToolsFeature",
+    register (container) {
+        container.register(external_ToolRegistry_js_ToolRegistry);
+        container.register(external_ToolPipelineRunner_js_ToolPipelineRunner);
+        container.register(LexicalContext).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            toolRegistry: container.resolve(ToolRegistry),
+            pipelineRunner: container.resolve(ToolPipelineRunner)
+        };
+    }
+});
+export { ToolsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/tools/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tools/feature.js","sources":["../../../src/features/tools/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { Container } from \"@webiny/di\";\nimport {\n    ToolRegistry as ToolRegistryAbstraction,\n    ToolPipelineRunner as PipelineRunnerAbstraction\n} from \"./abstractions.js\";\nimport { ToolRegistry } from \"./ToolRegistry.js\";\nimport { ToolPipelineRunner } from \"./ToolPipelineRunner.js\";\nimport { LexicalContext } from \"~/features/tools/LexicalContext/LexicalContext.js\";\n\nexport const ToolsFeature = createFeature({\n    name: \"ToolsFeature\",\n    register(container: Container) {\n        container.register(ToolRegistry);\n        container.register(ToolPipelineRunner);\n        container.register(LexicalContext).inSingletonScope();\n    },\n    resolve(container: Container) {\n        return {\n            toolRegistry: container.resolve(ToolRegistryAbstraction),\n            pipelineRunner: container.resolve(PipelineRunnerAbstraction)\n        };\n    }\n});\n"],"names":["ToolsFeature","createFeature","container","ToolRegistry","ToolPipelineRunner","LexicalContext","ToolRegistryAbstraction","PipelineRunnerAbstraction"],"mappings":";;;;;AAUO,MAAMA,eAAeC,cAAc;IACtC,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG,gBAAgB,gBAAgB;IACvD;IACA,SAAQH,SAAoB;QACxB,OAAO;YACH,cAAcA,UAAU,OAAO,CAACI;YAChC,gBAAgBJ,UAAU,OAAO,CAACK;QACtC;IACJ;AACJ"}

package/features/tools/index.d.ts

@@ -0,0 +1,3 @@
+export { LexicalContext } from "./LexicalContext/abstractions.js";
+export { Tool, ToolRegistry, ToolPipelineRunner } from "./abstractions.js";
+export { ToolsFeature } from "./feature.js";

package/features/tools/index.js

@@ -0,0 +1,3 @@
+export { LexicalContext } from "./LexicalContext/abstractions.js";
+export { Tool, ToolPipelineRunner, ToolRegistry } from "./abstractions.js";
+export { ToolsFeature } from "./feature.js";

package/features/wcp/ReactLicense.d.ts

@@ -9,10 +9,14 @@ export declare class ReactLicense implements ILicense {
     canUseFeature(featureId: keyof typeof WCP_FEATURE_LABEL): boolean;
     canUseFileManagerThreatDetection(): boolean;
     canUseFolderLevelPermissions(): boolean;
+    canUseHcmsFieldPermissions(): boolean;
     canUsePrivateFiles(): boolean;
     canUseRecordLocking(): boolean;
     canUseTeams(): boolean;
     getRawLicense(): DecryptedWcpProjectLicense | null;
     canUseWorkflows(): boolean;
+    canUseAiImageEnrichment(): boolean;
+    canUseAiPageGeneration(): boolean;
+    canUseAiLexicalGeneration(): boolean;
     toDto(): DecryptedWcpProjectLicense | null;
 }