@webiny/api-headless-cms 0.0.0-unstable.e622468070 → 0.0.0-unstable.e6f0dc8ca7

package/features/storage/fields/DynamicZoneStorageTransform.d.ts

@@ -0,0 +1,10 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+declare class DynamicZoneStorageTransformImpl implements StorageTransform.Interface {
+    readonly fieldType = "dynamicZone";
+    toStorage(params: StorageTransform.ToStorageParams): StorageTransform.ToStorageResponse;
+    fromStorage(params: StorageTransform.FromStorageParams): StorageTransform.FromStorageResponse;
+}
+export declare const DynamicZoneStorageTransform: typeof DynamicZoneStorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};

package/features/storage/fields/DynamicZoneStorageTransform.js

@@ -0,0 +1,142 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import pReduce from "p-reduce";
+const processToStorage = async params => {
+  const {
+    model,
+    field: parentField,
+    value: input,
+    getStorageTransform
+  } = params;
+  const output = structuredClone(input);
+  if (!output._templateId) {
+    return output;
+  }
+  const template = parentField.settings.templates.find(t => t.id === output._templateId);
+  if (!template || !template.fields.length) {
+    return output;
+  }
+  return await pReduce(template.fields, async (values, field) => {
+    const value = values[field.fieldId];
+    if (!value) {
+      values[field.fieldId] = value;
+      return values;
+    }
+    const storageTransform = getStorageTransform(field.type);
+    if (!storageTransform) {
+      console.error(`Missing storage transform for field type "${field.type}".`);
+      delete values[field.fieldId];
+      return values;
+    }
+    values[field.fieldId] = await storageTransform.toStorage({
+      getStorageTransform,
+      model,
+      field,
+      value
+    });
+    return values;
+  }, output);
+};
+const processFromStorage = async params => {
+  const {
+    model,
+    field: parentField,
+    value: input,
+    getStorageTransform
+  } = params;
+  const output = structuredClone(input);
+  if (!output._templateId) {
+    return output;
+  }
+  const template = parentField.settings.templates.find(t => t.id === output._templateId);
+  if (!template || !template.fields.length) {
+    return output;
+  }
+  return await pReduce(template.fields, async (values, field) => {
+    const value = values[field.fieldId];
+    if (!value) {
+      return values;
+    }
+    const storageTransform = getStorageTransform(field.type);
+    if (!storageTransform) {
+      console.error(`Missing storage transform for field type "${field.type}".`);
+      delete values[field.fieldId];
+      return values;
+    }
+    values[field.fieldId] = await storageTransform.fromStorage({
+      getStorageTransform,
+      model,
+      field,
+      value
+    });
+    return values;
+  }, output);
+};
+class DynamicZoneStorageTransformImpl {
+  fieldType = "dynamicZone";
+  async toStorage(params) {
+    const {
+      value: input,
+      field,
+      model,
+      getStorageTransform
+    } = params;
+    if (!input) {
+      return input;
+    } else if (field.list) {
+      if (!Array.isArray(input)) {
+        return input;
+      }
+      const values = input;
+      return Promise.all(values.map(async value => {
+        return await processToStorage({
+          model,
+          field: field,
+          value,
+          getStorageTransform
+        });
+      }));
+    }
+    return await processToStorage({
+      model,
+      field: field,
+      value: input,
+      getStorageTransform
+    });
+  }
+  async fromStorage(params) {
+    const {
+      value: input,
+      field,
+      model,
+      getStorageTransform
+    } = params;
+    if (!input) {
+      return input;
+    } else if (field.list) {
+      if (!Array.isArray(input)) {
+        return input;
+      }
+      const values = input;
+      return await Promise.all(values.map(async value => {
+        return await processFromStorage({
+          model,
+          field: field,
+          value,
+          getStorageTransform
+        });
+      }));
+    }
+    return await processFromStorage({
+      model,
+      field: field,
+      value: input,
+      getStorageTransform
+    });
+  }
+}
+export const DynamicZoneStorageTransform = StorageTransform.createImplementation({
+  implementation: DynamicZoneStorageTransformImpl,
+  dependencies: []
+});
+
+//# sourceMappingURL=DynamicZoneStorageTransform.js.map

package/features/storage/fields/DynamicZoneStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["StorageTransform","pReduce","processToStorage","params","model","field","parentField","value","input","getStorageTransform","output","structuredClone","_templateId","template","settings","templates","find","t","id","fields","length","values","fieldId","storageTransform","type","console","error","toStorage","processFromStorage","fromStorage","DynamicZoneStorageTransformImpl","fieldType","list","Array","isArray","Promise","all","map","DynamicZoneStorageTransform","createImplementation","implementation","dependencies"],"sources":["DynamicZoneStorageTransform.ts"],"sourcesContent":["import { StorageTransform } from \"../abstractions/StorageTransform.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport type { CmsModel, CmsModelDynamicZoneField } from \"~/types/index.js\";\nimport pReduce from \"p-reduce\";\n\ninterface IProcessParams {\n    model: CmsModel;\n    field: CmsModelDynamicZoneField;\n    value: GenericRecord;\n    getStorageTransform: (fieldType: string) => StorageTransform.Interface;\n}\n\nconst processToStorage = async (params: IProcessParams): Promise<GenericRecord> => {\n    const { model, field: parentField, value: input, getStorageTransform } = params;\n\n    const output: GenericRecord = structuredClone(input);\n\n    if (!output._templateId) {\n        return output;\n    }\n    const template = parentField.settings.templates.find(t => t.id === output._templateId);\n    if (!template || !template.fields.length) {\n        return output;\n    }\n\n    return await pReduce(\n        template.fields,\n        async (values, field) => {\n            const value = values[field.fieldId];\n\n            if (!value) {\n                values[field.fieldId] = value;\n                return values;\n            }\n            const storageTransform = getStorageTransform(field.type);\n            if (!storageTransform) {\n                console.error(`Missing storage transform for field type \"${field.type}\".`);\n                delete values[field.fieldId];\n                return values;\n            }\n            values[field.fieldId] = await storageTransform.toStorage({\n                getStorageTransform,\n                model,\n                field,\n                value\n            });\n\n            return values;\n        },\n        output\n    );\n};\n\nconst processFromStorage = async (params: IProcessParams): Promise<GenericRecord> => {\n    const { model, field: parentField, value: input, getStorageTransform } = params;\n\n    const output: GenericRecord = structuredClone(input);\n\n    if (!output._templateId) {\n        return output;\n    }\n    const template = parentField.settings.templates.find(t => t.id === output._templateId);\n    if (!template || !template.fields.length) {\n        return output;\n    }\n\n    return await pReduce(\n        template.fields,\n        async (values, field) => {\n            const value = values[field.fieldId];\n\n            if (!value) {\n                return values;\n            }\n            const storageTransform = getStorageTransform(field.type);\n            if (!storageTransform) {\n                console.error(`Missing storage transform for field type \"${field.type}\".`);\n                delete values[field.fieldId];\n                return values;\n            }\n            values[field.fieldId] = await storageTransform.fromStorage({\n                getStorageTransform,\n                model,\n                field,\n                value\n            });\n\n            return values;\n        },\n        output\n    );\n};\n\nclass DynamicZoneStorageTransformImpl implements StorageTransform.Interface {\n    public readonly fieldType = \"dynamicZone\";\n\n    public async toStorage(\n        params: StorageTransform.ToStorageParams\n    ): StorageTransform.ToStorageResponse {\n        const { value: input, field, model, getStorageTransform } = params;\n        if (!input) {\n            return input;\n        } else if (field.list) {\n            if (!Array.isArray(input)) {\n                return input;\n            }\n            const values = input as GenericRecord[];\n            return Promise.all(\n                values.map(async value => {\n                    return await processToStorage({\n                        model,\n                        field: field as CmsModelDynamicZoneField,\n                        value,\n                        getStorageTransform\n                    });\n                })\n            );\n        }\n        return await processToStorage({\n            model,\n            field: field as CmsModelDynamicZoneField,\n            value: input,\n            getStorageTransform\n        });\n    }\n\n    public async fromStorage(\n        params: StorageTransform.FromStorageParams\n    ): StorageTransform.FromStorageResponse {\n        const { value: input, field, model, getStorageTransform } = params;\n        if (!input) {\n            return input;\n        } else if (field.list) {\n            if (!Array.isArray(input)) {\n                return input;\n            }\n            const values = input as GenericRecord[];\n\n            return await Promise.all(\n                values.map(async value => {\n                    return await processFromStorage({\n                        model,\n                        field: field as CmsModelDynamicZoneField,\n                        value,\n                        getStorageTransform\n                    });\n                })\n            );\n        }\n        return await processFromStorage({\n            model,\n            field: field as CmsModelDynamicZoneField,\n            value: input,\n            getStorageTransform\n        });\n    }\n}\n\nexport const DynamicZoneStorageTransform = StorageTransform.createImplementation({\n    implementation: DynamicZoneStorageTransformImpl,\n    dependencies: []\n});\n"],"mappings":"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","ignoreList":[]}

package/features/storage/fields/JsonStorageTransform.d.ts

@@ -0,0 +1,13 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+declare class JsonStorageTransformImpl implements StorageTransform.Interface {
+    private readonly compressorHandler;
+    fieldType: string;
+    constructor(compressorHandler: CompressionHandler.Interface);
+    fromStorage({ field, value }: StorageTransform.FromStorageParams): StorageTransform.FromStorageResponse;
+    toStorage({ value }: StorageTransform.ToStorageParams): StorageTransform.ToStorageResponse;
+}
+export declare const JsonStorageTransform: typeof JsonStorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};

package/features/storage/fields/JsonStorageTransform.js

@@ -0,0 +1,31 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { WebinyError } from "@webiny/error";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+class JsonStorageTransformImpl {
+  fieldType = "json";
+  constructor(compressorHandler) {
+    this.compressorHandler = compressorHandler;
+  }
+  async fromStorage({
+    field,
+    value
+  }) {
+    if (!value) {
+      return value;
+    } else if (typeof value !== "object") {
+      throw new WebinyError(`JSON value received in "fromStorage" function is not an object in field "${field.storageId}" - ${field.fieldId}.`);
+    }
+    return await this.compressorHandler.decompress(value);
+  }
+  async toStorage({
+    value
+  }) {
+    return await this.compressorHandler.compress(value);
+  }
+}
+export const JsonStorageTransform = StorageTransform.createImplementation({
+  implementation: JsonStorageTransformImpl,
+  dependencies: [CompressionHandler]
+});
+
+//# sourceMappingURL=JsonStorageTransform.js.map

package/features/storage/fields/JsonStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["StorageTransform","WebinyError","CompressionHandler","JsonStorageTransformImpl","fieldType","constructor","compressorHandler","fromStorage","field","value","storageId","fieldId","decompress","toStorage","compress","JsonStorageTransform","createImplementation","implementation","dependencies"],"sources":["JsonStorageTransform.ts"],"sourcesContent":["import { StorageTransform } from \"../abstractions/StorageTransform.js\";\nimport { WebinyError } from \"@webiny/error\";\nimport { CompressionHandler } from \"@webiny/utils/exports/api.js\";\n\nclass JsonStorageTransformImpl implements StorageTransform.Interface {\n    public fieldType = \"json\";\n\n    public constructor(private readonly compressorHandler: CompressionHandler.Interface) {}\n\n    public async fromStorage({\n        field,\n        value\n    }: StorageTransform.FromStorageParams): StorageTransform.FromStorageResponse {\n        if (!value) {\n            return value;\n        } else if (typeof value !== \"object\") {\n            throw new WebinyError(\n                `JSON value received in \"fromStorage\" function is not an object in field \"${field.storageId}\" - ${field.fieldId}.`\n            );\n        }\n\n        return await this.compressorHandler.decompress(value);\n    }\n\n    public async toStorage({\n        value\n    }: StorageTransform.ToStorageParams): StorageTransform.ToStorageResponse {\n        return await this.compressorHandler.compress(value);\n    }\n}\n\nexport const JsonStorageTransform = StorageTransform.createImplementation({\n    implementation: JsonStorageTransformImpl,\n    dependencies: [CompressionHandler]\n});\n"],"mappings":"AAAA,SAASA,gBAAgB;AACzB,SAASC,WAAW,QAAQ,eAAe;AAC3C,SAASC,kBAAkB,QAAQ,8BAA8B;AAEjE,MAAMC,wBAAwB,CAAuC;EAC1DC,SAAS,GAAG,MAAM;EAElBC,WAAWA,CAAkBC,iBAA+C,EAAE;IAAA,KAAjDA,iBAA+C,GAA/CA,iBAA+C;EAAG;EAEtF,MAAaC,WAAWA,CAAC;IACrBC,KAAK;IACLC;EACgC,CAAC,EAAwC;IACzE,IAAI,CAACA,KAAK,EAAE;MACR,OAAOA,KAAK;IAChB,CAAC,MAAM,IAAI,OAAOA,KAAK,KAAK,QAAQ,EAAE;MAClC,MAAM,IAAIR,WAAW,CACjB,4EAA4EO,KAAK,CAACE,SAAS,OAAOF,KAAK,CAACG,OAAO,GACnH,CAAC;IACL;IAEA,OAAO,MAAM,IAAI,CAACL,iBAAiB,CAACM,UAAU,CAACH,KAAK,CAAC;EACzD;EAEA,MAAaI,SAASA,CAAC;IACnBJ;EAC8B,CAAC,EAAsC;IACrE,OAAO,MAAM,IAAI,CAACH,iBAAiB,CAACQ,QAAQ,CAACL,KAAK,CAAC;EACvD;AACJ;AAEA,OAAO,MAAMM,oBAAoB,GAAGf,gBAAgB,CAACgB,oBAAoB,CAAC;EACtEC,cAAc,EAAEd,wBAAwB;EACxCe,YAAY,EAAE,CAAChB,kBAAkB;AACrC,CAAC,CAAC","ignoreList":[]}

package/features/storage/fields/LongTextStorageTransform.d.ts

@@ -0,0 +1,18 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+interface StorageValue {
+    compression: string;
+    value: string;
+    isArray?: boolean;
+}
+declare class LongTextStorageTransformImpl implements StorageTransform.Interface<string | string[], StorageValue> {
+    private readonly compressionHandler;
+    readonly fieldType = "long-text";
+    constructor(compressionHandler: CompressionHandler.Interface);
+    fromStorage({ field, value: storageValue }: StorageTransform.FromStorageParams<string | string[], StorageValue>): StorageTransform.FromStorageResponse<string | string[]>;
+    toStorage({ value: initialValue }: StorageTransform.ToStorageParams<string | string[], StorageValue>): StorageTransform.ToStorageResponse<StorageValue>;
+}
+export declare const LongTextStorageTransform: typeof LongTextStorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};

package/features/storage/fields/LongTextStorageTransform.js

@@ -0,0 +1,55 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { WebinyError } from "@webiny/error";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+class LongTextStorageTransformImpl {
+  fieldType = "long-text";
+  constructor(compressionHandler) {
+    this.compressionHandler = compressionHandler;
+  }
+  async fromStorage({
+    field,
+    value: storageValue
+  }) {
+    const typeOf = typeof storageValue;
+    if (!storageValue || typeOf === "string" || typeOf === "number" || Array.isArray(storageValue) === true) {
+      return storageValue;
+    } else if (typeOf !== "object") {
+      throw new WebinyError(`LongText value received in "fromStorage" function is not an object in field "${field.storageId}" - ${field.fieldId}.`);
+    }
+    try {
+      const sv = storageValue;
+      const result = await this.compressionHandler.decompress(storageValue);
+      if (!sv.isArray) {
+        return result;
+      }
+      return JSON.parse(result);
+    } catch (ex) {
+      console.log("Error while transforming long-text.");
+      console.log(ex.message);
+      return "";
+    }
+  }
+  async toStorage({
+    value: initialValue
+  }) {
+    if (initialValue && initialValue.compression) {
+      return initialValue;
+    }
+    const isArray = Array.isArray(initialValue);
+    const value = isArray ? JSON.stringify(initialValue) : initialValue;
+    const compressed = await this.compressionHandler.compress(value);
+    if (!isArray) {
+      return compressed;
+    }
+    return {
+      ...compressed,
+      isArray
+    };
+  }
+}
+export const LongTextStorageTransform = StorageTransform.createImplementation({
+  implementation: LongTextStorageTransformImpl,
+  dependencies: [CompressionHandler]
+});
+
+//# sourceMappingURL=LongTextStorageTransform.js.map

package/features/storage/fields/LongTextStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["StorageTransform","WebinyError","CompressionHandler","LongTextStorageTransformImpl","fieldType","constructor","compressionHandler","fromStorage","field","value","storageValue","typeOf","Array","isArray","storageId","fieldId","sv","result","decompress","JSON","parse","ex","console","log","message","toStorage","initialValue","compression","stringify","compressed","compress","LongTextStorageTransform","createImplementation","implementation","dependencies"],"sources":["LongTextStorageTransform.ts"],"sourcesContent":["import { StorageTransform } from \"../abstractions/StorageTransform.js\";\nimport { WebinyError } from \"@webiny/error\";\nimport { CompressionHandler } from \"@webiny/utils/exports/api.js\";\n\ninterface StorageValue {\n    compression: string;\n    value: string;\n    isArray?: boolean;\n}\n\nclass LongTextStorageTransformImpl implements StorageTransform.Interface<\n    string | string[],\n    StorageValue\n> {\n    public readonly fieldType = \"long-text\";\n\n    public constructor(private readonly compressionHandler: CompressionHandler.Interface) {}\n\n    public async fromStorage({\n        field,\n        value: storageValue\n    }: StorageTransform.FromStorageParams<\n        string | string[],\n        StorageValue\n    >): StorageTransform.FromStorageResponse<string | string[]> {\n        const typeOf = typeof storageValue;\n        if (\n            !storageValue ||\n            typeOf === \"string\" ||\n            typeOf === \"number\" ||\n            Array.isArray(storageValue) === true\n        ) {\n            return storageValue as unknown as string | string[];\n        } else if (typeOf !== \"object\") {\n            throw new WebinyError(\n                `LongText value received in \"fromStorage\" function is not an object in field \"${field.storageId}\" - ${field.fieldId}.`\n            );\n        }\n\n        try {\n            const sv = storageValue as unknown as StorageValue;\n            const result = await this.compressionHandler.decompress<string>(storageValue);\n            if (!sv.isArray) {\n                return result;\n            }\n            return JSON.parse(result);\n        } catch (ex) {\n            console.log(\"Error while transforming long-text.\");\n            console.log(ex.message);\n            return \"\";\n        }\n    }\n\n    public async toStorage({\n        value: initialValue\n    }: StorageTransform.ToStorageParams<\n        string | string[],\n        StorageValue\n    >): StorageTransform.ToStorageResponse<StorageValue> {\n        if (initialValue && (initialValue as unknown as StorageValue).compression) {\n            return initialValue as unknown as StorageValue;\n        }\n        const isArray = Array.isArray(initialValue);\n        const value = isArray ? JSON.stringify(initialValue) : initialValue;\n        const compressed = await this.compressionHandler.compress(value);\n\n        if (!isArray) {\n            return compressed as unknown as StorageValue;\n        }\n        return { ...compressed, isArray } as unknown as StorageValue;\n    }\n}\n\nexport const LongTextStorageTransform = StorageTransform.createImplementation({\n    implementation: LongTextStorageTransformImpl,\n    dependencies: [CompressionHandler]\n});\n"],"mappings":"AAAA,SAASA,gBAAgB;AACzB,SAASC,WAAW,QAAQ,eAAe;AAC3C,SAASC,kBAAkB,QAAQ,8BAA8B;AAQjE,MAAMC,4BAA4B,CAGhC;EACkBC,SAAS,GAAG,WAAW;EAEhCC,WAAWA,CAAkBC,kBAAgD,EAAE;IAAA,KAAlDA,kBAAgD,GAAhDA,kBAAgD;EAAG;EAEvF,MAAaC,WAAWA,CAAC;IACrBC,KAAK;IACLC,KAAK,EAAEC;EAIX,CAAC,EAA2D;IACxD,MAAMC,MAAM,GAAG,OAAOD,YAAY;IAClC,IACI,CAACA,YAAY,IACbC,MAAM,KAAK,QAAQ,IACnBA,MAAM,KAAK,QAAQ,IACnBC,KAAK,CAACC,OAAO,CAACH,YAAY,CAAC,KAAK,IAAI,EACtC;MACE,OAAOA,YAAY;IACvB,CAAC,MAAM,IAAIC,MAAM,KAAK,QAAQ,EAAE;MAC5B,MAAM,IAAIV,WAAW,CACjB,gFAAgFO,KAAK,CAACM,SAAS,OAAON,KAAK,CAACO,OAAO,GACvH,CAAC;IACL;IAEA,IAAI;MACA,MAAMC,EAAE,GAAGN,YAAuC;MAClD,MAAMO,MAAM,GAAG,MAAM,IAAI,CAACX,kBAAkB,CAACY,UAAU,CAASR,YAAY,CAAC;MAC7E,IAAI,CAACM,EAAE,CAACH,OAAO,EAAE;QACb,OAAOI,MAAM;MACjB;MACA,OAAOE,IAAI,CAACC,KAAK,CAACH,MAAM,CAAC;IAC7B,CAAC,CAAC,OAAOI,EAAE,EAAE;MACTC,OAAO,CAACC,GAAG,CAAC,qCAAqC,CAAC;MAClDD,OAAO,CAACC,GAAG,CAACF,EAAE,CAACG,OAAO,CAAC;MACvB,OAAO,EAAE;IACb;EACJ;EAEA,MAAaC,SAASA,CAAC;IACnBhB,KAAK,EAAEiB;EAIX,CAAC,EAAoD;IACjD,IAAIA,YAAY,IAAKA,YAAY,CAA6BC,WAAW,EAAE;MACvE,OAAOD,YAAY;IACvB;IACA,MAAMb,OAAO,GAAGD,KAAK,CAACC,OAAO,CAACa,YAAY,CAAC;IAC3C,MAAMjB,KAAK,GAAGI,OAAO,GAAGM,IAAI,CAACS,SAAS,CAACF,YAAY,CAAC,GAAGA,YAAY;IACnE,MAAMG,UAAU,GAAG,MAAM,IAAI,CAACvB,kBAAkB,CAACwB,QAAQ,CAACrB,KAAK,CAAC;IAEhE,IAAI,CAACI,OAAO,EAAE;MACV,OAAOgB,UAAU;IACrB;IACA,OAAO;MAAE,GAAGA,UAAU;MAAEhB;IAAQ,CAAC;EACrC;AACJ;AAEA,OAAO,MAAMkB,wBAAwB,GAAG/B,gBAAgB,CAACgC,oBAAoB,CAAC;EAC1EC,cAAc,EAAE9B,4BAA4B;EAC5C+B,YAAY,EAAE,CAAChC,kBAAkB;AACrC,CAAC,CAAC","ignoreList":[]}

package/features/storage/fields/ObjectStorageTransform.d.ts

@@ -0,0 +1,10 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+declare class StorageTransformImpl implements StorageTransform.Interface {
+    readonly fieldType = "object";
+    toStorage(params: StorageTransform.ToStorageParams): StorageTransform.ToStorageResponse;
+    fromStorage(params: StorageTransform.FromStorageParams): StorageTransform.FromStorageResponse;
+}
+export declare const ObjectStorageTransform: typeof StorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};

package/features/storage/fields/ObjectStorageTransform.js

@@ -0,0 +1,99 @@
+import pReduce from "p-reduce";
+import pMap from "p-map";
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { getBaseFieldType } from "../../../utils/getBaseFieldType.js";
+const processValue = async params => {
+  const {
+    fields,
+    sourceValue,
+    getStorageTransform,
+    model,
+    operation
+  } = params;
+  return await pReduce(fields, async (values, field) => {
+    const baseType = getBaseFieldType(field);
+    const storageTransform = getStorageTransform(baseType);
+    if (!storageTransform) {
+      throw new Error(`Missing storage transform for field type "${baseType}".`);
+    }
+    const input = sourceValue[field.fieldId];
+    const value = await storageTransform[operation]({
+      model,
+      field,
+      value: input,
+      getStorageTransform
+    });
+    return {
+      ...values,
+      [field.fieldId]: value
+    };
+  }, {});
+};
+class StorageTransformImpl {
+  fieldType = "object";
+  async toStorage(params) {
+    const {
+      value,
+      field,
+      getStorageTransform,
+      model
+    } = params;
+    if (!value) {
+      return null;
+    }
+    const fields = field.settings?.fields || [];
+    if (field.list) {
+      return await pMap(value, value => processValue({
+        sourceValue: value,
+        getStorageTransform,
+        model,
+        operation: "toStorage",
+        fields
+      }));
+    }
+    return await processValue({
+      sourceValue: value,
+      getStorageTransform,
+      model,
+      operation: "toStorage",
+      fields
+    });
+  }
+  async fromStorage(params) {
+    const {
+      field,
+      value: input,
+      getStorageTransform,
+      model
+    } = params;
+    if (!input) {
+      return null;
+    }
+    const fields = field.settings?.fields || [];
+    if (field.list) {
+      const values = input;
+      return await Promise.all(values.map(async value => {
+        return await processValue({
+          sourceValue: value,
+          getStorageTransform,
+          model,
+          operation: "fromStorage",
+          fields
+        });
+      }));
+    }
+    return await processValue({
+      sourceValue: input,
+      getStorageTransform,
+      model,
+      operation: "fromStorage",
+      fields
+    });
+  }
+}
+export const ObjectStorageTransform = StorageTransform.createImplementation({
+  implementation: StorageTransformImpl,
+  dependencies: []
+});
+
+//# sourceMappingURL=ObjectStorageTransform.js.map

package/features/storage/fields/ObjectStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["pReduce","pMap","StorageTransform","getBaseFieldType","processValue","params","fields","sourceValue","getStorageTransform","model","operation","values","field","baseType","storageTransform","Error","input","fieldId","value","StorageTransformImpl","fieldType","toStorage","settings","list","fromStorage","Promise","all","map","ObjectStorageTransform","createImplementation","implementation","dependencies"],"sources":["ObjectStorageTransform.ts"],"sourcesContent":["import pReduce from \"p-reduce\";\nimport pMap from \"p-map\";\nimport type { CmsModel, CmsModelField } from \"~/types/index.js\";\nimport { StorageTransform } from \"../abstractions/StorageTransform.js\";\nimport { getBaseFieldType } from \"~/utils/getBaseFieldType.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\ninterface ProcessValueParams {\n    fields: CmsModelField[];\n    sourceValue: GenericRecord;\n    getStorageTransform: (fieldType: string) => StorageTransform.Interface;\n    model: CmsModel;\n    operation: \"toStorage\" | \"fromStorage\";\n}\ninterface ProcessValue {\n    (params: ProcessValueParams): Promise<GenericRecord>;\n}\n\nconst processValue: ProcessValue = async params => {\n    const { fields, sourceValue, getStorageTransform, model, operation } = params;\n    return await pReduce(\n        fields,\n        async (values, field) => {\n            const baseType = getBaseFieldType(field);\n            const storageTransform = getStorageTransform(baseType);\n            if (!storageTransform) {\n                throw new Error(`Missing storage transform for field type \"${baseType}\".`);\n            }\n            const input = sourceValue[field.fieldId];\n            const value = await storageTransform[operation]({\n                model,\n                field,\n                value: input,\n                getStorageTransform\n            });\n            return { ...values, [field.fieldId]: value };\n        },\n        {}\n    );\n};\n\nclass StorageTransformImpl implements StorageTransform.Interface {\n    public readonly fieldType = \"object\";\n\n    public async toStorage(\n        params: StorageTransform.ToStorageParams\n    ): StorageTransform.ToStorageResponse {\n        const { value, field, getStorageTransform, model } = params;\n        if (!value) {\n            return null;\n        }\n\n        const fields = (field.settings?.fields || []) as CmsModelField[];\n\n        if (field.list) {\n            return await pMap(value as GenericRecord[], value =>\n                processValue({\n                    sourceValue: value,\n                    getStorageTransform,\n                    model,\n                    operation: \"toStorage\",\n                    fields\n                })\n            );\n        }\n\n        return await processValue({\n            sourceValue: value,\n            getStorageTransform,\n            model,\n            operation: \"toStorage\",\n            fields\n        });\n    }\n\n    public async fromStorage(\n        params: StorageTransform.FromStorageParams\n    ): StorageTransform.FromStorageResponse {\n        const { field, value: input, getStorageTransform, model } = params;\n        if (!input) {\n            return null;\n        }\n\n        const fields = (field.settings?.fields || []) as CmsModelField[];\n\n        if (field.list) {\n            const values = input as GenericRecord[];\n\n            return await Promise.all(\n                values.map(async value => {\n                    return await processValue({\n                        sourceValue: value,\n                        getStorageTransform,\n                        model,\n                        operation: \"fromStorage\",\n                        fields\n                    });\n                })\n            );\n        }\n\n        return await processValue({\n            sourceValue: input,\n            getStorageTransform,\n            model,\n            operation: \"fromStorage\",\n            fields\n        });\n    }\n}\n\nexport const ObjectStorageTransform = StorageTransform.createImplementation({\n    implementation: StorageTransformImpl,\n    dependencies: []\n});\n"],"mappings":"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","ignoreList":[]}

package/features/storage/fields/RichTextStorageTransform.d.ts

@@ -0,0 +1,13 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+declare class RichTextStorageTransformImpl implements StorageTransform.Interface {
+    private readonly compressionHandler;
+    readonly fieldType = "rich-text";
+    constructor(compressionHandler: CompressionHandler.Interface);
+    fromStorage({ field, value: storageValue }: StorageTransform.FromStorageParams): StorageTransform.FromStorageResponse;
+    toStorage({ value }: StorageTransform.ToStorageParams): StorageTransform.ToStorageResponse;
+}
+export declare const RichTextStorageTransform: typeof RichTextStorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};

package/features/storage/fields/RichTextStorageTransform.js

@@ -0,0 +1,39 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { WebinyError } from "@webiny/error";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+class RichTextStorageTransformImpl {
+  fieldType = "rich-text";
+  constructor(compressionHandler) {
+    this.compressionHandler = compressionHandler;
+  }
+  async fromStorage({
+    field,
+    value: storageValue
+  }) {
+    if (!storageValue) {
+      return storageValue;
+    } else if (typeof storageValue !== "object") {
+      throw new WebinyError(`RichText value received in "fromStorage" function is not an object in field "${field.storageId}" - ${field.fieldId}.`);
+    }
+    try {
+      return await this.compressionHandler.decompress(storageValue);
+    } catch {
+      return storageValue;
+    }
+  }
+  async toStorage({
+    value
+  }) {
+    try {
+      return await this.compressionHandler.compress(value);
+    } catch {
+      return value;
+    }
+  }
+}
+export const RichTextStorageTransform = StorageTransform.createImplementation({
+  implementation: RichTextStorageTransformImpl,
+  dependencies: [CompressionHandler]
+});
+
+//# sourceMappingURL=RichTextStorageTransform.js.map

package/features/storage/fields/RichTextStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["StorageTransform","WebinyError","CompressionHandler","RichTextStorageTransformImpl","fieldType","constructor","compressionHandler","fromStorage","field","value","storageValue","storageId","fieldId","decompress","toStorage","compress","RichTextStorageTransform","createImplementation","implementation","dependencies"],"sources":["RichTextStorageTransform.ts"],"sourcesContent":["import { StorageTransform } from \"../abstractions/StorageTransform.js\";\nimport { WebinyError } from \"@webiny/error\";\nimport { CompressionHandler } from \"@webiny/utils/exports/api.js\";\n\nclass RichTextStorageTransformImpl implements StorageTransform.Interface {\n    public readonly fieldType = \"rich-text\";\n\n    public constructor(private readonly compressionHandler: CompressionHandler.Interface) {}\n\n    public async fromStorage({\n        field,\n        value: storageValue\n    }: StorageTransform.FromStorageParams): StorageTransform.FromStorageResponse {\n        if (!storageValue) {\n            return storageValue;\n        } else if (typeof storageValue !== \"object\") {\n            throw new WebinyError(\n                `RichText value received in \"fromStorage\" function is not an object in field \"${field.storageId}\" - ${field.fieldId}.`\n            );\n        }\n\n        try {\n            return await this.compressionHandler.decompress(storageValue);\n        } catch {\n            return storageValue;\n        }\n    }\n\n    public async toStorage({\n        value\n    }: StorageTransform.ToStorageParams): StorageTransform.ToStorageResponse {\n        try {\n            return await this.compressionHandler.compress(value);\n        } catch {\n            return value;\n        }\n    }\n}\n\nexport const RichTextStorageTransform = StorageTransform.createImplementation({\n    implementation: RichTextStorageTransformImpl,\n    dependencies: [CompressionHandler]\n});\n"],"mappings":"AAAA,SAASA,gBAAgB;AACzB,SAASC,WAAW,QAAQ,eAAe;AAC3C,SAASC,kBAAkB,QAAQ,8BAA8B;AAEjE,MAAMC,4BAA4B,CAAuC;EACrDC,SAAS,GAAG,WAAW;EAEhCC,WAAWA,CAAkBC,kBAAgD,EAAE;IAAA,KAAlDA,kBAAgD,GAAhDA,kBAAgD;EAAG;EAEvF,MAAaC,WAAWA,CAAC;IACrBC,KAAK;IACLC,KAAK,EAAEC;EACyB,CAAC,EAAwC;IACzE,IAAI,CAACA,YAAY,EAAE;MACf,OAAOA,YAAY;IACvB,CAAC,MAAM,IAAI,OAAOA,YAAY,KAAK,QAAQ,EAAE;MACzC,MAAM,IAAIT,WAAW,CACjB,gFAAgFO,KAAK,CAACG,SAAS,OAAOH,KAAK,CAACI,OAAO,GACvH,CAAC;IACL;IAEA,IAAI;MACA,OAAO,MAAM,IAAI,CAACN,kBAAkB,CAACO,UAAU,CAACH,YAAY,CAAC;IACjE,CAAC,CAAC,MAAM;MACJ,OAAOA,YAAY;IACvB;EACJ;EAEA,MAAaI,SAASA,CAAC;IACnBL;EAC8B,CAAC,EAAsC;IACrE,IAAI;MACA,OAAO,MAAM,IAAI,CAACH,kBAAkB,CAACS,QAAQ,CAACN,KAAK,CAAC;IACxD,CAAC,CAAC,MAAM;MACJ,OAAOA,KAAK;IAChB;EACJ;AACJ;AAEA,OAAO,MAAMO,wBAAwB,GAAGhB,gBAAgB,CAACiB,oBAAoB,CAAC;EAC1EC,cAAc,EAAEf,4BAA4B;EAC5CgB,YAAY,EAAE,CAACjB,kBAAkB;AACrC,CAAC,CAAC","ignoreList":[]}

package/features/storage/index.d.ts

@@ -0,0 +1,3 @@
+export { StorageTransform } from "./abstractions/StorageTransform.js";
+export { StorageTransformRegistry } from "./abstractions/StorageTransformRegistry.js";
+export { StorageFeature } from "./feature.js";

package/features/storage/index.js

@@ -0,0 +1,5 @@
+export { StorageTransform } from "./abstractions/StorageTransform.js";
+export { StorageTransformRegistry } from "./abstractions/StorageTransformRegistry.js";
+export { StorageFeature } from "./feature.js";
+
+//# sourceMappingURL=index.js.map

package/features/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["StorageTransform","StorageTransformRegistry","StorageFeature"],"sources":["index.ts"],"sourcesContent":["export { StorageTransform } from \"./abstractions/StorageTransform.js\";\nexport { StorageTransformRegistry } from \"./abstractions/StorageTransformRegistry.js\";\nexport { StorageFeature } from \"./feature.js\";\n"],"mappings":"AAAA,SAASA,gBAAgB;AACzB,SAASC,wBAAwB;AACjC,SAASC,cAAc","ignoreList":[]}

package/features/validation/CmsModelFieldPatternValidatorRegistry.d.ts

@@ -0,0 +1,12 @@
+import { CmsModelFieldPatternValidator } from "./abstractions/CmsModelFieldPatternValidator.js";
+import { CmsModelFieldPatternValidatorRegistry as RegistryAbstraction } from "./abstractions/CmsModelFieldPatternValidatorRegistry.js";
+declare class CmsModelFieldPatternValidatorRegistryImpl implements RegistryAbstraction.Interface {
+    private readonly validators;
+    constructor(validators: CmsModelFieldPatternValidator.Interface[]);
+    get(name: string): CmsModelFieldPatternValidator.Interface | undefined;
+    getAll(): CmsModelFieldPatternValidator.Interface[];
+}
+export declare const CmsModelFieldPatternValidatorRegistry: typeof CmsModelFieldPatternValidatorRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/CmsModelFieldPatternValidatorRegistry.js").ICmsModelFieldPatternValidatorRegistry>;
+};
+export {};

package/features/validation/CmsModelFieldPatternValidatorRegistry.js

@@ -0,0 +1,21 @@
+import { CmsModelFieldPatternValidator } from "./abstractions/CmsModelFieldPatternValidator.js";
+import { CmsModelFieldPatternValidatorRegistry as RegistryAbstraction } from "./abstractions/CmsModelFieldPatternValidatorRegistry.js";
+class CmsModelFieldPatternValidatorRegistryImpl {
+  constructor(validators) {
+    this.validators = validators;
+  }
+  get(name) {
+    return this.validators.find(v => v.pattern.name === name);
+  }
+  getAll() {
+    return this.validators;
+  }
+}
+export const CmsModelFieldPatternValidatorRegistry = RegistryAbstraction.createImplementation({
+  implementation: CmsModelFieldPatternValidatorRegistryImpl,
+  dependencies: [[CmsModelFieldPatternValidator, {
+    multiple: true
+  }]]
+});
+
+//# sourceMappingURL=CmsModelFieldPatternValidatorRegistry.js.map

package/features/validation/CmsModelFieldPatternValidatorRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CmsModelFieldPatternValidator","CmsModelFieldPatternValidatorRegistry","RegistryAbstraction","CmsModelFieldPatternValidatorRegistryImpl","constructor","validators","get","name","find","v","pattern","getAll","createImplementation","implementation","dependencies","multiple"],"sources":["CmsModelFieldPatternValidatorRegistry.ts"],"sourcesContent":["import { CmsModelFieldPatternValidator } from \"./abstractions/CmsModelFieldPatternValidator.js\";\nimport { CmsModelFieldPatternValidatorRegistry as RegistryAbstraction } from \"./abstractions/CmsModelFieldPatternValidatorRegistry.js\";\n\nclass CmsModelFieldPatternValidatorRegistryImpl implements RegistryAbstraction.Interface {\n    public constructor(private readonly validators: CmsModelFieldPatternValidator.Interface[]) {}\n\n    public get(name: string): CmsModelFieldPatternValidator.Interface | undefined {\n        return this.validators.find(v => v.pattern.name === name);\n    }\n\n    public getAll(): CmsModelFieldPatternValidator.Interface[] {\n        return this.validators;\n    }\n}\n\nexport const CmsModelFieldPatternValidatorRegistry = RegistryAbstraction.createImplementation({\n    implementation: CmsModelFieldPatternValidatorRegistryImpl,\n    dependencies: [[CmsModelFieldPatternValidator, { multiple: true }]]\n});\n"],"mappings":"AAAA,SAASA,6BAA6B;AACtC,SAASC,qCAAqC,IAAIC,mBAAmB;AAErE,MAAMC,yCAAyC,CAA0C;EAC9EC,WAAWA,CAAkBC,UAAqD,EAAE;IAAA,KAAvDA,UAAqD,GAArDA,UAAqD;EAAG;EAErFC,GAAGA,CAACC,IAAY,EAAuD;IAC1E,OAAO,IAAI,CAACF,UAAU,CAACG,IAAI,CAACC,CAAC,IAAIA,CAAC,CAACC,OAAO,CAACH,IAAI,KAAKA,IAAI,CAAC;EAC7D;EAEOI,MAAMA,CAAA,EAA8C;IACvD,OAAO,IAAI,CAACN,UAAU;EAC1B;AACJ;AAEA,OAAO,MAAMJ,qCAAqC,GAAGC,mBAAmB,CAACU,oBAAoB,CAAC;EAC1FC,cAAc,EAAEV,yCAAyC;EACzDW,YAAY,EAAE,CAAC,CAACd,6BAA6B,EAAE;IAAEe,QAAQ,EAAE;EAAK,CAAC,CAAC;AACtE,CAAC,CAAC","ignoreList":[]}

package/features/validation/CmsModelFieldValidatorRegistry.d.ts

@@ -0,0 +1,12 @@
+import { CmsModelFieldValidator } from "./abstractions/CmsModelFieldValidator.js";
+import { CmsModelFieldValidatorRegistry as RegistryAbstraction } from "./abstractions/CmsModelFieldValidatorRegistry.js";
+declare class CmsModelFieldValidatorRegistryImpl implements RegistryAbstraction.Interface {
+    private readonly validators;
+    constructor(validators: CmsModelFieldValidator.Interface[]);
+    get(name: string): CmsModelFieldValidator.Interface | undefined;
+    getAll(): CmsModelFieldValidator.Interface[];
+}
+export declare const CmsModelFieldValidatorRegistry: typeof CmsModelFieldValidatorRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/CmsModelFieldValidatorRegistry.js").ICmsModelFieldValidatorRegistry>;
+};
+export {};

package/features/validation/CmsModelFieldValidatorRegistry.js

@@ -0,0 +1,23 @@
+import { CmsModelFieldValidator } from "./abstractions/CmsModelFieldValidator.js";
+import { CmsModelFieldValidatorRegistry as RegistryAbstraction } from "./abstractions/CmsModelFieldValidatorRegistry.js";
+class CmsModelFieldValidatorRegistryImpl {
+  constructor(validators) {
+    this.validators = validators;
+  }
+  get(name) {
+    return this.validators.find(v => {
+      return v.name === name;
+    });
+  }
+  getAll() {
+    return this.validators;
+  }
+}
+export const CmsModelFieldValidatorRegistry = RegistryAbstraction.createImplementation({
+  implementation: CmsModelFieldValidatorRegistryImpl,
+  dependencies: [[CmsModelFieldValidator, {
+    multiple: true
+  }]]
+});
+
+//# sourceMappingURL=CmsModelFieldValidatorRegistry.js.map

package/features/validation/CmsModelFieldValidatorRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CmsModelFieldValidator","CmsModelFieldValidatorRegistry","RegistryAbstraction","CmsModelFieldValidatorRegistryImpl","constructor","validators","get","name","find","v","getAll","createImplementation","implementation","dependencies","multiple"],"sources":["CmsModelFieldValidatorRegistry.ts"],"sourcesContent":["import { CmsModelFieldValidator } from \"./abstractions/CmsModelFieldValidator.js\";\nimport { CmsModelFieldValidatorRegistry as RegistryAbstraction } from \"./abstractions/CmsModelFieldValidatorRegistry.js\";\n\nclass CmsModelFieldValidatorRegistryImpl implements RegistryAbstraction.Interface {\n    public constructor(private readonly validators: CmsModelFieldValidator.Interface[]) {}\n\n    public get(name: string): CmsModelFieldValidator.Interface | undefined {\n        return this.validators.find(v => {\n            return v.name === name;\n        });\n    }\n\n    public getAll(): CmsModelFieldValidator.Interface[] {\n        return this.validators;\n    }\n}\n\nexport const CmsModelFieldValidatorRegistry = RegistryAbstraction.createImplementation({\n    implementation: CmsModelFieldValidatorRegistryImpl,\n    dependencies: [[CmsModelFieldValidator, { multiple: true }]]\n});\n"],"mappings":"AAAA,SAASA,sBAAsB;AAC/B,SAASC,8BAA8B,IAAIC,mBAAmB;AAE9D,MAAMC,kCAAkC,CAA0C;EACvEC,WAAWA,CAAkBC,UAA8C,EAAE;IAAA,KAAhDA,UAA8C,GAA9CA,UAA8C;EAAG;EAE9EC,GAAGA,CAACC,IAAY,EAAgD;IACnE,OAAO,IAAI,CAACF,UAAU,CAACG,IAAI,CAACC,CAAC,IAAI;MAC7B,OAAOA,CAAC,CAACF,IAAI,KAAKA,IAAI;IAC1B,CAAC,CAAC;EACN;EAEOG,MAAMA,CAAA,EAAuC;IAChD,OAAO,IAAI,CAACL,UAAU;EAC1B;AACJ;AAEA,OAAO,MAAMJ,8BAA8B,GAAGC,mBAAmB,CAACS,oBAAoB,CAAC;EACnFC,cAAc,EAAET,kCAAkC;EAClDU,YAAY,EAAE,CAAC,CAACb,sBAAsB,EAAE;IAAEc,QAAQ,EAAE;EAAK,CAAC,CAAC;AAC/D,CAAC,CAAC","ignoreList":[]}

package/features/validation/abstractions/CmsModelFieldPatternValidator.d.ts

@@ -0,0 +1,13 @@
+export interface PatternDefinition {
+    readonly name: string;
+    readonly regex: string;
+    readonly flags: string;
+}
+export interface ICmsModelFieldPatternValidator {
+    readonly pattern: PatternDefinition;
+}
+export declare const CmsModelFieldPatternValidator: import("@webiny/di").Abstraction<ICmsModelFieldPatternValidator>;
+export declare namespace CmsModelFieldPatternValidator {
+    type Interface = ICmsModelFieldPatternValidator;
+    type Pattern = PatternDefinition;
+}

package/features/validation/abstractions/CmsModelFieldPatternValidator.js

@@ -0,0 +1,4 @@
+import { createAbstraction } from "@webiny/feature/createAbstraction.js";
+export const CmsModelFieldPatternValidator = createAbstraction("Cms/Model/Field/PatternValidator");
+
+//# sourceMappingURL=CmsModelFieldPatternValidator.js.map

package/features/validation/abstractions/CmsModelFieldPatternValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","CmsModelFieldPatternValidator"],"sources":["CmsModelFieldPatternValidator.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/createAbstraction.js\";\n\nexport interface PatternDefinition {\n    readonly name: string;\n    readonly regex: string;\n    readonly flags: string;\n}\n\nexport interface ICmsModelFieldPatternValidator {\n    readonly pattern: PatternDefinition;\n}\n\nexport const CmsModelFieldPatternValidator = createAbstraction<ICmsModelFieldPatternValidator>(\n    \"Cms/Model/Field/PatternValidator\"\n);\n\nexport namespace CmsModelFieldPatternValidator {\n    export type Interface = ICmsModelFieldPatternValidator;\n    export type Pattern = PatternDefinition;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,sCAAsC;AAYxE,OAAO,MAAMC,6BAA6B,GAAGD,iBAAiB,CAC1D,kCACJ,CAAC","ignoreList":[]}