@webiny/app-admin 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

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

@@ -0,0 +1,22 @@
+import type { DecryptedWcpProjectLicense, ILicense, WcpProject } from "@webiny/wcp/types.js";
+import type { WCP_FEATURE_LABEL } from "@webiny/wcp";
+export declare class ReactLicense implements ILicense {
+    private readonly license;
+    constructor(license: ILicense);
+    getProject(): WcpProject | null;
+    canUseAacl(): boolean;
+    canUseAuditLogs(): boolean;
+    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;
+}

package/features/wcp/ReactLicense.js

@@ -0,0 +1,56 @@
+class ReactLicense {
+    constructor(license){
+        this.license = license;
+    }
+    getProject() {
+        return this.license.getProject();
+    }
+    canUseAacl() {
+        return this.license.canUseAacl();
+    }
+    canUseAuditLogs() {
+        return this.license.canUseAuditLogs();
+    }
+    canUseFeature(featureId) {
+        return this.license.canUseFeature(featureId);
+    }
+    canUseFileManagerThreatDetection() {
+        return this.license.canUseFileManagerThreatDetection();
+    }
+    canUseFolderLevelPermissions() {
+        return this.license.canUseFolderLevelPermissions();
+    }
+    canUseHcmsFieldPermissions() {
+        return this.license.canUseHcmsFieldPermissions();
+    }
+    canUsePrivateFiles() {
+        return this.license.canUsePrivateFiles();
+    }
+    canUseRecordLocking() {
+        return this.license.canUseRecordLocking();
+    }
+    canUseTeams() {
+        return this.license.canUseTeams();
+    }
+    getRawLicense() {
+        return this.license.getRawLicense();
+    }
+    canUseWorkflows() {
+        return this.license.canUseWorkflows();
+    }
+    canUseAiImageEnrichment() {
+        return this.license.canUseAiImageEnrichment();
+    }
+    canUseAiPageGeneration() {
+        return this.license.canUseAiPageGeneration();
+    }
+    canUseAiLexicalGeneration() {
+        return this.license.canUseAiLexicalGeneration();
+    }
+    toDto() {
+        return this.license.toDto();
+    }
+}
+export { ReactLicense };
+
+//# sourceMappingURL=ReactLicense.js.map

package/features/wcp/ReactLicense.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/wcp/ReactLicense.js","sources":["../../../src/features/wcp/ReactLicense.ts"],"sourcesContent":["import type { DecryptedWcpProjectLicense, ILicense, WcpProject } from \"@webiny/wcp/types.js\";\nimport type { WCP_FEATURE_LABEL } from \"@webiny/wcp\";\n\nexport class ReactLicense implements ILicense {\n    private readonly license: ILicense;\n\n    constructor(license: ILicense) {\n        this.license = license;\n    }\n\n    getProject(): WcpProject | null {\n        return this.license.getProject();\n    }\n\n    canUseAacl(): boolean {\n        return this.license.canUseAacl();\n    }\n\n    canUseAuditLogs(): boolean {\n        return this.license.canUseAuditLogs();\n    }\n\n    canUseFeature(featureId: keyof typeof WCP_FEATURE_LABEL): boolean {\n        return this.license.canUseFeature(featureId);\n    }\n\n    canUseFileManagerThreatDetection(): boolean {\n        return this.license.canUseFileManagerThreatDetection();\n    }\n\n    canUseFolderLevelPermissions(): boolean {\n        return this.license.canUseFolderLevelPermissions();\n    }\n\n    canUseHcmsFieldPermissions(): boolean {\n        return this.license.canUseHcmsFieldPermissions();\n    }\n\n    canUsePrivateFiles(): boolean {\n        return this.license.canUsePrivateFiles();\n    }\n\n    canUseRecordLocking(): boolean {\n        return this.license.canUseRecordLocking();\n    }\n\n    canUseTeams(): boolean {\n        return this.license.canUseTeams();\n    }\n\n    getRawLicense(): DecryptedWcpProjectLicense | null {\n        return this.license.getRawLicense();\n    }\n\n    public canUseWorkflows(): boolean {\n        return this.license.canUseWorkflows();\n    }\n\n    canUseAiImageEnrichment(): boolean {\n        return this.license.canUseAiImageEnrichment();\n    }\n\n    canUseAiPageGeneration(): boolean {\n        return this.license.canUseAiPageGeneration();\n    }\n\n    canUseAiLexicalGeneration(): boolean {\n        return this.license.canUseAiLexicalGeneration();\n    }\n\n    toDto(): DecryptedWcpProjectLicense | null {\n        return this.license.toDto();\n    }\n}\n"],"names":["ReactLicense","license","featureId"],"mappings":"AAGO,MAAMA;IAGT,YAAYC,OAAiB,CAAE;QAC3B,IAAI,CAAC,OAAO,GAAGA;IACnB;IAEA,aAAgC;QAC5B,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU;IAClC;IAEA,aAAsB;QAClB,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU;IAClC;IAEA,kBAA2B;QACvB,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe;IACvC;IAEA,cAAcC,SAAyC,EAAW;QAC9D,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAACA;IACtC;IAEA,mCAA4C;QACxC,OAAO,IAAI,CAAC,OAAO,CAAC,gCAAgC;IACxD;IAEA,+BAAwC;QACpC,OAAO,IAAI,CAAC,OAAO,CAAC,4BAA4B;IACpD;IAEA,6BAAsC;QAClC,OAAO,IAAI,CAAC,OAAO,CAAC,0BAA0B;IAClD;IAEA,qBAA8B;QAC1B,OAAO,IAAI,CAAC,OAAO,CAAC,kBAAkB;IAC1C;IAEA,sBAA+B;QAC3B,OAAO,IAAI,CAAC,OAAO,CAAC,mBAAmB;IAC3C;IAEA,cAAuB;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW;IACnC;IAEA,gBAAmD;QAC/C,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa;IACrC;IAEO,kBAA2B;QAC9B,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe;IACvC;IAEA,0BAAmC;QAC/B,OAAO,IAAI,CAAC,OAAO,CAAC,uBAAuB;IAC/C;IAEA,yBAAkC;QAC9B,OAAO,IAAI,CAAC,OAAO,CAAC,sBAAsB;IAC9C;IAEA,4BAAqC;QACjC,OAAO,IAAI,CAAC,OAAO,CAAC,yBAAyB;IACjD;IAEA,QAA2C;QACvC,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK;IAC7B;AACJ"}

package/features/wcp/WcpGateway.d.ts

@@ -0,0 +1,10 @@
+import { WcpGateway as WcpGatewayAbstraction } from "./abstractions.js";
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+import type { WcpProjectData } from "./types.js";
+declare class WcpGraphQLGateway implements WcpGatewayAbstraction.Interface {
+    private client;
+    constructor(client: MainGraphQLClient.Interface);
+    fetchProject(): Promise<WcpProjectData | null>;
+}
+export declare const WcpGateway: import("@webiny/di").Implementation<typeof WcpGraphQLGateway>;
+export {};

package/features/wcp/WcpGateway.js

@@ -0,0 +1,78 @@
+import { createImplementation } from "@webiny/di";
+import { WcpGateway } from "./abstractions.js";
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+const GET_WCP_PROJECT = `
+    query GetWcpProject {
+        wcp {
+            getProject {
+                data {
+                    orgId
+                    projectId
+                    package {
+                        features {
+                            seats {
+                                enabled
+                                options
+                            }
+                            multiTenancy {
+                                enabled
+                                options
+                            }
+                            advancedPublishingWorkflow {
+                                enabled
+                            }
+                            advancedAccessControlLayer {
+                                enabled
+                                options
+                            }
+                            auditLogs {
+                                enabled
+                            }
+                            recordLocking {
+                                enabled
+                            }
+                            fileManager {
+                                enabled
+                                options
+                            }
+                            aiPowerups {
+                                enabled
+                                options
+                            }
+                        }
+                    }
+                }
+                error {
+                    message
+                    code
+                    data
+                }
+            }
+        }
+    }
+`;
+class WcpGraphQLGateway {
+    constructor(client){
+        this.client = client;
+    }
+    async fetchProject() {
+        const response = await this.client.execute({
+            query: GET_WCP_PROJECT,
+            headers: {
+                "x-tenant": "root"
+            }
+        });
+        if (response.wcp.getProject.error) throw new Error(response.wcp.getProject.error.message);
+        return response.wcp.getProject.data;
+    }
+}
+const WcpGateway_WcpGateway = createImplementation({
+    abstraction: WcpGateway,
+    implementation: WcpGraphQLGateway,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { WcpGateway_WcpGateway as WcpGateway };
+
+//# sourceMappingURL=WcpGateway.js.map

package/features/wcp/WcpGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/wcp/WcpGateway.js","sources":["../../../src/features/wcp/WcpGateway.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport { WcpGateway as WcpGatewayAbstraction } from \"./abstractions.js\";\nimport { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/index.js\";\nimport type { GetWcpProjectResponse, WcpProjectData } from \"./types.js\";\n\nconst GET_WCP_PROJECT = /* GraphQL */ `\n    query GetWcpProject {\n        wcp {\n            getProject {\n                data {\n                    orgId\n                    projectId\n                    package {\n                        features {\n                            seats {\n                                enabled\n                                options\n                            }\n                            multiTenancy {\n                                enabled\n                                options\n                            }\n                            advancedPublishingWorkflow {\n                                enabled\n                            }\n                            advancedAccessControlLayer {\n                                enabled\n                                options\n                            }\n                            auditLogs {\n                                enabled\n                            }\n                            recordLocking {\n                                enabled\n                            }\n                            fileManager {\n                                enabled\n                                options\n                            }\n                            aiPowerups {\n                                enabled\n                                options\n                            }\n                        }\n                    }\n                }\n                error {\n                    message\n                    code\n                    data\n                }\n            }\n        }\n    }\n`;\n\nclass WcpGraphQLGateway implements WcpGatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async fetchProject(): Promise<WcpProjectData | null> {\n        const response = await this.client.execute<GetWcpProjectResponse>({\n            query: GET_WCP_PROJECT,\n            headers: {\n                \"x-tenant\": \"root\"\n            }\n        });\n\n        if (response.wcp.getProject.error) {\n            throw new Error(response.wcp.getProject.error.message);\n        }\n\n        return response.wcp.getProject.data;\n    }\n}\n\nexport const WcpGateway = createImplementation({\n    abstraction: WcpGatewayAbstraction,\n    implementation: WcpGraphQLGateway,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["GET_WCP_PROJECT","WcpGraphQLGateway","client","response","Error","WcpGateway","createImplementation","WcpGatewayAbstraction","MainGraphQLClient"],"mappings":";;;AAKA,MAAMA,kBAAgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDvC,CAAC;AAED,MAAMC;IACF,YAAoBC,MAAmC,CAAE;aAArCA,MAAM,GAANA;IAAsC;IAE1D,MAAM,eAA+C;QACjD,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAwB;YAC9D,OAAOH;YACP,SAAS;gBACL,YAAY;YAChB;QACJ;QAEA,IAAIG,SAAS,GAAG,CAAC,UAAU,CAAC,KAAK,EAC7B,MAAM,IAAIC,MAAMD,SAAS,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO;QAGzD,OAAOA,SAAS,GAAG,CAAC,UAAU,CAAC,IAAI;IACvC;AACJ;AAEO,MAAME,wBAAaC,qBAAqB;IAC3C,aAAaC;IACb,gBAAgBN;IAChB,cAAc;QAACO;KAAkB;AACrC"}

package/features/wcp/WcpService.d.ts

@@ -0,0 +1,20 @@
+import { LocalStorage } from "@webiny/app/features/localStorage";
+import { EnvConfig } from "@webiny/app/features/envConfig";
+import type { ILicense } from "@webiny/wcp/types.js";
+import { WcpService as Abstraction, WcpGateway } from "./abstractions.js";
+import type { WcpFeatureName } from "../../features/wcp/types.js";
+declare class WcpServiceImpl implements Abstraction.Interface {
+    private gateway;
+    private localStorage;
+    private envConfig;
+    private project;
+    private loaded;
+    constructor(gateway: WcpGateway.Interface, localStorage: LocalStorage.Interface, envConfig: EnvConfig.Interface);
+    private initializeFromLocalStorage;
+    getProject(): ILicense;
+    isLoaded(): boolean;
+    canUseFeature(featureName: WcpFeatureName): boolean;
+    loadProject(): Promise<void>;
+}
+export declare const WcpService: import("@webiny/di").Implementation<typeof WcpServiceImpl>;
+export {};

package/features/wcp/WcpService.js

@@ -0,0 +1,74 @@
+import { makeAutoObservable, runInAction } from "mobx";
+import { createImplementation } from "@webiny/di";
+import { LocalStorage } from "@webiny/app/features/localStorage";
+import { EnvConfig } from "@webiny/app/features/envConfig";
+import { License, NullLicense } from "@webiny/wcp";
+import { WcpGateway, WcpService } from "./abstractions.js";
+import { ReactLicense } from "./ReactLicense.js";
+const LOCAL_STORAGE_KEY = "wcp/project";
+class WcpServiceImpl {
+    constructor(gateway, localStorage, envConfig){
+        this.gateway = gateway;
+        this.localStorage = localStorage;
+        this.envConfig = envConfig;
+        this.project = new ReactLicense(new NullLicense());
+        this.loaded = false;
+        makeAutoObservable(this, {}, {
+            autoBind: true
+        });
+        this.initializeFromLocalStorage();
+    }
+    initializeFromLocalStorage() {
+        if (!this.envConfig.get("wcpProjectId")) {
+            this.loaded = true;
+            return;
+        }
+        try {
+            const cachedData = this.localStorage.get(LOCAL_STORAGE_KEY);
+            if (cachedData) {
+                this.project = new ReactLicense(License.fromLicenseDto(cachedData));
+                this.loaded = true;
+            }
+        } catch (error) {
+            console.warn("Failed to load WCP project from localStorage:", error);
+        }
+        this.loadProject();
+    }
+    getProject() {
+        return this.project;
+    }
+    isLoaded() {
+        return this.loaded;
+    }
+    canUseFeature(featureName) {
+        if (!this.project) return false;
+        return this.project.canUseFeature(featureName);
+    }
+    async loadProject() {
+        if (!this.envConfig.get("wcpProjectId")) return;
+        try {
+            const data = await this.gateway.fetchProject();
+            if (!data) throw new Error("No WCP project data received.");
+            const license = new ReactLicense(License.fromLicenseDto(data));
+            runInAction(()=>{
+                this.project = license;
+                this.loaded = true;
+            });
+            this.localStorage.set(LOCAL_STORAGE_KEY, data);
+        } catch (error) {
+            console.error("Failed to load WCP project:", error);
+        }
+    }
+}
+const WcpService_WcpService = createImplementation({
+    abstraction: WcpService,
+    implementation: WcpServiceImpl,
+    dependencies: [
+        WcpGateway,
+        LocalStorage,
+        EnvConfig
+    ]
+});
+export { WcpService_WcpService as WcpService };
+
+//# sourceMappingURL=WcpService.js.map

package/features/wcp/WcpService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/wcp/WcpService.js","sources":["../../../src/features/wcp/WcpService.ts"],"sourcesContent":["import { makeAutoObservable, runInAction } from \"mobx\";\nimport { createImplementation } from \"@webiny/di\";\nimport { LocalStorage } from \"@webiny/app/features/localStorage\";\nimport { EnvConfig } from \"@webiny/app/features/envConfig\";\nimport { License, NullLicense } from \"@webiny/wcp\";\nimport type { ILicense, DecryptedWcpProjectLicense } from \"@webiny/wcp/types.js\";\nimport { WcpService as Abstraction, WcpGateway } from \"./abstractions.js\";\nimport { ReactLicense } from \"./ReactLicense.js\";\nimport type { WcpFeatureName } from \"~/features/wcp/types.js\";\n\nconst LOCAL_STORAGE_KEY = \"wcp/project\";\n\nclass WcpServiceImpl implements Abstraction.Interface {\n    private project: ILicense = new ReactLicense(new NullLicense());\n    private loaded = false;\n\n    constructor(\n        private gateway: WcpGateway.Interface,\n        private localStorage: LocalStorage.Interface,\n        private envConfig: EnvConfig.Interface\n    ) {\n        makeAutoObservable(this, {}, { autoBind: true });\n        this.initializeFromLocalStorage();\n    }\n\n    private initializeFromLocalStorage(): void {\n        // If WCP is not configured, use NullLicense\n        if (!this.envConfig.get(\"wcpProjectId\")) {\n            this.loaded = true;\n            return;\n        }\n\n        // Try to load from localStorage\n        try {\n            const cachedData = this.localStorage.get<DecryptedWcpProjectLicense>(LOCAL_STORAGE_KEY);\n            if (cachedData) {\n                // If cache exists, we use that until the project is revalidated in the background.\n                this.project = new ReactLicense(License.fromLicenseDto(cachedData));\n                this.loaded = true;\n            }\n        } catch (error) {\n            console.warn(\"Failed to load WCP project from localStorage:\", error);\n        }\n\n        /* Load/Revalidate WCP project in the background. */\n        this.loadProject();\n    }\n\n    getProject(): ILicense {\n        return this.project;\n    }\n\n    isLoaded(): boolean {\n        return this.loaded;\n    }\n\n    canUseFeature(featureName: WcpFeatureName): boolean {\n        if (!this.project) {\n            return false;\n        }\n        return this.project.canUseFeature(featureName);\n    }\n\n    async loadProject(): Promise<void> {\n        // If WCP is not configured, nothing to load\n        if (!this.envConfig.get(\"wcpProjectId\")) {\n            return;\n        }\n\n        try {\n            const data = await this.gateway.fetchProject();\n\n            if (!data) {\n                throw new Error(\"No WCP project data received.\");\n            }\n\n            const license = new ReactLicense(License.fromLicenseDto(data));\n\n            runInAction(() => {\n                this.project = license;\n                this.loaded = true;\n            });\n\n            // Cache in localStorage\n            this.localStorage.set(LOCAL_STORAGE_KEY, data);\n        } catch (error) {\n            console.error(\"Failed to load WCP project:\", error);\n        }\n    }\n}\n\nexport const WcpService = createImplementation({\n    abstraction: Abstraction,\n    implementation: WcpServiceImpl,\n    dependencies: [WcpGateway, LocalStorage, EnvConfig]\n});\n"],"names":["LOCAL_STORAGE_KEY","WcpServiceImpl","gateway","localStorage","envConfig","ReactLicense","NullLicense","makeAutoObservable","cachedData","License","error","console","featureName","data","Error","license","runInAction","WcpService","createImplementation","Abstraction","WcpGateway","LocalStorage","EnvConfig"],"mappings":";;;;;;;AAUA,MAAMA,oBAAoB;AAE1B,MAAMC;IAIF,YACYC,OAA6B,EAC7BC,YAAoC,EACpCC,SAA8B,CACxC;aAHUF,OAAO,GAAPA;aACAC,YAAY,GAAZA;aACAC,SAAS,GAATA;aANJ,OAAO,GAAa,IAAIC,aAAa,IAAIC;aACzC,MAAM,GAAG;QAObC,mBAAmB,IAAI,EAAE,CAAC,GAAG;YAAE,UAAU;QAAK;QAC9C,IAAI,CAAC,0BAA0B;IACnC;IAEQ,6BAAmC;QAEvC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,iBAAiB;YACrC,IAAI,CAAC,MAAM,GAAG;YACd;QACJ;QAGA,IAAI;YACA,MAAMC,aAAa,IAAI,CAAC,YAAY,CAAC,GAAG,CAA6BR;YACrE,IAAIQ,YAAY;gBAEZ,IAAI,CAAC,OAAO,GAAG,IAAIH,aAAaI,QAAQ,cAAc,CAACD;gBACvD,IAAI,CAAC,MAAM,GAAG;YAClB;QACJ,EAAE,OAAOE,OAAO;YACZC,QAAQ,IAAI,CAAC,iDAAiDD;QAClE;QAGA,IAAI,CAAC,WAAW;IACpB;IAEA,aAAuB;QACnB,OAAO,IAAI,CAAC,OAAO;IACvB;IAEA,WAAoB;QAChB,OAAO,IAAI,CAAC,MAAM;IACtB;IAEA,cAAcE,WAA2B,EAAW;QAChD,IAAI,CAAC,IAAI,CAAC,OAAO,EACb,OAAO;QAEX,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAACA;IACtC;IAEA,MAAM,cAA6B;QAE/B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,iBACpB;QAGJ,IAAI;YACA,MAAMC,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,YAAY;YAE5C,IAAI,CAACA,MACD,MAAM,IAAIC,MAAM;YAGpB,MAAMC,UAAU,IAAIV,aAAaI,QAAQ,cAAc,CAACI;YAExDG,YAAY;gBACR,IAAI,CAAC,OAAO,GAAGD;gBACf,IAAI,CAAC,MAAM,GAAG;YAClB;YAGA,IAAI,CAAC,YAAY,CAAC,GAAG,CAACf,mBAAmBa;QAC7C,EAAE,OAAOH,OAAO;YACZC,QAAQ,KAAK,CAAC,+BAA+BD;QACjD;IACJ;AACJ;AAEO,MAAMO,wBAAaC,qBAAqB;IAC3C,aAAaC;IACb,gBAAgBlB;IAChB,cAAc;QAACmB;QAAYC;QAAcC;KAAU;AACvD"}

package/features/wcp/abstractions.d.ts

@@ -0,0 +1,19 @@
+import { Abstraction } from "@webiny/di";
+import type { DecryptedWcpProjectLicense, ILicense } from "@webiny/wcp/types.js";
+export interface IWcpGateway {
+    fetchProject(): Promise<DecryptedWcpProjectLicense | null>;
+}
+export declare const WcpGateway: Abstraction<IWcpGateway>;
+export declare namespace WcpGateway {
+    type Interface = IWcpGateway;
+}
+export interface IWcpService {
+    getProject(): ILicense;
+    isLoaded(): boolean;
+    canUseFeature(featureName: string): boolean;
+    loadProject(): Promise<void>;
+}
+export declare const WcpService: Abstraction<IWcpService>;
+export declare namespace WcpService {
+    type Interface = IWcpService;
+}

package/features/wcp/abstractions.js

@@ -0,0 +1,6 @@
+import { Abstraction } from "@webiny/di";
+const WcpGateway = new Abstraction("WcpGateway");
+const WcpService = new Abstraction("WcpService");
+export { WcpGateway, WcpService };
+
+//# sourceMappingURL=abstractions.js.map

package/features/wcp/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/wcp/abstractions.js","sources":["../../../src/features/wcp/abstractions.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\nimport type { DecryptedWcpProjectLicense, ILicense } from \"@webiny/wcp/types.js\";\n\nexport interface IWcpGateway {\n    fetchProject(): Promise<DecryptedWcpProjectLicense | null>;\n}\n\nexport const WcpGateway = new Abstraction<IWcpGateway>(\"WcpGateway\");\n\nexport namespace WcpGateway {\n    export type Interface = IWcpGateway;\n}\n\nexport interface IWcpService {\n    getProject(): ILicense;\n    isLoaded(): boolean;\n    canUseFeature(featureName: string): boolean;\n    loadProject(): Promise<void>;\n}\n\nexport const WcpService = new Abstraction<IWcpService>(\"WcpService\");\n\nexport namespace WcpService {\n    export type Interface = IWcpService;\n}\n"],"names":["WcpGateway","Abstraction","WcpService"],"mappings":";AAOO,MAAMA,aAAa,IAAIC,YAAyB;AAahD,MAAMC,aAAa,IAAID,YAAyB"}

package/features/wcp/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const WcpFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    service: import("./abstractions.js").IWcpService;
+}, []>;