@webiny/app-admin 6.4.12-beta.5 → 6.5.0-beta.1

package/features/clipboard/abstractions.js

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

package/features/clipboard/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/clipboard/abstractions.js","sources":["../../../src/features/clipboard/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\nexport interface IClipboardItem {\n    type: string;\n    data: Record<string, unknown>;\n}\n\nexport interface IClipboard {\n    readonly item: IClipboardItem | null;\n    copy(item: IClipboardItem): void;\n    paste(): IClipboardItem | null;\n    clear(): void;\n}\n\nexport const Clipboard = createAbstraction<IClipboard>(\"Clipboard\");\n\nexport namespace Clipboard {\n    export type Interface = IClipboard;\n}\n"],"names":["Clipboard","createAbstraction"],"mappings":";AAcO,MAAMA,YAAYC,kBAA8B"}

package/features/clipboard/feature.d.ts

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

package/features/clipboard/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/admin";
+import { ClipboardService } from "./ClipboardService.js";
+import { Clipboard } from "./abstractions.js";
+const ClipboardFeature = createFeature({
+    name: "Clipboard",
+    register (container) {
+        container.register(ClipboardService).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            clipboard: container.resolve(Clipboard)
+        };
+    }
+});
+export { ClipboardFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/clipboard/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/clipboard/feature.js","sources":["../../../src/features/clipboard/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { ClipboardService } from \"./ClipboardService.js\";\nimport { Clipboard as ClipboardAbstraction } from \"./abstractions.js\";\n\nexport const ClipboardFeature = createFeature({\n    name: \"Clipboard\",\n    register(container) {\n        container.register(ClipboardService).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            clipboard: container.resolve(ClipboardAbstraction)\n        };\n    }\n});\n"],"names":["ClipboardFeature","createFeature","container","ClipboardService","ClipboardAbstraction"],"mappings":";;;AAIO,MAAMA,mBAAmBC,cAAc;IAC1C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,kBAAkB,gBAAgB;IACzD;IACA,SAAQD,SAAS;QACb,OAAO;YACH,WAAWA,UAAU,OAAO,CAACE;QACjC;IACJ;AACJ"}

package/features/clipboard/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./abstractions.js";
+export { ClipboardFeature } from "./feature.js";

package/features/clipboard/index.js

@@ -0,0 +1,2 @@
+export * from "./abstractions.js";
+export { ClipboardFeature } from "./feature.js";

package/features/confirmation/Confirmation.d.ts

@@ -0,0 +1,11 @@
+import { Confirmation as Abstraction, NamedDialogOpener } from "./abstractions.js";
+declare class ConfirmationImpl implements Abstraction.Interface {
+    private dialogOpener;
+    constructor(dialogOpener: NamedDialogOpener.Interface);
+    confirm<TData = void, TParams extends Record<string, unknown> = Record<string, unknown>>(name: string, params?: TParams): Promise<TData | false>;
+    confirm<TData = void, TParams extends Record<string, unknown> = Record<string, unknown>, TResult = unknown>(name: string, params: TParams, execute: (data: TData) => Promise<TResult>): Promise<TResult | false>;
+}
+export declare const Confirmation: typeof ConfirmationImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IConfirmation>;
+};
+export {};

package/features/confirmation/Confirmation.js

@@ -0,0 +1,29 @@
+import { Confirmation, NamedDialogOpener } from "./abstractions.js";
+class ConfirmationImpl {
+    constructor(dialogOpener){
+        this.dialogOpener = dialogOpener;
+    }
+    async confirm(name, params, execute) {
+        return new Promise((resolve)=>{
+            this.dialogOpener.open(name, {
+                ...params,
+                onConfirm: async (data)=>{
+                    if (execute) {
+                        const result = await execute(data);
+                        resolve(result);
+                    } else resolve(data);
+                },
+                onCancel: ()=>resolve(false)
+            });
+        });
+    }
+}
+const Confirmation_Confirmation = Confirmation.createImplementation({
+    implementation: ConfirmationImpl,
+    dependencies: [
+        NamedDialogOpener
+    ]
+});
+export { Confirmation_Confirmation as Confirmation };
+
+//# sourceMappingURL=Confirmation.js.map

package/features/confirmation/Confirmation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/confirmation/Confirmation.js","sources":["../../../src/features/confirmation/Confirmation.ts"],"sourcesContent":["import { Confirmation as Abstraction, NamedDialogOpener } from \"./abstractions.js\";\n\nclass ConfirmationImpl implements Abstraction.Interface {\n    constructor(private dialogOpener: NamedDialogOpener.Interface) {}\n\n    async confirm<TData = void, TParams extends Record<string, unknown> = Record<string, unknown>>(\n        name: string,\n        params?: TParams\n    ): Promise<TData | false>;\n    async confirm<\n        TData = void,\n        TParams extends Record<string, unknown> = Record<string, unknown>,\n        TResult = unknown\n    >(\n        name: string,\n        params: TParams,\n        execute: (data: TData) => Promise<TResult>\n    ): Promise<TResult | false>;\n    async confirm(\n        name: string,\n        params?: Record<string, unknown>,\n        execute?: (data: unknown) => Promise<unknown>\n    ): Promise<unknown> {\n        return new Promise(resolve => {\n            this.dialogOpener.open(name, {\n                ...params,\n                onConfirm: async (data: unknown) => {\n                    if (execute) {\n                        const result = await execute(data);\n                        resolve(result);\n                    } else {\n                        resolve(data);\n                    }\n                },\n                onCancel: () => resolve(false)\n            });\n        });\n    }\n}\n\nexport const Confirmation = Abstraction.createImplementation({\n    implementation: ConfirmationImpl,\n    dependencies: [NamedDialogOpener]\n});\n"],"names":["ConfirmationImpl","dialogOpener","name","params","execute","Promise","resolve","data","result","Confirmation","Abstraction","NamedDialogOpener"],"mappings":";AAEA,MAAMA;IACF,YAAoBC,YAAyC,CAAE;aAA3CA,YAAY,GAAZA;IAA4C;IAehE,MAAM,QACFC,IAAY,EACZC,MAAgC,EAChCC,OAA6C,EAC7B;QAChB,OAAO,IAAIC,QAAQC,CAAAA;YACf,IAAI,CAAC,YAAY,CAAC,IAAI,CAACJ,MAAM;gBACzB,GAAGC,MAAM;gBACT,WAAW,OAAOI;oBACd,IAAIH,SAAS;wBACT,MAAMI,SAAS,MAAMJ,QAAQG;wBAC7BD,QAAQE;oBACZ,OACIF,QAAQC;gBAEhB;gBACA,UAAU,IAAMD,QAAQ;YAC5B;QACJ;IACJ;AACJ;AAEO,MAAMG,4BAAeC,aAAAA,oBAAgC,CAAC;IACzD,gBAAgBV;IAChB,cAAc;QAACW;KAAkB;AACrC"}

package/features/confirmation/ConfirmationBridge.d.ts

@@ -0,0 +1 @@
+export declare const ConfirmationBridge: () => null;

package/features/confirmation/ConfirmationBridge.js

@@ -0,0 +1,20 @@
+import { useEffect } from "react";
+import { useContainer } from "@webiny/app";
+import { useDialogs } from "../../components/Dialogs/useDialogs.js";
+import { NamedDialogOpener } from "./abstractions.js";
+const ConfirmationBridge = ()=>{
+    const container = useContainer();
+    const { openNamedDialog } = useDialogs();
+    useEffect(()=>{
+        container.registerInstance(NamedDialogOpener, {
+            open: openNamedDialog
+        });
+    }, [
+        container,
+        openNamedDialog
+    ]);
+    return null;
+};
+export { ConfirmationBridge };
+
+//# sourceMappingURL=ConfirmationBridge.js.map

package/features/confirmation/ConfirmationBridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/confirmation/ConfirmationBridge.js","sources":["../../../src/features/confirmation/ConfirmationBridge.tsx"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useContainer } from \"@webiny/app\";\nimport { useDialogs } from \"~/components/Dialogs/useDialogs.js\";\nimport { NamedDialogOpener } from \"./abstractions.js\";\n\nexport const ConfirmationBridge = () => {\n    const container = useContainer();\n    const { openNamedDialog } = useDialogs();\n\n    useEffect(() => {\n        container.registerInstance(NamedDialogOpener, {\n            open: openNamedDialog\n        });\n    }, [container, openNamedDialog]);\n\n    return null;\n};\n"],"names":["ConfirmationBridge","container","useContainer","openNamedDialog","useDialogs","useEffect","NamedDialogOpener"],"mappings":";;;;AAKO,MAAMA,qBAAqB;IAC9B,MAAMC,YAAYC;IAClB,MAAM,EAAEC,eAAe,EAAE,GAAGC;IAE5BC,UAAU;QACNJ,UAAU,gBAAgB,CAACK,mBAAmB;YAC1C,MAAMH;QACV;IACJ,GAAG;QAACF;QAAWE;KAAgB;IAE/B,OAAO;AACX"}

package/features/confirmation/abstractions.d.ts

@@ -0,0 +1,15 @@
+export interface INamedDialogOpener {
+    open(name: string, params: Record<string, unknown>): void;
+}
+export declare const NamedDialogOpener: import("@webiny/di").Abstraction<INamedDialogOpener>;
+export declare namespace NamedDialogOpener {
+    type Interface = INamedDialogOpener;
+}
+export interface IConfirmation {
+    confirm<TData = void, TParams extends Record<string, unknown> = Record<string, unknown>>(name: string, params?: TParams): Promise<TData | false>;
+    confirm<TData = void, TParams extends Record<string, unknown> = Record<string, unknown>, TResult = unknown>(name: string, params: TParams, execute: (data: TData) => Promise<TResult>): Promise<TResult | false>;
+}
+export declare const Confirmation: import("@webiny/di").Abstraction<IConfirmation>;
+export declare namespace Confirmation {
+    type Interface = IConfirmation;
+}

package/features/confirmation/abstractions.js

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

package/features/confirmation/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/confirmation/abstractions.js","sources":["../../../src/features/confirmation/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\nexport interface INamedDialogOpener {\n    open(name: string, params: Record<string, unknown>): void;\n}\n\nexport const NamedDialogOpener = createAbstraction<INamedDialogOpener>(\"NamedDialogOpener\");\n\nexport namespace NamedDialogOpener {\n    export type Interface = INamedDialogOpener;\n}\n\nexport interface IConfirmation {\n    confirm<TData = void, TParams extends Record<string, unknown> = Record<string, unknown>>(\n        name: string,\n        params?: TParams\n    ): Promise<TData | false>;\n\n    confirm<\n        TData = void,\n        TParams extends Record<string, unknown> = Record<string, unknown>,\n        TResult = unknown\n    >(\n        name: string,\n        params: TParams,\n        execute: (data: TData) => Promise<TResult>\n    ): Promise<TResult | false>;\n}\n\nexport const Confirmation = createAbstraction<IConfirmation>(\"Confirmation\");\n\nexport namespace Confirmation {\n    export type Interface = IConfirmation;\n}\n"],"names":["NamedDialogOpener","createAbstraction","Confirmation"],"mappings":";AAMO,MAAMA,oBAAoBC,kBAAsC;AAuBhE,MAAMC,eAAeD,kBAAiC"}

package/features/confirmation/feature.d.ts

@@ -0,0 +1 @@
+export declare const ConfirmationFeature: import("@webiny/feature/admin").FeatureDefinition<any, []>;

package/features/confirmation/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/admin";
+import { Confirmation } from "./Confirmation.js";
+const ConfirmationFeature = createFeature({
+    name: "Confirmation",
+    register (container) {
+        container.register(Confirmation).inSingletonScope();
+    }
+});
+export { ConfirmationFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/confirmation/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/confirmation/feature.js","sources":["../../../src/features/confirmation/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { Confirmation } from \"./Confirmation.js\";\n\nexport const ConfirmationFeature = createFeature({\n    name: \"Confirmation\",\n    register(container) {\n        container.register(Confirmation).inSingletonScope();\n    }\n});\n"],"names":["ConfirmationFeature","createFeature","container","Confirmation"],"mappings":";;AAGO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,cAAc,gBAAgB;IACrD;AACJ"}

package/features/confirmation/index.d.ts

@@ -0,0 +1,3 @@
+export { Confirmation, NamedDialogOpener, type IConfirmation, type INamedDialogOpener } from "./abstractions.js";
+export { ConfirmationFeature } from "./feature.js";
+export { ConfirmationBridge } from "./ConfirmationBridge.js";

package/features/confirmation/index.js

@@ -0,0 +1,3 @@
+export { Confirmation, NamedDialogOpener } from "./abstractions.js";
+export { ConfirmationFeature } from "./feature.js";
+export { ConfirmationBridge } from "./ConfirmationBridge.js";

package/features/dateFormatter/DefaultDateFormatter.d.ts

@@ -0,0 +1,8 @@
+import type { FormattableDate, IDateFormatter } from "./abstractions.js";
+declare class DefaultDateFormatterImpl implements IDateFormatter {
+    format(date: FormattableDate, options?: Intl.DateTimeFormatOptions): string;
+}
+export declare const DefaultDateFormatter: typeof DefaultDateFormatterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IDateFormatter>;
+};
+export {};

package/features/dateFormatter/DefaultDateFormatter.js

@@ -0,0 +1,25 @@
+import { DateFormatter } from "./abstractions.js";
+const DEFAULT_OPTIONS = {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+};
+class DefaultDateFormatterImpl {
+    format(date, options) {
+        const formatter = new Intl.DateTimeFormat(void 0, {
+            ...DEFAULT_OPTIONS,
+            ...options
+        });
+        return formatter.format(new Date(date));
+    }
+}
+const DefaultDateFormatter = DateFormatter.createImplementation({
+    implementation: DefaultDateFormatterImpl,
+    dependencies: []
+});
+export { DefaultDateFormatter };
+
+//# sourceMappingURL=DefaultDateFormatter.js.map

package/features/dateFormatter/DefaultDateFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/dateFormatter/DefaultDateFormatter.js","sources":["../../../src/features/dateFormatter/DefaultDateFormatter.ts"],"sourcesContent":["import { DateFormatter } from \"./abstractions.js\";\nimport type { FormattableDate, IDateFormatter } from \"./abstractions.js\";\n\n/**\n * Default absolute date/time format used across the admin app: `YYYY-MM-DD HH:mm`, 24-hour, in the\n * browser's locale. This is the single place these dates are formatted, so projects can change the\n * format everywhere at once by decorating the DateFormatter abstraction.\n */\nconst DEFAULT_OPTIONS: Intl.DateTimeFormatOptions = {\n    year: \"numeric\",\n    month: \"2-digit\",\n    day: \"2-digit\",\n    hour: \"2-digit\",\n    minute: \"2-digit\",\n    hour12: false\n};\n\nclass DefaultDateFormatterImpl implements IDateFormatter {\n    format(date: FormattableDate, options?: Intl.DateTimeFormatOptions): string {\n        const formatter = new Intl.DateTimeFormat(undefined, { ...DEFAULT_OPTIONS, ...options });\n        return formatter.format(new Date(date));\n    }\n}\n\nexport const DefaultDateFormatter = DateFormatter.createImplementation({\n    implementation: DefaultDateFormatterImpl,\n    dependencies: []\n});\n"],"names":["DEFAULT_OPTIONS","DefaultDateFormatterImpl","date","options","formatter","Intl","undefined","Date","DefaultDateFormatter","DateFormatter"],"mappings":";AAQA,MAAMA,kBAA8C;IAChD,MAAM;IACN,OAAO;IACP,KAAK;IACL,MAAM;IACN,QAAQ;IACR,QAAQ;AACZ;AAEA,MAAMC;IACF,OAAOC,IAAqB,EAAEC,OAAoC,EAAU;QACxE,MAAMC,YAAY,IAAIC,KAAK,cAAc,CAACC,QAAW;YAAE,GAAGN,eAAe;YAAE,GAAGG,OAAO;QAAC;QACtF,OAAOC,UAAU,MAAM,CAAC,IAAIG,KAAKL;IACrC;AACJ;AAEO,MAAMM,uBAAuBC,cAAc,oBAAoB,CAAC;IACnE,gBAAgBR;IAChB,cAAc,EAAE;AACpB"}

package/features/dateFormatter/abstractions.d.ts

@@ -0,0 +1,13 @@
+export type FormattableDate = Date | string | number;
+export interface IDateFormatter {
+    /**
+     * Formats an absolute date/time as a locale string. Pass `options` to override the defaults for
+     * a specific call; change the defaults globally by decorating this abstraction.
+     */
+    format(date: FormattableDate, options?: Intl.DateTimeFormatOptions): string;
+}
+export declare const DateFormatter: import("@webiny/di").Abstraction<IDateFormatter>;
+export declare namespace DateFormatter {
+    type Interface = IDateFormatter;
+    type Value = FormattableDate;
+}

package/features/dateFormatter/abstractions.js

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

package/features/dateFormatter/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/dateFormatter/abstractions.js","sources":["../../../src/features/dateFormatter/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\nexport type FormattableDate = Date | string | number;\n\nexport interface IDateFormatter {\n    /**\n     * Formats an absolute date/time as a locale string. Pass `options` to override the defaults for\n     * a specific call; change the defaults globally by decorating this abstraction.\n     */\n    format(date: FormattableDate, options?: Intl.DateTimeFormatOptions): string;\n}\n\nexport const DateFormatter = createAbstraction<IDateFormatter>(\"DateFormatter\");\n\nexport namespace DateFormatter {\n    export type Interface = IDateFormatter;\n    export type Value = FormattableDate;\n}\n"],"names":["DateFormatter","createAbstraction"],"mappings":";AAYO,MAAMA,gBAAgBC,kBAAkC"}

package/features/dateFormatter/feature.d.ts

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

package/features/dateFormatter/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/admin";
+import { DateFormatter } from "./abstractions.js";
+import { DefaultDateFormatter } from "./DefaultDateFormatter.js";
+const DateFormatterFeature = createFeature({
+    name: "DateFormatter",
+    register (container) {
+        container.register(DefaultDateFormatter).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            formatter: container.resolve(DateFormatter)
+        };
+    }
+});
+export { DateFormatterFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/dateFormatter/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/dateFormatter/feature.js","sources":["../../../src/features/dateFormatter/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { DateFormatter } from \"./abstractions.js\";\nimport { DefaultDateFormatter } from \"./DefaultDateFormatter.js\";\n\nexport const DateFormatterFeature = createFeature({\n    name: \"DateFormatter\",\n    register(container) {\n        container.register(DefaultDateFormatter).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            formatter: container.resolve(DateFormatter)\n        };\n    }\n});\n"],"names":["DateFormatterFeature","createFeature","container","DefaultDateFormatter","DateFormatter"],"mappings":";;;AAIO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,sBAAsB,gBAAgB;IAC7D;IACA,SAAQD,SAAS;QACb,OAAO;YACH,WAAWA,UAAU,OAAO,CAACE;QACjC;IACJ;AACJ"}

package/features/dateFormatter/formatUtcOffset.d.ts

@@ -0,0 +1 @@
+export declare function formatUtcOffset(): string;

package/features/dateFormatter/formatUtcOffset.js

@@ -0,0 +1,11 @@
+function formatUtcOffset() {
+    const offset = -new Date().getTimezoneOffset();
+    const sign = offset >= 0 ? "+" : "-";
+    const abs = Math.abs(offset);
+    const hours = String(Math.floor(abs / 60)).padStart(2, "0");
+    const minutes = String(abs % 60).padStart(2, "0");
+    return `UTC${sign}${hours}:${minutes}`;
+}
+export { formatUtcOffset };
+
+//# sourceMappingURL=formatUtcOffset.js.map

package/features/dateFormatter/formatUtcOffset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/dateFormatter/formatUtcOffset.js","sources":["../../../src/features/dateFormatter/formatUtcOffset.ts"],"sourcesContent":["export function formatUtcOffset(): string {\n    const offset = -new Date().getTimezoneOffset();\n    const sign = offset >= 0 ? \"+\" : \"-\";\n    const abs = Math.abs(offset);\n    const hours = String(Math.floor(abs / 60)).padStart(2, \"0\");\n    const minutes = String(abs % 60).padStart(2, \"0\");\n    return `UTC${sign}${hours}:${minutes}`;\n}\n"],"names":["formatUtcOffset","offset","Date","sign","abs","Math","hours","String","minutes"],"mappings":"AAAO,SAASA;IACZ,MAAMC,SAAS,CAAC,IAAIC,OAAO,iBAAiB;IAC5C,MAAMC,OAAOF,UAAU,IAAI,MAAM;IACjC,MAAMG,MAAMC,KAAK,GAAG,CAACJ;IACrB,MAAMK,QAAQC,OAAOF,KAAK,KAAK,CAACD,MAAM,KAAK,QAAQ,CAAC,GAAG;IACvD,MAAMI,UAAUD,OAAOH,MAAM,IAAI,QAAQ,CAAC,GAAG;IAC7C,OAAO,CAAC,GAAG,EAAED,OAAOG,MAAM,CAAC,EAAEE,SAAS;AAC1C"}

package/features/dateFormatter/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./abstractions.js";
+export * from "./DefaultDateFormatter.js";
+export * from "./feature.js";
+export * from "./useDateFormatter.js";

package/features/dateFormatter/index.js

@@ -0,0 +1,4 @@
+export * from "./abstractions.js";
+export * from "./DefaultDateFormatter.js";
+export * from "./feature.js";
+export * from "./useDateFormatter.js";

package/features/dateFormatter/useDateFormatter.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Resolves the shared DateFormatter for components that have no presenter of their own. Prefer
+ * formatting in a presenter's view model where one exists.
+ */
+export declare function useDateFormatter(): import("./abstractions.js").IDateFormatter;

package/features/dateFormatter/useDateFormatter.js

@@ -0,0 +1,8 @@
+import { useFeature } from "@webiny/app";
+import { DateFormatterFeature } from "./feature.js";
+function useDateFormatter() {
+    return useFeature(DateFormatterFeature).formatter;
+}
+export { useDateFormatter };
+
+//# sourceMappingURL=useDateFormatter.js.map

package/features/dateFormatter/useDateFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/dateFormatter/useDateFormatter.js","sources":["../../../src/features/dateFormatter/useDateFormatter.ts"],"sourcesContent":["import { useFeature } from \"@webiny/app\";\nimport { DateFormatterFeature } from \"./feature.js\";\n\n/**\n * Resolves the shared DateFormatter for components that have no presenter of their own. Prefer\n * formatting in a presenter's view model where one exists.\n */\nexport function useDateFormatter() {\n    return useFeature(DateFormatterFeature).formatter;\n}\n"],"names":["useDateFormatter","useFeature","DateFormatterFeature"],"mappings":";;AAOO,SAASA;IACZ,OAAOC,WAAWC,sBAAsB,SAAS;AACrD"}

package/features/formModel/AccessControlRuleEvaluator.d.ts

@@ -0,0 +1,12 @@
+import { IdentityContext } from "../../features/security/IdentityContext/abstractions.js";
+import { RuleEvaluator } from "./abstractions.js";
+declare class AccessControlRuleEvaluatorImpl implements RuleEvaluator.Interface {
+    private identityContext;
+    constructor(identityContext: IdentityContext.Interface);
+    canEvaluate(rule: RuleEvaluator.Rule): boolean;
+    evaluate(rule: RuleEvaluator.Rule): boolean;
+}
+export declare const AccessControlRuleEvaluator: typeof AccessControlRuleEvaluatorImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IRuleEvaluator>;
+};
+export {};

package/features/formModel/AccessControlRuleEvaluator.js

@@ -0,0 +1,30 @@
+import { IdentityContext } from "../security/IdentityContext/abstractions.js";
+import { RuleEvaluator } from "./abstractions.js";
+class AccessControlRuleEvaluatorImpl {
+    constructor(identityContext){
+        this.identityContext = identityContext;
+    }
+    canEvaluate(rule) {
+        return "accessControl" === rule.type;
+    }
+    evaluate(rule) {
+        const identity = this.identityContext.getIdentity();
+        if (!identity.isAuthenticated || "string" != typeof rule.value) return false;
+        const separator = rule.value.indexOf(":");
+        const scope = rule.value.slice(0, separator);
+        const id = rule.value.slice(separator + 1);
+        if (-1 === separator || !id) return false;
+        if ("admin" === scope) return identity.id === id;
+        if ("team" === scope) return identity.teams.some((team)=>team.slug === id);
+        return false;
+    }
+}
+const AccessControlRuleEvaluator = RuleEvaluator.createImplementation({
+    implementation: AccessControlRuleEvaluatorImpl,
+    dependencies: [
+        IdentityContext
+    ]
+});
+export { AccessControlRuleEvaluator };
+
+//# sourceMappingURL=AccessControlRuleEvaluator.js.map

package/features/formModel/AccessControlRuleEvaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/formModel/AccessControlRuleEvaluator.js","sources":["../../../src/features/formModel/AccessControlRuleEvaluator.ts"],"sourcesContent":["import { IdentityContext } from \"~/features/security/IdentityContext/abstractions.js\";\nimport { RuleEvaluator } from \"./abstractions.js\";\n\nclass AccessControlRuleEvaluatorImpl implements RuleEvaluator.Interface {\n    constructor(private identityContext: IdentityContext.Interface) {}\n\n    canEvaluate(rule: RuleEvaluator.Rule): boolean {\n        return rule.type === \"accessControl\";\n    }\n\n    // Rule values follow the folder-permission target format: `admin:<userId>` or `team:<teamSlug>`.\n    evaluate(rule: RuleEvaluator.Rule): boolean {\n        const identity = this.identityContext.getIdentity();\n        if (!identity.isAuthenticated || typeof rule.value !== \"string\") {\n            return false;\n        }\n\n        const separator = rule.value.indexOf(\":\");\n        const scope = rule.value.slice(0, separator);\n        const id = rule.value.slice(separator + 1);\n        if (separator === -1 || !id) {\n            return false;\n        }\n\n        if (scope === \"admin\") {\n            return identity.id === id;\n        }\n        if (scope === \"team\") {\n            return identity.teams.some(team => team.slug === id);\n        }\n        return false;\n    }\n}\n\nexport const AccessControlRuleEvaluator = RuleEvaluator.createImplementation({\n    implementation: AccessControlRuleEvaluatorImpl,\n    dependencies: [IdentityContext]\n});\n"],"names":["AccessControlRuleEvaluatorImpl","identityContext","rule","identity","separator","scope","id","team","AccessControlRuleEvaluator","RuleEvaluator","IdentityContext"],"mappings":";;AAGA,MAAMA;IACF,YAAoBC,eAA0C,CAAE;aAA5CA,eAAe,GAAfA;IAA6C;IAEjE,YAAYC,IAAwB,EAAW;QAC3C,OAAOA,AAAc,oBAAdA,KAAK,IAAI;IACpB;IAGA,SAASA,IAAwB,EAAW;QACxC,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,IAAI,CAACA,SAAS,eAAe,IAAI,AAAsB,YAAtB,OAAOD,KAAK,KAAK,EAC9C,OAAO;QAGX,MAAME,YAAYF,KAAK,KAAK,CAAC,OAAO,CAAC;QACrC,MAAMG,QAAQH,KAAK,KAAK,CAAC,KAAK,CAAC,GAAGE;QAClC,MAAME,KAAKJ,KAAK,KAAK,CAAC,KAAK,CAACE,YAAY;QACxC,IAAIA,AAAc,OAAdA,aAAoB,CAACE,IACrB,OAAO;QAGX,IAAID,AAAU,YAAVA,OACA,OAAOF,SAAS,EAAE,KAAKG;QAE3B,IAAID,AAAU,WAAVA,OACA,OAAOF,SAAS,KAAK,CAAC,IAAI,CAACI,CAAAA,OAAQA,KAAK,IAAI,KAAKD;QAErD,OAAO;IACX;AACJ;AAEO,MAAME,6BAA6BC,cAAc,oBAAoB,CAAC;IACzE,gBAAgBT;IAChB,cAAc;QAACU;KAAgB;AACnC"}

package/features/formModel/AccessControlRuleEvaluator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/features/formModel/AccessControlRuleEvaluator.test.js

@@ -0,0 +1,219 @@
+import { describe, expect, it } from "vitest";
+import { Container } from "@webiny/di";
+import { FormModelFeature } from "./feature.js";
+import { FormModelFactory } from "./abstractions.js";
+import { IdentityContext } from "../security/IdentityContext/abstractions.js";
+import { Identity } from "../../domain/Identity.js";
+const createIdentity = (id, teamSlugs = [])=>Identity.createAuthenticated({
+        id,
+        type: "admin",
+        displayName: id,
+        roles: [],
+        teams: teamSlugs.map((slug)=>({
+                id: `${slug}-id`,
+                slug,
+                name: slug
+            })),
+        permissions: [],
+        profile: {
+            external: false
+        },
+        currentTenant: {
+            id: "root",
+            name: "Root"
+        },
+        defaultTenant: {
+            id: "root",
+            name: "Root"
+        }
+    });
+const accessRule = (value, action = "hide")=>({
+        type: "accessControl",
+        target: "identity",
+        operator: "matches",
+        value,
+        action
+    });
+const createContainer = (identity)=>{
+    const container = new Container();
+    FormModelFeature.register(container);
+    container.registerInstance(IdentityContext, {
+        getIdentity: ()=>identity,
+        setIdentity: ()=>{},
+        clear: ()=>{}
+    });
+    return container;
+};
+const createFieldForm = (identity, rules)=>createContainer(identity).resolve(FormModelFactory).create({
+        fields: (fields)=>({
+                secret: fields.text().label("Secret").rules(rules)
+            })
+    });
+describe("AccessControlRuleEvaluator", ()=>{
+    it("hides a field from the admin the rule names", ()=>{
+        const form = createFieldForm(createIdentity("user-1"), [
+            accessRule("admin:user-1")
+        ]);
+        expect(form.field("secret").visible).toBe(false);
+    });
+    it("leaves the field visible for other admins", ()=>{
+        const form = createFieldForm(createIdentity("user-2"), [
+            accessRule("admin:user-1")
+        ]);
+        expect(form.field("secret").visible).toBe(true);
+    });
+    it("hides a field from members of the team the rule names, by team slug", ()=>{
+        const form = createFieldForm(createIdentity("user-2", [
+            "editors"
+        ]), [
+            accessRule("team:editors")
+        ]);
+        expect(form.field("secret").visible).toBe(false);
+    });
+    it("leaves the field visible for admins outside the team", ()=>{
+        const form = createFieldForm(createIdentity("user-2", [
+            "writers"
+        ]), [
+            accessRule("team:editors")
+        ]);
+        expect(form.field("secret").visible).toBe(true);
+    });
+    it("does not match a team by its id", ()=>{
+        const form = createFieldForm(createIdentity("user-2", [
+            "editors"
+        ]), [
+            accessRule("team:editors-id")
+        ]);
+        expect(form.field("secret").visible).toBe(true);
+    });
+    it("disables the field for a viewer rule", ()=>{
+        const form = createFieldForm(createIdentity("user-1"), [
+            accessRule("admin:user-1", "disable")
+        ]);
+        expect(form.field("secret").visible).toBe(true);
+        expect(form.field("secret").vm.disabled).toBe(true);
+    });
+    it("applies when any of several rules matches", ()=>{
+        const form = createFieldForm(createIdentity("user-3", [
+            "editors"
+        ]), [
+            accessRule("admin:user-1"),
+            accessRule("team:editors")
+        ]);
+        expect(form.field("secret").visible).toBe(false);
+    });
+    describe("read-only and no-access rules on one field", ()=>{
+        const rules = [
+            accessRule("admin:user-1", "disable"),
+            accessRule("team:team-1", "hide")
+        ];
+        it.each([
+            [
+                "matches only the read-only rule",
+                "user-1",
+                [],
+                true,
+                true
+            ],
+            [
+                "matches only the no-access rule",
+                "user-2",
+                [
+                    "team-1"
+                ],
+                false,
+                false
+            ],
+            [
+                "matches both rules",
+                "user-1",
+                [
+                    "team-1"
+                ],
+                false,
+                true
+            ],
+            [
+                "matches neither rule",
+                "user-2",
+                [
+                    "team-2"
+                ],
+                true,
+                false
+            ]
+        ])("%s", (_, id, teams, visible, disabled)=>{
+            const form = createFieldForm(createIdentity(id, teams), rules);
+            expect(form.field("secret").visible).toBe(visible);
+            expect(form.field("secret").disabled).toBe(disabled);
+        });
+    });
+    it("does not match an anonymous identity", ()=>{
+        const form = createFieldForm(Identity.createAnonymous(), [
+            accessRule("admin:anonymous")
+        ]);
+        expect(form.field("secret").visible).toBe(true);
+    });
+    it.each([
+        [
+            "no scope",
+            "user-1"
+        ],
+        [
+            "unknown scope",
+            "role:user-1"
+        ],
+        [
+            "empty id",
+            "admin:"
+        ],
+        [
+            "null",
+            null
+        ],
+        [
+            "non-string",
+            1
+        ]
+    ])("ignores a malformed value (%s)", (_, value)=>{
+        const form = createFieldForm(createIdentity("user-1"), [
+            accessRule(value)
+        ]);
+        expect(form.field("secret").visible).toBe(true);
+    });
+    it("hides a tab from the admin the rule names, alongside a condition rule", ()=>{
+        const form = createContainer(createIdentity("user-1")).resolve(FormModelFactory).create({
+            fields: (fields)=>({
+                    options: fields.text().label("Options"),
+                    map: fields.text().label("Map")
+                }),
+            layout: (layout)=>[
+                    layout.tabs("tabs").tab("tab1", (tab)=>{
+                        tab.label("Tab 1").layout((layout)=>[
+                                layout.row("options")
+                            ]);
+                    }).tab("tab2", (tab)=>{
+                        tab.label("Tab 2").rules([
+                            {
+                                type: "condition",
+                                target: "options",
+                                operator: "!=",
+                                value: "map",
+                                action: "disable"
+                            },
+                            accessRule("admin:user-1")
+                        ]).layout((layout)=>[
+                                layout.row("map")
+                            ]);
+                    })
+                ]
+        });
+        const tabs = form.vm.layout.find((n)=>"tabs" === n.type);
+        expect(tabs.tabs.map((t)=>t.id)).toEqual([
+            "tab1"
+        ]);
+        expect(form.field("map").visible).toBe(false);
+    });
+});
+
+//# sourceMappingURL=AccessControlRuleEvaluator.test.js.map