@webiny/api-aco 6.3.0-beta.4 → 6.4.0-beta.0

package/features/folder/EnsureFolderIsEmpty/EnsureFolderIsEmpty.js

@@ -1,56 +1,55 @@
 import { FolderLevelPermissions } from "../../flp/FolderLevelPermissions/index.js";
 import { ListFoldersUseCase } from "../ListFolders/index.js";
-import { EnsureFolderIsEmpty as Abstraction } from "./abstractions.js";
+import { EnsureFolderIsEmpty } from "./abstractions.js";
 import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
 import { FolderNotAuthorizedError, FolderNotEmptyError } from "../../../domain/folder/errors.js";
 import { Result } from "@webiny/feature/api";
 class EnsureFolderIsEmptyImpl {
-  constructor(identityContext, folderLevelPermissions, listFoldersUseCase) {
-    this.identityContext = identityContext;
-    this.folderLevelPermissions = folderLevelPermissions;
-    this.listFoldersUseCase = listFoldersUseCase;
-  }
-  async execute(type, id, hasContentCallback) {
-    const hasFoldersCallback = async () => {
-      const result = await this.listFoldersUseCase.execute({
-        where: {
-          type,
-          parentId: id
-        },
-        limit: 1
-      });
-      const {
-        folders
-      } = result.value;
-      return folders.length > 0;
-    };
-    const [hasFolders, hasContent] = await Promise.all([hasFoldersCallback(), hasContentCallback()]);
-    if (hasFolders || hasContent) {
-      return Result.fail(new FolderNotEmptyError());
+    constructor(identityContext, folderLevelPermissions, listFoldersUseCase){
+        this.identityContext = identityContext;
+        this.folderLevelPermissions = folderLevelPermissions;
+        this.listFoldersUseCase = listFoldersUseCase;
     }
-
-    // Let's also check if there are folders / content that are not visible because of folder permissions.
-    if (!this.folderLevelPermissions.canUseFolderLevelPermissions()) {
-      // If folder level permissions are not enabled, we can skip this check. This is because
-      // in that case, all folders and content are visible to the user.
-      return Result.ok();
-    }
-    const [hasInvisibleFolders, hasInvisibleContent] = await this.identityContext.withoutAuthorization(async () => {
-      const [hasFolders, hasContent] = await Promise.all([hasFoldersCallback(), hasContentCallback()]);
-      return [hasFolders, hasContent];
-    });
-
-    // In case there are invisible folders or content, we'll throw a different error.
-    // This is to prevent users from deleting folders that contain content they can't see.
-    if (hasInvisibleFolders || hasInvisibleContent) {
-      return Result.fail(new FolderNotAuthorizedError());
+    async execute(type, id, hasContentCallback) {
+        const hasFoldersCallback = async ()=>{
+            const result = await this.listFoldersUseCase.execute({
+                where: {
+                    type,
+                    parentId: id
+                },
+                limit: 1
+            });
+            const { folders } = result.value;
+            return folders.length > 0;
+        };
+        const [hasFolders, hasContent] = await Promise.all([
+            hasFoldersCallback(),
+            hasContentCallback()
+        ]);
+        if (hasFolders || hasContent) return Result.fail(new FolderNotEmptyError());
+        if (!this.folderLevelPermissions.canUseFolderLevelPermissions()) return Result.ok();
+        const [hasInvisibleFolders, hasInvisibleContent] = await this.identityContext.withoutAuthorization(async ()=>{
+            const [hasFolders, hasContent] = await Promise.all([
+                hasFoldersCallback(),
+                hasContentCallback()
+            ]);
+            return [
+                hasFolders,
+                hasContent
+            ];
+        });
+        if (hasInvisibleFolders || hasInvisibleContent) return Result.fail(new FolderNotAuthorizedError());
+        return Result.ok();
     }
-    return Result.ok();
-  }
 }
-export const EnsureFolderIsEmpty = Abstraction.createImplementation({
-  implementation: EnsureFolderIsEmptyImpl,
-  dependencies: [IdentityContext, FolderLevelPermissions, ListFoldersUseCase]
+const EnsureFolderIsEmpty_EnsureFolderIsEmpty = EnsureFolderIsEmpty.createImplementation({
+    implementation: EnsureFolderIsEmptyImpl,
+    dependencies: [
+        IdentityContext,
+        FolderLevelPermissions,
+        ListFoldersUseCase
+    ]
 });
+export { EnsureFolderIsEmpty_EnsureFolderIsEmpty as EnsureFolderIsEmpty };
 
 //# sourceMappingURL=EnsureFolderIsEmpty.js.map

package/features/folder/EnsureFolderIsEmpty/EnsureFolderIsEmpty.js.map

@@ -1 +1 @@
-{"version":3,"names":["FolderLevelPermissions","ListFoldersUseCase","EnsureFolderIsEmpty","Abstraction","IdentityContext","FolderNotAuthorizedError","FolderNotEmptyError","Result","EnsureFolderIsEmptyImpl","constructor","identityContext","folderLevelPermissions","listFoldersUseCase","execute","type","id","hasContentCallback","hasFoldersCallback","result","where","parentId","limit","folders","value","length","hasFolders","hasContent","Promise","all","fail","canUseFolderLevelPermissions","ok","hasInvisibleFolders","hasInvisibleContent","withoutAuthorization","createImplementation","implementation","dependencies"],"sources":["EnsureFolderIsEmpty.ts"],"sourcesContent":["import { FolderLevelPermissions } from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { ListFoldersUseCase } from \"~/features/folder/ListFolders/index.js\";\nimport { EnsureFolderIsEmpty as Abstraction } from \"~/features/folder/EnsureFolderIsEmpty/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { FolderNotAuthorizedError, FolderNotEmptyError } from \"~/domain/folder/errors.js\";\nimport { Result } from \"@webiny/feature/api\";\n\nclass EnsureFolderIsEmptyImpl implements Abstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private folderLevelPermissions: FolderLevelPermissions.Interface,\n        private listFoldersUseCase: ListFoldersUseCase.Interface\n    ) {}\n\n    async execute(\n        type: string,\n        id: string,\n        hasContentCallback: Abstraction.HasContentCallback\n    ): Abstraction.Return {\n        const hasFoldersCallback = async () => {\n            const result = await this.listFoldersUseCase.execute({\n                where: {\n                    type,\n                    parentId: id\n                },\n                limit: 1\n            });\n\n            const { folders } = result.value;\n\n            return folders.length > 0;\n        };\n\n        const [hasFolders, hasContent] = await Promise.all([\n            hasFoldersCallback(),\n            hasContentCallback()\n        ]);\n\n        if (hasFolders || hasContent) {\n            return Result.fail(new FolderNotEmptyError());\n        }\n\n        // Let's also check if there are folders / content that are not visible because of folder permissions.\n        if (!this.folderLevelPermissions.canUseFolderLevelPermissions()) {\n            // If folder level permissions are not enabled, we can skip this check. This is because\n            // in that case, all folders and content are visible to the user.\n            return Result.ok();\n        }\n\n        const [hasInvisibleFolders, hasInvisibleContent] =\n            await this.identityContext.withoutAuthorization(async () => {\n                const [hasFolders, hasContent] = await Promise.all([\n                    hasFoldersCallback(),\n                    hasContentCallback()\n                ]);\n                return [hasFolders, hasContent];\n            });\n\n        // In case there are invisible folders or content, we'll throw a different error.\n        // This is to prevent users from deleting folders that contain content they can't see.\n        if (hasInvisibleFolders || hasInvisibleContent) {\n            return Result.fail(new FolderNotAuthorizedError());\n        }\n\n        return Result.ok();\n    }\n}\n\nexport const EnsureFolderIsEmpty = Abstraction.createImplementation({\n    implementation: EnsureFolderIsEmptyImpl,\n    dependencies: [IdentityContext, FolderLevelPermissions, ListFoldersUseCase]\n});\n"],"mappings":"AAAA,SAASA,sBAAsB;AAC/B,SAASC,kBAAkB;AAC3B,SAASC,mBAAmB,IAAIC,WAAW;AAC3C,SAASC,eAAe,QAAQ,6DAA6D;AAC7F,SAASC,wBAAwB,EAAEC,mBAAmB;AACtD,SAASC,MAAM,QAAQ,qBAAqB;AAE5C,MAAMC,uBAAuB,CAAkC;EAC3DC,WAAWA,CACCC,eAA0C,EAC1CC,sBAAwD,EACxDC,kBAAgD,EAC1D;IAAA,KAHUF,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,sBAAwD,GAAxDA,sBAAwD;IAAA,KACxDC,kBAAgD,GAAhDA,kBAAgD;EACzD;EAEH,MAAMC,OAAOA,CACTC,IAAY,EACZC,EAAU,EACVC,kBAAkD,EAChC;IAClB,MAAMC,kBAAkB,GAAG,MAAAA,CAAA,KAAY;MACnC,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACN,kBAAkB,CAACC,OAAO,CAAC;QACjDM,KAAK,EAAE;UACHL,IAAI;UACJM,QAAQ,EAAEL;QACd,CAAC;QACDM,KAAK,EAAE;MACX,CAAC,CAAC;MAEF,MAAM;QAAEC;MAAQ,CAAC,GAAGJ,MAAM,CAACK,KAAK;MAEhC,OAAOD,OAAO,CAACE,MAAM,GAAG,CAAC;IAC7B,CAAC;IAED,MAAM,CAACC,UAAU,EAAEC,UAAU,CAAC,GAAG,MAAMC,OAAO,CAACC,GAAG,CAAC,CAC/CX,kBAAkB,CAAC,CAAC,EACpBD,kBAAkB,CAAC,CAAC,CACvB,CAAC;IAEF,IAAIS,UAAU,IAAIC,UAAU,EAAE;MAC1B,OAAOnB,MAAM,CAACsB,IAAI,CAAC,IAAIvB,mBAAmB,CAAC,CAAC,CAAC;IACjD;;IAEA;IACA,IAAI,CAAC,IAAI,CAACK,sBAAsB,CAACmB,4BAA4B,CAAC,CAAC,EAAE;MAC7D;MACA;MACA,OAAOvB,MAAM,CAACwB,EAAE,CAAC,CAAC;IACtB;IAEA,MAAM,CAACC,mBAAmB,EAAEC,mBAAmB,CAAC,GAC5C,MAAM,IAAI,CAACvB,eAAe,CAACwB,oBAAoB,CAAC,YAAY;MACxD,MAAM,CAACT,UAAU,EAAEC,UAAU,CAAC,GAAG,MAAMC,OAAO,CAACC,GAAG,CAAC,CAC/CX,kBAAkB,CAAC,CAAC,EACpBD,kBAAkB,CAAC,CAAC,CACvB,CAAC;MACF,OAAO,CAACS,UAAU,EAAEC,UAAU,CAAC;IACnC,CAAC,CAAC;;IAEN;IACA;IACA,IAAIM,mBAAmB,IAAIC,mBAAmB,EAAE;MAC5C,OAAO1B,MAAM,CAACsB,IAAI,CAAC,IAAIxB,wBAAwB,CAAC,CAAC,CAAC;IACtD;IAEA,OAAOE,MAAM,CAACwB,EAAE,CAAC,CAAC;EACtB;AACJ;AAEA,OAAO,MAAM7B,mBAAmB,GAAGC,WAAW,CAACgC,oBAAoB,CAAC;EAChEC,cAAc,EAAE5B,uBAAuB;EACvC6B,YAAY,EAAE,CAACjC,eAAe,EAAEJ,sBAAsB,EAAEC,kBAAkB;AAC9E,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/folder/EnsureFolderIsEmpty/EnsureFolderIsEmpty.js","sources":["../../../../src/features/folder/EnsureFolderIsEmpty/EnsureFolderIsEmpty.ts"],"sourcesContent":["import { FolderLevelPermissions } from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { ListFoldersUseCase } from \"~/features/folder/ListFolders/index.js\";\nimport { EnsureFolderIsEmpty as Abstraction } from \"~/features/folder/EnsureFolderIsEmpty/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { FolderNotAuthorizedError, FolderNotEmptyError } from \"~/domain/folder/errors.js\";\nimport { Result } from \"@webiny/feature/api\";\n\nclass EnsureFolderIsEmptyImpl implements Abstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private folderLevelPermissions: FolderLevelPermissions.Interface,\n        private listFoldersUseCase: ListFoldersUseCase.Interface\n    ) {}\n\n    async execute(\n        type: string,\n        id: string,\n        hasContentCallback: Abstraction.HasContentCallback\n    ): Abstraction.Return {\n        const hasFoldersCallback = async () => {\n            const result = await this.listFoldersUseCase.execute({\n                where: {\n                    type,\n                    parentId: id\n                },\n                limit: 1\n            });\n\n            const { folders } = result.value;\n\n            return folders.length > 0;\n        };\n\n        const [hasFolders, hasContent] = await Promise.all([\n            hasFoldersCallback(),\n            hasContentCallback()\n        ]);\n\n        if (hasFolders || hasContent) {\n            return Result.fail(new FolderNotEmptyError());\n        }\n\n        // Let's also check if there are folders / content that are not visible because of folder permissions.\n        if (!this.folderLevelPermissions.canUseFolderLevelPermissions()) {\n            // If folder level permissions are not enabled, we can skip this check. This is because\n            // in that case, all folders and content are visible to the user.\n            return Result.ok();\n        }\n\n        const [hasInvisibleFolders, hasInvisibleContent] =\n            await this.identityContext.withoutAuthorization(async () => {\n                const [hasFolders, hasContent] = await Promise.all([\n                    hasFoldersCallback(),\n                    hasContentCallback()\n                ]);\n                return [hasFolders, hasContent];\n            });\n\n        // In case there are invisible folders or content, we'll throw a different error.\n        // This is to prevent users from deleting folders that contain content they can't see.\n        if (hasInvisibleFolders || hasInvisibleContent) {\n            return Result.fail(new FolderNotAuthorizedError());\n        }\n\n        return Result.ok();\n    }\n}\n\nexport const EnsureFolderIsEmpty = Abstraction.createImplementation({\n    implementation: EnsureFolderIsEmptyImpl,\n    dependencies: [IdentityContext, FolderLevelPermissions, ListFoldersUseCase]\n});\n"],"names":["EnsureFolderIsEmptyImpl","identityContext","folderLevelPermissions","listFoldersUseCase","type","id","hasContentCallback","hasFoldersCallback","result","folders","hasFolders","hasContent","Promise","Result","FolderNotEmptyError","hasInvisibleFolders","hasInvisibleContent","FolderNotAuthorizedError","EnsureFolderIsEmpty","Abstraction","IdentityContext","FolderLevelPermissions","ListFoldersUseCase"],"mappings":";;;;;;AAOA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,sBAAwD,EACxDC,kBAAgD,CAC1D;aAHUF,eAAe,GAAfA;aACAC,sBAAsB,GAAtBA;aACAC,kBAAkB,GAAlBA;IACT;IAEH,MAAM,QACFC,IAAY,EACZC,EAAU,EACVC,kBAAkD,EAChC;QAClB,MAAMC,qBAAqB;YACvB,MAAMC,SAAS,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;gBACjD,OAAO;oBACHJ;oBACA,UAAUC;gBACd;gBACA,OAAO;YACX;YAEA,MAAM,EAAEI,OAAO,EAAE,GAAGD,OAAO,KAAK;YAEhC,OAAOC,QAAQ,MAAM,GAAG;QAC5B;QAEA,MAAM,CAACC,YAAYC,WAAW,GAAG,MAAMC,QAAQ,GAAG,CAAC;YAC/CL;YACAD;SACH;QAED,IAAII,cAAcC,YACd,OAAOE,OAAO,IAAI,CAAC,IAAIC;QAI3B,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,4BAA4B,IAGzD,OAAOD,OAAO,EAAE;QAGpB,MAAM,CAACE,qBAAqBC,oBAAoB,GAC5C,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC;YAC5C,MAAM,CAACN,YAAYC,WAAW,GAAG,MAAMC,QAAQ,GAAG,CAAC;gBAC/CL;gBACAD;aACH;YACD,OAAO;gBAACI;gBAAYC;aAAW;QACnC;QAIJ,IAAII,uBAAuBC,qBACvB,OAAOH,OAAO,IAAI,CAAC,IAAII;QAG3B,OAAOJ,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMK,0CAAsBC,oBAAAA,oBAAgC,CAAC;IAChE,gBAAgBnB;IAChB,cAAc;QAACoB;QAAiBC;QAAwBC;KAAmB;AAC/E"}

package/features/folder/EnsureFolderIsEmpty/abstractions.js

@@ -1,5 +1,5 @@
 import { createAbstraction } from "@webiny/feature/api";
-/** Verify a folder has no children before deletion. */
-export const EnsureFolderIsEmpty = createAbstraction("EnsureFolderIsEmpty");
+const EnsureFolderIsEmpty = createAbstraction("EnsureFolderIsEmpty");
+export { EnsureFolderIsEmpty };
 
 //# sourceMappingURL=abstractions.js.map

package/features/folder/EnsureFolderIsEmpty/abstractions.js.map

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","EnsureFolderIsEmpty"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport { FolderNotAuthorizedError, FolderNotEmptyError } from \"~/domain/folder/errors.js\";\n\nexport interface IHasContentCallback {\n    (): boolean | Promise<boolean>;\n}\n\nexport interface IEnsureFolderIsEmpty {\n    execute(\n        type: string,\n        id: string,\n        hasContentCallback: IHasContentCallback\n    ): Promise<Result<void, UseCaseError>>;\n}\n\nexport interface IEnsureFolderIsEmptyError {\n    notAuthorized: FolderNotAuthorizedError;\n    notEmpty: FolderNotEmptyError;\n}\n\ntype UseCaseError = IEnsureFolderIsEmptyError[keyof IEnsureFolderIsEmptyError];\n\n/** Verify a folder has no children before deletion. */\nexport const EnsureFolderIsEmpty = createAbstraction<IEnsureFolderIsEmpty>(\"EnsureFolderIsEmpty\");\n\nexport namespace EnsureFolderIsEmpty {\n    export type Interface = IEnsureFolderIsEmpty;\n    export type HasContentCallback = IHasContentCallback;\n    export type Return = Promise<Result<void, UseCaseError>>;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;AAsB/D;AACA,OAAO,MAAMC,mBAAmB,GAAGD,iBAAiB,CAAuB,qBAAqB,CAAC","ignoreList":[]}
+{"version":3,"file":"features/folder/EnsureFolderIsEmpty/abstractions.js","sources":["../../../../src/features/folder/EnsureFolderIsEmpty/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport { FolderNotAuthorizedError, FolderNotEmptyError } from \"~/domain/folder/errors.js\";\n\nexport interface IHasContentCallback {\n    (): boolean | Promise<boolean>;\n}\n\nexport interface IEnsureFolderIsEmpty {\n    execute(\n        type: string,\n        id: string,\n        hasContentCallback: IHasContentCallback\n    ): Promise<Result<void, UseCaseError>>;\n}\n\nexport interface IEnsureFolderIsEmptyError {\n    notAuthorized: FolderNotAuthorizedError;\n    notEmpty: FolderNotEmptyError;\n}\n\ntype UseCaseError = IEnsureFolderIsEmptyError[keyof IEnsureFolderIsEmptyError];\n\n/** Verify a folder has no children before deletion. */\nexport const EnsureFolderIsEmpty = createAbstraction<IEnsureFolderIsEmpty>(\"EnsureFolderIsEmpty\");\n\nexport namespace EnsureFolderIsEmpty {\n    export type Interface = IEnsureFolderIsEmpty;\n    export type HasContentCallback = IHasContentCallback;\n    export type Return = Promise<Result<void, UseCaseError>>;\n}\n"],"names":["EnsureFolderIsEmpty","createAbstraction"],"mappings":";AAuBO,MAAMA,sBAAsBC,kBAAwC"}

package/features/folder/EnsureFolderIsEmpty/feature.js

@@ -1,10 +1,11 @@
 import { createFeature } from "@webiny/feature/api";
 import { EnsureFolderIsEmpty } from "./EnsureFolderIsEmpty.js";
-export const EnsureFolderIsEmptyFeature = createFeature({
-  name: "EnsureFolderIsEmptyFeature",
-  register(container) {
-    container.register(EnsureFolderIsEmpty);
-  }
+const EnsureFolderIsEmptyFeature = createFeature({
+    name: "EnsureFolderIsEmptyFeature",
+    register (container) {
+        container.register(EnsureFolderIsEmpty);
+    }
 });
+export { EnsureFolderIsEmptyFeature };
 
 //# sourceMappingURL=feature.js.map

package/features/folder/EnsureFolderIsEmpty/feature.js.map

@@ -1 +1 @@
-{"version":3,"names":["createFeature","EnsureFolderIsEmpty","EnsureFolderIsEmptyFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { EnsureFolderIsEmpty } from \"./EnsureFolderIsEmpty.js\";\n\nexport const EnsureFolderIsEmptyFeature = createFeature({\n    name: \"EnsureFolderIsEmptyFeature\",\n    register(container) {\n        container.register(EnsureFolderIsEmpty);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,mBAAmB;AAE5B,OAAO,MAAMC,0BAA0B,GAAGF,aAAa,CAAC;EACpDG,IAAI,EAAE,4BAA4B;EAClCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,mBAAmB,CAAC;EAC3C;AACJ,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/folder/EnsureFolderIsEmpty/feature.js","sources":["../../../../src/features/folder/EnsureFolderIsEmpty/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { EnsureFolderIsEmpty } from \"./EnsureFolderIsEmpty.js\";\n\nexport const EnsureFolderIsEmptyFeature = createFeature({\n    name: \"EnsureFolderIsEmptyFeature\",\n    register(container) {\n        container.register(EnsureFolderIsEmpty);\n    }\n});\n"],"names":["EnsureFolderIsEmptyFeature","createFeature","container","EnsureFolderIsEmpty"],"mappings":";;AAGO,MAAMA,6BAA6BC,cAAc;IACpD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/folder/EnsureFolderIsEmpty/index.js

@@ -1,3 +1 @@
 export { EnsureFolderIsEmpty } from "./abstractions.js";
-
-//# sourceMappingURL=index.js.map

package/features/folder/EnsureFolderIsEmptyOnDelete/GenericFolderBeforeDeleteHandler.js

@@ -2,28 +2,24 @@ import { WebinyError } from "@webiny/error";
 import { FolderBeforeDeleteEventHandler } from "../DeleteFolder/abstractions.js";
 import { EnsureFolderIsEmpty } from "../EnsureFolderIsEmpty/abstractions.js";
 class GenericFolderBeforeDeleteHandlerImpl {
-  constructor(ensureFolderIsEmpty) {
-    this.ensureFolderIsEmpty = ensureFolderIsEmpty;
-  }
-  async handle(event) {
-    const {
-      folder
-    } = event.payload;
-    const result = await this.ensureFolderIsEmpty.execute(folder.type, folder.id,
-    // We can only check if a folder has child folders.
-    // Content is controlled by individual apps, so content checks are implemented there.
-    () => false);
-    if (result.isFail()) {
-      throw WebinyError.from(result.error, {
-        message: "Error while ensuring folder is empty before delete.",
-        code: "ACO_BEFORE_FOLDER_DELETE_FILE_HANDLER"
-      });
+    constructor(ensureFolderIsEmpty){
+        this.ensureFolderIsEmpty = ensureFolderIsEmpty;
+    }
+    async handle(event) {
+        const { folder } = event.payload;
+        const result = await this.ensureFolderIsEmpty.execute(folder.type, folder.id, ()=>false);
+        if (result.isFail()) throw WebinyError.from(result.error, {
+            message: "Error while ensuring folder is empty before delete.",
+            code: "ACO_BEFORE_FOLDER_DELETE_FILE_HANDLER"
+        });
     }
-  }
 }
-export const GenericFolderBeforeDeleteHandler = FolderBeforeDeleteEventHandler.createImplementation({
-  implementation: GenericFolderBeforeDeleteHandlerImpl,
-  dependencies: [EnsureFolderIsEmpty]
+const GenericFolderBeforeDeleteHandler = FolderBeforeDeleteEventHandler.createImplementation({
+    implementation: GenericFolderBeforeDeleteHandlerImpl,
+    dependencies: [
+        EnsureFolderIsEmpty
+    ]
 });
+export { GenericFolderBeforeDeleteHandler };
 
 //# sourceMappingURL=GenericFolderBeforeDeleteHandler.js.map

package/features/folder/EnsureFolderIsEmptyOnDelete/GenericFolderBeforeDeleteHandler.js.map

@@ -1 +1 @@
-{"version":3,"names":["WebinyError","FolderBeforeDeleteEventHandler","EnsureFolderIsEmpty","GenericFolderBeforeDeleteHandlerImpl","constructor","ensureFolderIsEmpty","handle","event","folder","payload","result","execute","type","id","isFail","from","error","message","code","GenericFolderBeforeDeleteHandler","createImplementation","implementation","dependencies"],"sources":["GenericFolderBeforeDeleteHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { FolderBeforeDeleteEventHandler } from \"~/features/folder/DeleteFolder/abstractions.js\";\nimport type { FolderBeforeDeleteEvent } from \"~/features/folder/DeleteFolder/events.js\";\nimport { EnsureFolderIsEmpty } from \"~/features/folder/EnsureFolderIsEmpty/abstractions.js\";\n\nclass GenericFolderBeforeDeleteHandlerImpl implements FolderBeforeDeleteEventHandler.Interface {\n    constructor(private ensureFolderIsEmpty: EnsureFolderIsEmpty.Interface) {}\n\n    async handle(event: FolderBeforeDeleteEvent): Promise<void> {\n        const { folder } = event.payload;\n\n        const result = await this.ensureFolderIsEmpty.execute(\n            folder.type,\n            folder.id,\n            // We can only check if a folder has child folders.\n            // Content is controlled by individual apps, so content checks are implemented there.\n            () => false\n        );\n\n        if (result.isFail()) {\n            throw WebinyError.from(result.error, {\n                message: \"Error while ensuring folder is empty before delete.\",\n                code: \"ACO_BEFORE_FOLDER_DELETE_FILE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const GenericFolderBeforeDeleteHandler = FolderBeforeDeleteEventHandler.createImplementation(\n    {\n        implementation: GenericFolderBeforeDeleteHandlerImpl,\n        dependencies: [EnsureFolderIsEmpty]\n    }\n);\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,eAAe;AAC3C,SAASC,8BAA8B;AAEvC,SAASC,mBAAmB;AAE5B,MAAMC,oCAAoC,CAAqD;EAC3FC,WAAWA,CAASC,mBAAkD,EAAE;IAAA,KAApDA,mBAAkD,GAAlDA,mBAAkD;EAAG;EAEzE,MAAMC,MAAMA,CAACC,KAA8B,EAAiB;IACxD,MAAM;MAAEC;IAAO,CAAC,GAAGD,KAAK,CAACE,OAAO;IAEhC,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACL,mBAAmB,CAACM,OAAO,CACjDH,MAAM,CAACI,IAAI,EACXJ,MAAM,CAACK,EAAE;IACT;IACA;IACA,MAAM,KACV,CAAC;IAED,IAAIH,MAAM,CAACI,MAAM,CAAC,CAAC,EAAE;MACjB,MAAMd,WAAW,CAACe,IAAI,CAACL,MAAM,CAACM,KAAK,EAAE;QACjCC,OAAO,EAAE,qDAAqD;QAC9DC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,gCAAgC,GAAGlB,8BAA8B,CAACmB,oBAAoB,CAC/F;EACIC,cAAc,EAAElB,oCAAoC;EACpDmB,YAAY,EAAE,CAACpB,mBAAmB;AACtC,CACJ,CAAC","ignoreList":[]}
+{"version":3,"file":"features/folder/EnsureFolderIsEmptyOnDelete/GenericFolderBeforeDeleteHandler.js","sources":["../../../../src/features/folder/EnsureFolderIsEmptyOnDelete/GenericFolderBeforeDeleteHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { FolderBeforeDeleteEventHandler } from \"~/features/folder/DeleteFolder/abstractions.js\";\nimport type { FolderBeforeDeleteEvent } from \"~/features/folder/DeleteFolder/events.js\";\nimport { EnsureFolderIsEmpty } from \"~/features/folder/EnsureFolderIsEmpty/abstractions.js\";\n\nclass GenericFolderBeforeDeleteHandlerImpl implements FolderBeforeDeleteEventHandler.Interface {\n    constructor(private ensureFolderIsEmpty: EnsureFolderIsEmpty.Interface) {}\n\n    async handle(event: FolderBeforeDeleteEvent): Promise<void> {\n        const { folder } = event.payload;\n\n        const result = await this.ensureFolderIsEmpty.execute(\n            folder.type,\n            folder.id,\n            // We can only check if a folder has child folders.\n            // Content is controlled by individual apps, so content checks are implemented there.\n            () => false\n        );\n\n        if (result.isFail()) {\n            throw WebinyError.from(result.error, {\n                message: \"Error while ensuring folder is empty before delete.\",\n                code: \"ACO_BEFORE_FOLDER_DELETE_FILE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const GenericFolderBeforeDeleteHandler = FolderBeforeDeleteEventHandler.createImplementation(\n    {\n        implementation: GenericFolderBeforeDeleteHandlerImpl,\n        dependencies: [EnsureFolderIsEmpty]\n    }\n);\n"],"names":["GenericFolderBeforeDeleteHandlerImpl","ensureFolderIsEmpty","event","folder","result","WebinyError","GenericFolderBeforeDeleteHandler","FolderBeforeDeleteEventHandler","EnsureFolderIsEmpty"],"mappings":";;;AAKA,MAAMA;IACF,YAAoBC,mBAAkD,CAAE;aAApDA,mBAAmB,GAAnBA;IAAqD;IAEzE,MAAM,OAAOC,KAA8B,EAAiB;QACxD,MAAM,EAAEC,MAAM,EAAE,GAAGD,MAAM,OAAO;QAEhC,MAAME,SAAS,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CACjDD,OAAO,IAAI,EACXA,OAAO,EAAE,EAGT,IAAM;QAGV,IAAIC,OAAO,MAAM,IACb,MAAMC,YAAY,IAAI,CAACD,OAAO,KAAK,EAAE;YACjC,SAAS;YACT,MAAM;QACV;IAER;AACJ;AAEO,MAAME,mCAAmCC,+BAA+B,oBAAoB,CAC/F;IACI,gBAAgBP;IAChB,cAAc;QAACQ;KAAoB;AACvC"}

package/features/folder/EnsureFolderIsEmptyOnDelete/feature.js

@@ -1,17 +1,11 @@
 import { createFeature } from "@webiny/feature/api";
 import { GenericFolderBeforeDeleteHandler } from "./GenericFolderBeforeDeleteHandler.js";
-
-/**
- * This feature checks whether a folder is allowed to be deleted.
- * This generic check simply checks if there are child folders within the given folder.
- * Actual content cannot be checked, as folders do not have information about their records.
- * Individual apps (like File Manager, Headless CMS, etc.) need to implement their own event handlers.
- */
-export const EnsureFolderIsEmptyOnDeleteFeature = createFeature({
-  name: "EnsureFolderIsEmptyOnDelete",
-  register(container) {
-    container.register(GenericFolderBeforeDeleteHandler);
-  }
+const EnsureFolderIsEmptyOnDeleteFeature = createFeature({
+    name: "EnsureFolderIsEmptyOnDelete",
+    register (container) {
+        container.register(GenericFolderBeforeDeleteHandler);
+    }
 });
+export { EnsureFolderIsEmptyOnDeleteFeature };
 
 //# sourceMappingURL=feature.js.map

package/features/folder/EnsureFolderIsEmptyOnDelete/feature.js.map

@@ -1 +1 @@
-{"version":3,"names":["createFeature","GenericFolderBeforeDeleteHandler","EnsureFolderIsEmptyOnDeleteFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GenericFolderBeforeDeleteHandler } from \"./GenericFolderBeforeDeleteHandler.js\";\n\n/**\n * This feature checks whether a folder is allowed to be deleted.\n * This generic check simply checks if there are child folders within the given folder.\n * Actual content cannot be checked, as folders do not have information about their records.\n * Individual apps (like File Manager, Headless CMS, etc.) need to implement their own event handlers.\n */\nexport const EnsureFolderIsEmptyOnDeleteFeature = createFeature({\n    name: \"EnsureFolderIsEmptyOnDelete\",\n    register(container) {\n        container.register(GenericFolderBeforeDeleteHandler);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,gCAAgC;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,kCAAkC,GAAGF,aAAa,CAAC;EAC5DG,IAAI,EAAE,6BAA6B;EACnCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,gCAAgC,CAAC;EACxD;AACJ,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/folder/EnsureFolderIsEmptyOnDelete/feature.js","sources":["../../../../src/features/folder/EnsureFolderIsEmptyOnDelete/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GenericFolderBeforeDeleteHandler } from \"./GenericFolderBeforeDeleteHandler.js\";\n\n/**\n * This feature checks whether a folder is allowed to be deleted.\n * This generic check simply checks if there are child folders within the given folder.\n * Actual content cannot be checked, as folders do not have information about their records.\n * Individual apps (like File Manager, Headless CMS, etc.) need to implement their own event handlers.\n */\nexport const EnsureFolderIsEmptyOnDeleteFeature = createFeature({\n    name: \"EnsureFolderIsEmptyOnDelete\",\n    register(container) {\n        container.register(GenericFolderBeforeDeleteHandler);\n    }\n});\n"],"names":["EnsureFolderIsEmptyOnDeleteFeature","createFeature","container","GenericFolderBeforeDeleteHandler"],"mappings":";;AASO,MAAMA,qCAAqCC,cAAc;IAC5D,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/folder/EnsureFolderIsEmptyOnDelete/index.js

@@ -1,3 +1 @@
 export { EnsureFolderIsEmptyOnDeleteFeature } from "./feature.js";
-
-//# sourceMappingURL=index.js.map

package/features/folder/EnsureHcmsFolderIsEmptyOnDelete/ModelFolderBeforeDeleteHandler.js

@@ -4,53 +4,45 @@ import { EnsureFolderIsEmpty } from "../EnsureFolderIsEmpty/abstractions.js";
 import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
 import { ListEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js";
 class ModelFolderBeforeDeleteHandlerImpl {
-  constructor(ensureFolderIsEmpty, getModel, listEntries) {
-    this.ensureFolderIsEmpty = ensureFolderIsEmpty;
-    this.getModel = getModel;
-    this.listEntries = listEntries;
-  }
-  async handle(event) {
-    const {
-      folder
-    } = event.payload;
-    const {
-      id,
-      type
-    } = folder;
-    const modelId = type.split(":")[1];
-    if (!modelId) {
-      return;
+    constructor(ensureFolderIsEmpty, getModel, listEntries){
+        this.ensureFolderIsEmpty = ensureFolderIsEmpty;
+        this.getModel = getModel;
+        this.listEntries = listEntries;
     }
-    const modelResult = await this.getModel.execute(modelId);
-    if (modelResult.isFail()) {
-      return;
+    async handle(event) {
+        const { folder } = event.payload;
+        const { id, type } = folder;
+        const modelId = type.split(":")[1];
+        if (!modelId) return;
+        const modelResult = await this.getModel.execute(modelId);
+        if (modelResult.isFail()) return;
+        const result = await this.ensureFolderIsEmpty.execute(type, id, async ()=>{
+            const result = await this.listEntries.execute(modelResult.value, {
+                where: {
+                    latest: true,
+                    wbyAco_location: {
+                        folderId: id
+                    }
+                },
+                limit: 1
+            });
+            const { entries } = result.value;
+            return entries.length > 0;
+        });
+        if (result.isFail()) throw WebinyError.from(result.error, {
+            message: "Error while ensuring HCMS folder is empty before delete.",
+            code: "ACO_BEFORE_FOLDER_DELETE_HCMS_HANDLER"
+        });
     }
-    const result = await this.ensureFolderIsEmpty.execute(type, id, async () => {
-      const result = await this.listEntries.execute(modelResult.value, {
-        where: {
-          latest: true,
-          wbyAco_location: {
-            folderId: id
-          }
-        },
-        limit: 1
-      });
-      const {
-        entries
-      } = result.value;
-      return entries.length > 0;
-    });
-    if (result.isFail()) {
-      throw WebinyError.from(result.error, {
-        message: "Error while ensuring HCMS folder is empty before delete.",
-        code: "ACO_BEFORE_FOLDER_DELETE_HCMS_HANDLER"
-      });
-    }
-  }
 }
-export const ModelFolderBeforeDeleteHandler = FolderBeforeDeleteEventHandler.createImplementation({
-  implementation: ModelFolderBeforeDeleteHandlerImpl,
-  dependencies: [EnsureFolderIsEmpty, GetModelUseCase, ListEntriesUseCase]
+const ModelFolderBeforeDeleteHandler = FolderBeforeDeleteEventHandler.createImplementation({
+    implementation: ModelFolderBeforeDeleteHandlerImpl,
+    dependencies: [
+        EnsureFolderIsEmpty,
+        GetModelUseCase,
+        ListEntriesUseCase
+    ]
 });
+export { ModelFolderBeforeDeleteHandler };
 
 //# sourceMappingURL=ModelFolderBeforeDeleteHandler.js.map

package/features/folder/EnsureHcmsFolderIsEmptyOnDelete/ModelFolderBeforeDeleteHandler.js.map

@@ -1 +1 @@
-{"version":3,"names":["WebinyError","FolderBeforeDeleteEventHandler","EnsureFolderIsEmpty","GetModelUseCase","ListEntriesUseCase","ModelFolderBeforeDeleteHandlerImpl","constructor","ensureFolderIsEmpty","getModel","listEntries","handle","event","folder","payload","id","type","modelId","split","modelResult","execute","isFail","result","value","where","latest","wbyAco_location","folderId","limit","entries","length","from","error","message","code","ModelFolderBeforeDeleteHandler","createImplementation","implementation","dependencies"],"sources":["ModelFolderBeforeDeleteHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { FolderBeforeDeleteEventHandler } from \"~/features/folder/DeleteFolder/abstractions.js\";\nimport type { FolderBeforeDeleteEvent } from \"~/features/folder/DeleteFolder/events.js\";\nimport { EnsureFolderIsEmpty } from \"~/features/folder/EnsureFolderIsEmpty/abstractions.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { ListEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js\";\n\nclass ModelFolderBeforeDeleteHandlerImpl implements FolderBeforeDeleteEventHandler.Interface {\n    constructor(\n        private ensureFolderIsEmpty: EnsureFolderIsEmpty.Interface,\n        private getModel: GetModelUseCase.Interface,\n        private listEntries: ListEntriesUseCase.Interface\n    ) {}\n\n    async handle(event: FolderBeforeDeleteEvent): Promise<void> {\n        const { folder } = event.payload;\n\n        const { id, type } = folder;\n\n        const modelId = type.split(\":\")[1];\n        if (!modelId) {\n            return;\n        }\n\n        const modelResult = await this.getModel.execute(modelId);\n        if (modelResult.isFail()) {\n            return;\n        }\n\n        const result = await this.ensureFolderIsEmpty.execute(type, id, async () => {\n            const result = await this.listEntries.execute(modelResult.value, {\n                where: {\n                    latest: true,\n                    wbyAco_location: {\n                        folderId: id\n                    }\n                },\n                limit: 1\n            });\n\n            const { entries } = result.value;\n\n            return entries.length > 0;\n        });\n\n        if (result.isFail()) {\n            throw WebinyError.from(result.error, {\n                message: \"Error while ensuring HCMS folder is empty before delete.\",\n                code: \"ACO_BEFORE_FOLDER_DELETE_HCMS_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const ModelFolderBeforeDeleteHandler = FolderBeforeDeleteEventHandler.createImplementation({\n    implementation: ModelFolderBeforeDeleteHandlerImpl,\n    dependencies: [EnsureFolderIsEmpty, GetModelUseCase, ListEntriesUseCase]\n});\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,eAAe;AAC3C,SAASC,8BAA8B;AAEvC,SAASC,mBAAmB;AAC5B,SAASC,eAAe,QAAQ,kEAAkE;AAClG,SAASC,kBAAkB,QAAQ,4EAA4E;AAE/G,MAAMC,kCAAkC,CAAqD;EACzFC,WAAWA,CACCC,mBAAkD,EAClDC,QAAmC,EACnCC,WAAyC,EACnD;IAAA,KAHUF,mBAAkD,GAAlDA,mBAAkD;IAAA,KAClDC,QAAmC,GAAnCA,QAAmC;IAAA,KACnCC,WAAyC,GAAzCA,WAAyC;EAClD;EAEH,MAAMC,MAAMA,CAACC,KAA8B,EAAiB;IACxD,MAAM;MAAEC;IAAO,CAAC,GAAGD,KAAK,CAACE,OAAO;IAEhC,MAAM;MAAEC,EAAE;MAAEC;IAAK,CAAC,GAAGH,MAAM;IAE3B,MAAMI,OAAO,GAAGD,IAAI,CAACE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAClC,IAAI,CAACD,OAAO,EAAE;MACV;IACJ;IAEA,MAAME,WAAW,GAAG,MAAM,IAAI,CAACV,QAAQ,CAACW,OAAO,CAACH,OAAO,CAAC;IACxD,IAAIE,WAAW,CAACE,MAAM,CAAC,CAAC,EAAE;MACtB;IACJ;IAEA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACd,mBAAmB,CAACY,OAAO,CAACJ,IAAI,EAAED,EAAE,EAAE,YAAY;MACxE,MAAMO,MAAM,GAAG,MAAM,IAAI,CAACZ,WAAW,CAACU,OAAO,CAACD,WAAW,CAACI,KAAK,EAAE;QAC7DC,KAAK,EAAE;UACHC,MAAM,EAAE,IAAI;UACZC,eAAe,EAAE;YACbC,QAAQ,EAAEZ;UACd;QACJ,CAAC;QACDa,KAAK,EAAE;MACX,CAAC,CAAC;MAEF,MAAM;QAAEC;MAAQ,CAAC,GAAGP,MAAM,CAACC,KAAK;MAEhC,OAAOM,OAAO,CAACC,MAAM,GAAG,CAAC;IAC7B,CAAC,CAAC;IAEF,IAAIR,MAAM,CAACD,MAAM,CAAC,CAAC,EAAE;MACjB,MAAMpB,WAAW,CAAC8B,IAAI,CAACT,MAAM,CAACU,KAAK,EAAE;QACjCC,OAAO,EAAE,0DAA0D;QACnEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,8BAA8B,GAAGjC,8BAA8B,CAACkC,oBAAoB,CAAC;EAC9FC,cAAc,EAAE/B,kCAAkC;EAClDgC,YAAY,EAAE,CAACnC,mBAAmB,EAAEC,eAAe,EAAEC,kBAAkB;AAC3E,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/folder/EnsureHcmsFolderIsEmptyOnDelete/ModelFolderBeforeDeleteHandler.js","sources":["../../../../src/features/folder/EnsureHcmsFolderIsEmptyOnDelete/ModelFolderBeforeDeleteHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { FolderBeforeDeleteEventHandler } from \"~/features/folder/DeleteFolder/abstractions.js\";\nimport type { FolderBeforeDeleteEvent } from \"~/features/folder/DeleteFolder/events.js\";\nimport { EnsureFolderIsEmpty } from \"~/features/folder/EnsureFolderIsEmpty/abstractions.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { ListEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js\";\n\nclass ModelFolderBeforeDeleteHandlerImpl implements FolderBeforeDeleteEventHandler.Interface {\n    constructor(\n        private ensureFolderIsEmpty: EnsureFolderIsEmpty.Interface,\n        private getModel: GetModelUseCase.Interface,\n        private listEntries: ListEntriesUseCase.Interface\n    ) {}\n\n    async handle(event: FolderBeforeDeleteEvent): Promise<void> {\n        const { folder } = event.payload;\n\n        const { id, type } = folder;\n\n        const modelId = type.split(\":\")[1];\n        if (!modelId) {\n            return;\n        }\n\n        const modelResult = await this.getModel.execute(modelId);\n        if (modelResult.isFail()) {\n            return;\n        }\n\n        const result = await this.ensureFolderIsEmpty.execute(type, id, async () => {\n            const result = await this.listEntries.execute(modelResult.value, {\n                where: {\n                    latest: true,\n                    wbyAco_location: {\n                        folderId: id\n                    }\n                },\n                limit: 1\n            });\n\n            const { entries } = result.value;\n\n            return entries.length > 0;\n        });\n\n        if (result.isFail()) {\n            throw WebinyError.from(result.error, {\n                message: \"Error while ensuring HCMS folder is empty before delete.\",\n                code: \"ACO_BEFORE_FOLDER_DELETE_HCMS_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const ModelFolderBeforeDeleteHandler = FolderBeforeDeleteEventHandler.createImplementation({\n    implementation: ModelFolderBeforeDeleteHandlerImpl,\n    dependencies: [EnsureFolderIsEmpty, GetModelUseCase, ListEntriesUseCase]\n});\n"],"names":["ModelFolderBeforeDeleteHandlerImpl","ensureFolderIsEmpty","getModel","listEntries","event","folder","id","type","modelId","modelResult","result","entries","WebinyError","ModelFolderBeforeDeleteHandler","FolderBeforeDeleteEventHandler","EnsureFolderIsEmpty","GetModelUseCase","ListEntriesUseCase"],"mappings":";;;;;AAOA,MAAMA;IACF,YACYC,mBAAkD,EAClDC,QAAmC,EACnCC,WAAyC,CACnD;aAHUF,mBAAmB,GAAnBA;aACAC,QAAQ,GAARA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,KAA8B,EAAiB;QACxD,MAAM,EAAEC,MAAM,EAAE,GAAGD,MAAM,OAAO;QAEhC,MAAM,EAAEE,EAAE,EAAEC,IAAI,EAAE,GAAGF;QAErB,MAAMG,UAAUD,KAAK,KAAK,CAAC,IAAI,CAAC,EAAE;QAClC,IAAI,CAACC,SACD;QAGJ,MAAMC,cAAc,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACD;QAChD,IAAIC,YAAY,MAAM,IAClB;QAGJ,MAAMC,SAAS,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAACH,MAAMD,IAAI;YAC5D,MAAMI,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAACD,YAAY,KAAK,EAAE;gBAC7D,OAAO;oBACH,QAAQ;oBACR,iBAAiB;wBACb,UAAUH;oBACd;gBACJ;gBACA,OAAO;YACX;YAEA,MAAM,EAAEK,OAAO,EAAE,GAAGD,OAAO,KAAK;YAEhC,OAAOC,QAAQ,MAAM,GAAG;QAC5B;QAEA,IAAID,OAAO,MAAM,IACb,MAAME,YAAY,IAAI,CAACF,OAAO,KAAK,EAAE;YACjC,SAAS;YACT,MAAM;QACV;IAER;AACJ;AAEO,MAAMG,iCAAiCC,+BAA+B,oBAAoB,CAAC;IAC9F,gBAAgBd;IAChB,cAAc;QAACe;QAAqBC;QAAiBC;KAAmB;AAC5E"}

package/features/folder/EnsureHcmsFolderIsEmptyOnDelete/feature.js

@@ -1,10 +1,11 @@
 import { createFeature } from "@webiny/feature/api";
 import { ModelFolderBeforeDeleteHandler } from "./ModelFolderBeforeDeleteHandler.js";
-export const EnsureHcmsFolderIsEmptyOnDeleteFeature = createFeature({
-  name: "EnsureHcmsFolderIsEmptyOnDelete",
-  register(container) {
-    container.register(ModelFolderBeforeDeleteHandler);
-  }
+const EnsureHcmsFolderIsEmptyOnDeleteFeature = createFeature({
+    name: "EnsureHcmsFolderIsEmptyOnDelete",
+    register (container) {
+        container.register(ModelFolderBeforeDeleteHandler);
+    }
 });
+export { EnsureHcmsFolderIsEmptyOnDeleteFeature };
 
 //# sourceMappingURL=feature.js.map

package/features/folder/EnsureHcmsFolderIsEmptyOnDelete/feature.js.map

@@ -1 +1 @@
-{"version":3,"names":["createFeature","ModelFolderBeforeDeleteHandler","EnsureHcmsFolderIsEmptyOnDeleteFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ModelFolderBeforeDeleteHandler } from \"./ModelFolderBeforeDeleteHandler.js\";\n\nexport const EnsureHcmsFolderIsEmptyOnDeleteFeature = createFeature({\n    name: \"EnsureHcmsFolderIsEmptyOnDelete\",\n    register(container) {\n        container.register(ModelFolderBeforeDeleteHandler);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,8BAA8B;AAEvC,OAAO,MAAMC,sCAAsC,GAAGF,aAAa,CAAC;EAChEG,IAAI,EAAE,iCAAiC;EACvCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,8BAA8B,CAAC;EACtD;AACJ,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/folder/EnsureHcmsFolderIsEmptyOnDelete/feature.js","sources":["../../../../src/features/folder/EnsureHcmsFolderIsEmptyOnDelete/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ModelFolderBeforeDeleteHandler } from \"./ModelFolderBeforeDeleteHandler.js\";\n\nexport const EnsureHcmsFolderIsEmptyOnDeleteFeature = createFeature({\n    name: \"EnsureHcmsFolderIsEmptyOnDelete\",\n    register(container) {\n        container.register(ModelFolderBeforeDeleteHandler);\n    }\n});\n"],"names":["EnsureHcmsFolderIsEmptyOnDeleteFeature","createFeature","container","ModelFolderBeforeDeleteHandler"],"mappings":";;AAGO,MAAMA,yCAAyCC,cAAc;IAChE,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/folder/EnsureHcmsFolderIsEmptyOnDelete/index.js

@@ -1,3 +1 @@
 export { EnsureHcmsFolderIsEmptyOnDeleteFeature } from "./feature.js";
-
-//# sourceMappingURL=index.js.map

package/features/folder/GetAncestors/GetAncestorsRepository.js

@@ -1,88 +1,58 @@
 import { Result } from "@webiny/feature/api";
-import { GetAncestorsRepository as RepositoryAbstraction } from "./abstractions.js";
+import { GetAncestorsRepository } from "./abstractions.js";
 import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
 import { FolderModel } from "../../../domain/folder/abstractions.js";
 import { EntryToFolderMapper } from "../shared/EntryToFolderMapper.js";
 import { FolderPersistenceError } from "../../../domain/folder/errors.js";
 import { ROOT_FOLDER } from "../../../constants.js";
 class GetAncestorsRepositoryImpl {
-  constructor(listLatestEntries, folderModel) {
-    this.listLatestEntries = listLatestEntries;
-    this.folderModel = folderModel;
-  }
-  async execute(params) {
-    const {
-      folder
-    } = params;
-
-    // No folder found: return an empty array
-    if (!folder) {
-      return Result.ok([]);
-    }
-
-    // The folder has no parent (it's at root level): return an array with the folder
-    if (!folder.parentId) {
-      return Result.ok([folder]);
+    constructor(listLatestEntries, folderModel){
+        this.listLatestEntries = listLatestEntries;
+        this.folderModel = folderModel;
     }
-
-    // Construct paths for all ancestors of the folder
-    const parts = folder.path.split("/").slice(1);
-    const paths = parts.map((_, index) => {
-      return [ROOT_FOLDER, ...parts.slice(0, index + 1)].join("/");
-    });
-
-    // Retrieve all folders that match the specified type and any of the constructed paths
-    const result = await this.listLatestEntries.execute(this.folderModel, {
-      where: {
-        values: {
-          type: folder.type,
-          path_in: paths
-        }
-      }
-    });
-    if (result.isFail()) {
-      return Result.fail(new FolderPersistenceError(result.error));
+    async execute(params) {
+        const { folder } = params;
+        if (!folder) return Result.ok([]);
+        if (!folder.parentId) return Result.ok([
+            folder
+        ]);
+        const parts = folder.path.split("/").slice(1);
+        const paths = parts.map((_, index)=>[
+                ROOT_FOLDER,
+                ...parts.slice(0, index + 1)
+            ].join("/"));
+        const result = await this.listLatestEntries.execute(this.folderModel, {
+            where: {
+                values: {
+                    type: folder.type,
+                    path_in: paths
+                }
+            }
+        });
+        if (result.isFail()) return Result.fail(new FolderPersistenceError(result.error));
+        const { entries } = result.value;
+        const folders = entries.map((entry)=>EntryToFolderMapper.toFolder(entry));
+        const folderMap = new Map();
+        folders.forEach((f)=>folderMap.set(f.id, f));
+        const findParents = (next, current)=>{
+            if (!current) return next;
+            next.push(current);
+            if (!current.parentId) return next;
+            const parent = folderMap.get(current.parentId);
+            if (!parent) return next;
+            return findParents(next, parent);
+        };
+        const ancestors = findParents([], folder);
+        return Result.ok(ancestors);
     }
-    const {
-      entries
-    } = result.value;
-    const folders = entries.map(entry => EntryToFolderMapper.toFolder(entry));
-
-    // Create a Map with folders, using folder.id as key
-    const folderMap = new Map();
-    folders.forEach(f => folderMap.set(f.id, f));
-    const findParents = (next, current) => {
-      // No folder found: return the result
-      if (!current) {
-        return next;
-      }
-
-      // Push the current folder into the accumulator array
-      next.push(current);
-
-      // No parentId found: return the result
-      if (!current.parentId) {
-        return next;
-      }
-      const parent = folderMap.get(current.parentId);
-
-      // No parent found: return the result
-      if (!parent) {
-        return next;
-      }
-
-      // Go ahead and find parent for the current parent
-      return findParents(next, parent);
-    };
-
-    // Recursively find parents for a given folder id
-    const ancestors = findParents([], folder);
-    return Result.ok(ancestors);
-  }
 }
-export const GetAncestorsRepository = RepositoryAbstraction.createImplementation({
-  implementation: GetAncestorsRepositoryImpl,
-  dependencies: [ListLatestEntriesUseCase, FolderModel]
+const GetAncestorsRepository_GetAncestorsRepository = GetAncestorsRepository.createImplementation({
+    implementation: GetAncestorsRepositoryImpl,
+    dependencies: [
+        ListLatestEntriesUseCase,
+        FolderModel
+    ]
 });
+export { GetAncestorsRepository_GetAncestorsRepository as GetAncestorsRepository };
 
 //# sourceMappingURL=GetAncestorsRepository.js.map

package/features/folder/GetAncestors/GetAncestorsRepository.js.map

@@ -1 +1 @@
-{"version":3,"names":["Result","GetAncestorsRepository","RepositoryAbstraction","ListLatestEntriesUseCase","FolderModel","EntryToFolderMapper","FolderPersistenceError","ROOT_FOLDER","GetAncestorsRepositoryImpl","constructor","listLatestEntries","folderModel","execute","params","folder","ok","parentId","parts","path","split","slice","paths","map","_","index","join","result","where","values","type","path_in","isFail","fail","error","entries","value","folders","entry","toFolder","folderMap","Map","forEach","f","set","id","findParents","next","current","push","parent","get","ancestors","createImplementation","implementation","dependencies"],"sources":["GetAncestorsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    type GetAncestorsParams,\n    GetAncestorsRepository as RepositoryAbstraction,\n    type IGetAncestorsRepository\n} from \"./abstractions.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { FolderModel } from \"~/domain/folder/abstractions.js\";\nimport type { CmsEntryFolder, Folder } from \"~/folder/folder.types.js\";\nimport { EntryToFolderMapper } from \"../shared/EntryToFolderMapper.js\";\nimport { FolderPersistenceError } from \"~/domain/folder/errors.js\";\nimport { ROOT_FOLDER } from \"~/constants.js\";\n\nclass GetAncestorsRepositoryImpl implements IGetAncestorsRepository {\n    constructor(\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private folderModel: FolderModel.Interface\n    ) {}\n\n    async execute(\n        params: GetAncestorsParams\n    ): Promise<Result<Folder[], RepositoryAbstraction.Error>> {\n        const { folder } = params;\n\n        // No folder found: return an empty array\n        if (!folder) {\n            return Result.ok([]);\n        }\n\n        // The folder has no parent (it's at root level): return an array with the folder\n        if (!folder.parentId) {\n            return Result.ok([folder]);\n        }\n\n        // Construct paths for all ancestors of the folder\n        const parts = folder.path.split(\"/\").slice(1);\n        const paths = parts.map((_, index) => {\n            return [ROOT_FOLDER, ...parts.slice(0, index + 1)].join(\"/\");\n        });\n\n        // Retrieve all folders that match the specified type and any of the constructed paths\n        const result = await this.listLatestEntries.execute<CmsEntryFolder>(this.folderModel, {\n            where: {\n                values: {\n                    type: folder.type,\n                    path_in: paths\n                }\n            }\n        });\n\n        if (result.isFail()) {\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const { entries } = result.value;\n        const folders = entries.map(entry => EntryToFolderMapper.toFolder(entry));\n\n        // Create a Map with folders, using folder.id as key\n        const folderMap = new Map<string, Folder>();\n        folders.forEach(f => folderMap.set(f.id, f));\n\n        const findParents = (next: Folder[], current: Folder): Folder[] => {\n            // No folder found: return the result\n            if (!current) {\n                return next;\n            }\n\n            // Push the current folder into the accumulator array\n            next.push(current);\n\n            // No parentId found: return the result\n            if (!current.parentId) {\n                return next;\n            }\n\n            const parent = folderMap.get(current.parentId);\n\n            // No parent found: return the result\n            if (!parent) {\n                return next;\n            }\n\n            // Go ahead and find parent for the current parent\n            return findParents(next, parent);\n        };\n\n        // Recursively find parents for a given folder id\n        const ancestors = findParents([], folder);\n        return Result.ok(ancestors);\n    }\n}\n\nexport const GetAncestorsRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetAncestorsRepositoryImpl,\n    dependencies: [ListLatestEntriesUseCase, FolderModel]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAEIC,sBAAsB,IAAIC,qBAAqB;AAGnD,SAASC,wBAAwB,QAAQ,4DAA4D;AACrG,SAASC,WAAW;AAEpB,SAASC,mBAAmB;AAC5B,SAASC,sBAAsB;AAC/B,SAASC,WAAW;AAEpB,MAAMC,0BAA0B,CAAoC;EAChEC,WAAWA,CACCC,iBAAqD,EACrDC,WAAkC,EAC5C;IAAA,KAFUD,iBAAqD,GAArDA,iBAAqD;IAAA,KACrDC,WAAkC,GAAlCA,WAAkC;EAC3C;EAEH,MAAMC,OAAOA,CACTC,MAA0B,EAC4B;IACtD,MAAM;MAAEC;IAAO,CAAC,GAAGD,MAAM;;IAEzB;IACA,IAAI,CAACC,MAAM,EAAE;MACT,OAAOd,MAAM,CAACe,EAAE,CAAC,EAAE,CAAC;IACxB;;IAEA;IACA,IAAI,CAACD,MAAM,CAACE,QAAQ,EAAE;MAClB,OAAOhB,MAAM,CAACe,EAAE,CAAC,CAACD,MAAM,CAAC,CAAC;IAC9B;;IAEA;IACA,MAAMG,KAAK,GAAGH,MAAM,CAACI,IAAI,CAACC,KAAK,CAAC,GAAG,CAAC,CAACC,KAAK,CAAC,CAAC,CAAC;IAC7C,MAAMC,KAAK,GAAGJ,KAAK,CAACK,GAAG,CAAC,CAACC,CAAC,EAAEC,KAAK,KAAK;MAClC,OAAO,CAACjB,WAAW,EAAE,GAAGU,KAAK,CAACG,KAAK,CAAC,CAAC,EAAEI,KAAK,GAAG,CAAC,CAAC,CAAC,CAACC,IAAI,CAAC,GAAG,CAAC;IAChE,CAAC,CAAC;;IAEF;IACA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAAChB,iBAAiB,CAACE,OAAO,CAAiB,IAAI,CAACD,WAAW,EAAE;MAClFgB,KAAK,EAAE;QACHC,MAAM,EAAE;UACJC,IAAI,EAAEf,MAAM,CAACe,IAAI;UACjBC,OAAO,EAAET;QACb;MACJ;IACJ,CAAC,CAAC;IAEF,IAAIK,MAAM,CAACK,MAAM,CAAC,CAAC,EAAE;MACjB,OAAO/B,MAAM,CAACgC,IAAI,CAAC,IAAI1B,sBAAsB,CAACoB,MAAM,CAACO,KAAK,CAAC,CAAC;IAChE;IAEA,MAAM;MAAEC;IAAQ,CAAC,GAAGR,MAAM,CAACS,KAAK;IAChC,MAAMC,OAAO,GAAGF,OAAO,CAACZ,GAAG,CAACe,KAAK,IAAIhC,mBAAmB,CAACiC,QAAQ,CAACD,KAAK,CAAC,CAAC;;IAEzE;IACA,MAAME,SAAS,GAAG,IAAIC,GAAG,CAAiB,CAAC;IAC3CJ,OAAO,CAACK,OAAO,CAACC,CAAC,IAAIH,SAAS,CAACI,GAAG,CAACD,CAAC,CAACE,EAAE,EAAEF,CAAC,CAAC,CAAC;IAE5C,MAAMG,WAAW,GAAGA,CAACC,IAAc,EAAEC,OAAe,KAAe;MAC/D;MACA,IAAI,CAACA,OAAO,EAAE;QACV,OAAOD,IAAI;MACf;;MAEA;MACAA,IAAI,CAACE,IAAI,CAACD,OAAO,CAAC;;MAElB;MACA,IAAI,CAACA,OAAO,CAAC/B,QAAQ,EAAE;QACnB,OAAO8B,IAAI;MACf;MAEA,MAAMG,MAAM,GAAGV,SAAS,CAACW,GAAG,CAACH,OAAO,CAAC/B,QAAQ,CAAC;;MAE9C;MACA,IAAI,CAACiC,MAAM,EAAE;QACT,OAAOH,IAAI;MACf;;MAEA;MACA,OAAOD,WAAW,CAACC,IAAI,EAAEG,MAAM,CAAC;IACpC,CAAC;;IAED;IACA,MAAME,SAAS,GAAGN,WAAW,CAAC,EAAE,EAAE/B,MAAM,CAAC;IACzC,OAAOd,MAAM,CAACe,EAAE,CAACoC,SAAS,CAAC;EAC/B;AACJ;AAEA,OAAO,MAAMlD,sBAAsB,GAAGC,qBAAqB,CAACkD,oBAAoB,CAAC;EAC7EC,cAAc,EAAE7C,0BAA0B;EAC1C8C,YAAY,EAAE,CAACnD,wBAAwB,EAAEC,WAAW;AACxD,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/folder/GetAncestors/GetAncestorsRepository.js","sources":["../../../../src/features/folder/GetAncestors/GetAncestorsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    type GetAncestorsParams,\n    GetAncestorsRepository as RepositoryAbstraction,\n    type IGetAncestorsRepository\n} from \"./abstractions.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { FolderModel } from \"~/domain/folder/abstractions.js\";\nimport type { CmsEntryFolder, Folder } from \"~/folder/folder.types.js\";\nimport { EntryToFolderMapper } from \"../shared/EntryToFolderMapper.js\";\nimport { FolderPersistenceError } from \"~/domain/folder/errors.js\";\nimport { ROOT_FOLDER } from \"~/constants.js\";\n\nclass GetAncestorsRepositoryImpl implements IGetAncestorsRepository {\n    constructor(\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private folderModel: FolderModel.Interface\n    ) {}\n\n    async execute(\n        params: GetAncestorsParams\n    ): Promise<Result<Folder[], RepositoryAbstraction.Error>> {\n        const { folder } = params;\n\n        // No folder found: return an empty array\n        if (!folder) {\n            return Result.ok([]);\n        }\n\n        // The folder has no parent (it's at root level): return an array with the folder\n        if (!folder.parentId) {\n            return Result.ok([folder]);\n        }\n\n        // Construct paths for all ancestors of the folder\n        const parts = folder.path.split(\"/\").slice(1);\n        const paths = parts.map((_, index) => {\n            return [ROOT_FOLDER, ...parts.slice(0, index + 1)].join(\"/\");\n        });\n\n        // Retrieve all folders that match the specified type and any of the constructed paths\n        const result = await this.listLatestEntries.execute<CmsEntryFolder>(this.folderModel, {\n            where: {\n                values: {\n                    type: folder.type,\n                    path_in: paths\n                }\n            }\n        });\n\n        if (result.isFail()) {\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const { entries } = result.value;\n        const folders = entries.map(entry => EntryToFolderMapper.toFolder(entry));\n\n        // Create a Map with folders, using folder.id as key\n        const folderMap = new Map<string, Folder>();\n        folders.forEach(f => folderMap.set(f.id, f));\n\n        const findParents = (next: Folder[], current: Folder): Folder[] => {\n            // No folder found: return the result\n            if (!current) {\n                return next;\n            }\n\n            // Push the current folder into the accumulator array\n            next.push(current);\n\n            // No parentId found: return the result\n            if (!current.parentId) {\n                return next;\n            }\n\n            const parent = folderMap.get(current.parentId);\n\n            // No parent found: return the result\n            if (!parent) {\n                return next;\n            }\n\n            // Go ahead and find parent for the current parent\n            return findParents(next, parent);\n        };\n\n        // Recursively find parents for a given folder id\n        const ancestors = findParents([], folder);\n        return Result.ok(ancestors);\n    }\n}\n\nexport const GetAncestorsRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetAncestorsRepositoryImpl,\n    dependencies: [ListLatestEntriesUseCase, FolderModel]\n});\n"],"names":["GetAncestorsRepositoryImpl","listLatestEntries","folderModel","params","folder","Result","parts","paths","_","index","ROOT_FOLDER","result","FolderPersistenceError","entries","folders","entry","EntryToFolderMapper","folderMap","Map","f","findParents","next","current","parent","ancestors","GetAncestorsRepository","RepositoryAbstraction","ListLatestEntriesUseCase","FolderModel"],"mappings":";;;;;;;AAaA,MAAMA;IACF,YACYC,iBAAqD,EACrDC,WAAkC,CAC5C;aAFUD,iBAAiB,GAAjBA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,QACFC,MAA0B,EAC4B;QACtD,MAAM,EAAEC,MAAM,EAAE,GAAGD;QAGnB,IAAI,CAACC,QACD,OAAOC,OAAO,EAAE,CAAC,EAAE;QAIvB,IAAI,CAACD,OAAO,QAAQ,EAChB,OAAOC,OAAO,EAAE,CAAC;YAACD;SAAO;QAI7B,MAAME,QAAQF,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;QAC3C,MAAMG,QAAQD,MAAM,GAAG,CAAC,CAACE,GAAGC,QACjB;gBAACC;mBAAgBJ,MAAM,KAAK,CAAC,GAAGG,QAAQ;aAAG,CAAC,IAAI,CAAC;QAI5D,MAAME,SAAS,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAiB,IAAI,CAAC,WAAW,EAAE;YAClF,OAAO;gBACH,QAAQ;oBACJ,MAAMP,OAAO,IAAI;oBACjB,SAASG;gBACb;YACJ;QACJ;QAEA,IAAII,OAAO,MAAM,IACb,OAAON,OAAO,IAAI,CAAC,IAAIO,uBAAuBD,OAAO,KAAK;QAG9D,MAAM,EAAEE,OAAO,EAAE,GAAGF,OAAO,KAAK;QAChC,MAAMG,UAAUD,QAAQ,GAAG,CAACE,CAAAA,QAASC,oBAAoB,QAAQ,CAACD;QAGlE,MAAME,YAAY,IAAIC;QACtBJ,QAAQ,OAAO,CAACK,CAAAA,IAAKF,UAAU,GAAG,CAACE,EAAE,EAAE,EAAEA;QAEzC,MAAMC,cAAc,CAACC,MAAgBC;YAEjC,IAAI,CAACA,SACD,OAAOD;YAIXA,KAAK,IAAI,CAACC;YAGV,IAAI,CAACA,QAAQ,QAAQ,EACjB,OAAOD;YAGX,MAAME,SAASN,UAAU,GAAG,CAACK,QAAQ,QAAQ;YAG7C,IAAI,CAACC,QACD,OAAOF;YAIX,OAAOD,YAAYC,MAAME;QAC7B;QAGA,MAAMC,YAAYJ,YAAY,EAAE,EAAEhB;QAClC,OAAOC,OAAO,EAAE,CAACmB;IACrB;AACJ;AAEO,MAAMC,gDAAyBC,uBAAAA,oBAA0C,CAAC;IAC7E,gBAAgB1B;IAChB,cAAc;QAAC2B;QAA0BC;KAAY;AACzD"}