@webiny/app-admin 6.6.0-alpha.1 → 6.6.0-alpha.10

package/features/formModel/jsonSchema/getJsonSchemaKind.js

@@ -0,0 +1,31 @@
+const isNumberType = (type)=>"number" === type || "integer" === type;
+const hasEnumValues = (schema)=>Array.isArray(schema.enum) && schema.enum.length > 0;
+const hasEnumOfType = (schema, valueType)=>{
+    if (!Array.isArray(schema.enum) || 0 === schema.enum.length) return false;
+    return schema.enum.every((value)=>typeof value === valueType);
+};
+const getArrayKind = (schema)=>{
+    const items = schema.items;
+    if (!items || "object" != typeof items) return "json";
+    if ("string" === items.type && !hasEnumValues(items)) return "stringList";
+    if ("object" === items.type && items.properties && "object" == typeof items.properties) return "objectList";
+    return "json";
+};
+const getJsonSchemaKind = (schema)=>{
+    if (!schema || "object" != typeof schema) return "json";
+    if ("string" === schema.type) {
+        if (hasEnumValues(schema)) return hasEnumOfType(schema, "string") ? "enum" : "json";
+        return "string";
+    }
+    if (isNumberType(schema.type)) {
+        if (hasEnumValues(schema)) return hasEnumOfType(schema, "number") ? "enum" : "json";
+        return "number";
+    }
+    if ("boolean" === schema.type) return "boolean";
+    if ("object" === schema.type && schema.properties && "object" == typeof schema.properties) return "object";
+    if ("array" === schema.type) return getArrayKind(schema);
+    return "json";
+};
+export { getJsonSchemaKind };
+
+//# sourceMappingURL=getJsonSchemaKind.js.map

package/features/formModel/jsonSchema/getJsonSchemaKind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/formModel/jsonSchema/getJsonSchemaKind.js","sources":["../../../../src/features/formModel/jsonSchema/getJsonSchemaKind.ts"],"sourcesContent":["import type { JsonSchema } from \"./JsonSchema.js\";\n\nexport type JsonSchemaKind =\n    | \"string\"\n    | \"enum\"\n    | \"number\"\n    | \"boolean\"\n    | \"object\"\n    | \"stringList\"\n    | \"objectList\"\n    | \"json\";\n\nconst isNumberType = (type: unknown): boolean => {\n    return type === \"number\" || type === \"integer\";\n};\n\nconst hasEnumValues = (schema: JsonSchema): boolean => {\n    return Array.isArray(schema.enum) && schema.enum.length > 0;\n};\n\nconst hasEnumOfType = (schema: JsonSchema, valueType: string): boolean => {\n    if (!Array.isArray(schema.enum) || schema.enum.length === 0) {\n        return false;\n    }\n    return schema.enum.every(value => typeof value === valueType);\n};\n\nconst getArrayKind = (schema: JsonSchema): JsonSchemaKind => {\n    const items = schema.items;\n    if (!items || typeof items !== \"object\") {\n        return \"json\";\n    }\n    if (items.type === \"string\" && !hasEnumValues(items)) {\n        return \"stringList\";\n    }\n    if (items.type === \"object\" && items.properties && typeof items.properties === \"object\") {\n        return \"objectList\";\n    }\n    return \"json\";\n};\n\n/*\n * How the adapter renders a property: one of the supported shapes, or `json` (a JSON text field)\n * for everything else. A schema that is not an object returns `json`, so a malformed property\n * never crashes the builder.\n */\nexport const getJsonSchemaKind = (schema: JsonSchema): JsonSchemaKind => {\n    if (!schema || typeof schema !== \"object\") {\n        return \"json\";\n    }\n    if (schema.type === \"string\") {\n        if (hasEnumValues(schema)) {\n            return hasEnumOfType(schema, \"string\") ? \"enum\" : \"json\";\n        }\n        return \"string\";\n    }\n    if (isNumberType(schema.type)) {\n        if (hasEnumValues(schema)) {\n            return hasEnumOfType(schema, \"number\") ? \"enum\" : \"json\";\n        }\n        return \"number\";\n    }\n    if (schema.type === \"boolean\") {\n        return \"boolean\";\n    }\n    if (schema.type === \"object\" && schema.properties && typeof schema.properties === \"object\") {\n        return \"object\";\n    }\n    if (schema.type === \"array\") {\n        return getArrayKind(schema);\n    }\n    return \"json\";\n};\n"],"names":["isNumberType","type","hasEnumValues","schema","Array","hasEnumOfType","valueType","value","getArrayKind","items","getJsonSchemaKind"],"mappings":"AAYA,MAAMA,eAAe,CAACC,OACXA,AAAS,aAATA,QAAqBA,AAAS,cAATA;AAGhC,MAAMC,gBAAgB,CAACC,SACZC,MAAM,OAAO,CAACD,OAAO,IAAI,KAAKA,OAAO,IAAI,CAAC,MAAM,GAAG;AAG9D,MAAME,gBAAgB,CAACF,QAAoBG;IACvC,IAAI,CAACF,MAAM,OAAO,CAACD,OAAO,IAAI,KAAKA,AAAuB,MAAvBA,OAAO,IAAI,CAAC,MAAM,EACjD,OAAO;IAEX,OAAOA,OAAO,IAAI,CAAC,KAAK,CAACI,CAAAA,QAAS,OAAOA,UAAUD;AACvD;AAEA,MAAME,eAAe,CAACL;IAClB,MAAMM,QAAQN,OAAO,KAAK;IAC1B,IAAI,CAACM,SAAS,AAAiB,YAAjB,OAAOA,OACjB,OAAO;IAEX,IAAIA,AAAe,aAAfA,MAAM,IAAI,IAAiB,CAACP,cAAcO,QAC1C,OAAO;IAEX,IAAIA,AAAe,aAAfA,MAAM,IAAI,IAAiBA,MAAM,UAAU,IAAI,AAA4B,YAA5B,OAAOA,MAAM,UAAU,EACtE,OAAO;IAEX,OAAO;AACX;AAOO,MAAMC,oBAAoB,CAACP;IAC9B,IAAI,CAACA,UAAU,AAAkB,YAAlB,OAAOA,QAClB,OAAO;IAEX,IAAIA,AAAgB,aAAhBA,OAAO,IAAI,EAAe;QAC1B,IAAID,cAAcC,SACd,OAAOE,cAAcF,QAAQ,YAAY,SAAS;QAEtD,OAAO;IACX;IACA,IAAIH,aAAaG,OAAO,IAAI,GAAG;QAC3B,IAAID,cAAcC,SACd,OAAOE,cAAcF,QAAQ,YAAY,SAAS;QAEtD,OAAO;IACX;IACA,IAAIA,AAAgB,cAAhBA,OAAO,IAAI,EACX,OAAO;IAEX,IAAIA,AAAgB,aAAhBA,OAAO,IAAI,IAAiBA,OAAO,UAAU,IAAI,AAA6B,YAA7B,OAAOA,OAAO,UAAU,EACzE,OAAO;IAEX,IAAIA,AAAgB,YAAhBA,OAAO,IAAI,EACX,OAAOK,aAAaL;IAExB,OAAO;AACX"}

package/features/formModel/jsonSchema/getJsonSchemaKind.test.d.ts

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

package/features/formModel/jsonSchema/getJsonSchemaKind.test.js

@@ -0,0 +1,123 @@
+import { describe, expect, it } from "vitest";
+import { getJsonSchemaKind } from "./getJsonSchemaKind.js";
+describe("getJsonSchemaKind", ()=>{
+    it("maps the scalar types", ()=>{
+        expect(getJsonSchemaKind({
+            type: "string"
+        })).toBe("string");
+        expect(getJsonSchemaKind({
+            type: "number"
+        })).toBe("number");
+        expect(getJsonSchemaKind({
+            type: "integer"
+        })).toBe("number");
+        expect(getJsonSchemaKind({
+            type: "boolean"
+        })).toBe("boolean");
+    });
+    it("maps a string or number enum to enum", ()=>{
+        expect(getJsonSchemaKind({
+            type: "string",
+            enum: [
+                "a",
+                "b"
+            ]
+        })).toBe("enum");
+        expect(getJsonSchemaKind({
+            type: "integer",
+            enum: [
+                1,
+                2
+            ]
+        })).toBe("enum");
+    });
+    it("falls back to json for an enum whose values do not match the type or that is empty", ()=>{
+        expect(getJsonSchemaKind({
+            type: "string",
+            enum: [
+                "a",
+                1
+            ]
+        })).toBe("json");
+        expect(getJsonSchemaKind({
+            type: "number",
+            enum: [
+                "a"
+            ]
+        })).toBe("json");
+        expect(getJsonSchemaKind({
+            type: "string",
+            enum: []
+        })).toBe("string");
+    });
+    it("maps an object with properties to object", ()=>{
+        expect(getJsonSchemaKind({
+            type: "object",
+            properties: {}
+        })).toBe("object");
+    });
+    it("maps an array of strings to stringList and an array of objects to objectList", ()=>{
+        expect(getJsonSchemaKind({
+            type: "array",
+            items: {
+                type: "string"
+            }
+        })).toBe("stringList");
+        expect(getJsonSchemaKind({
+            type: "array",
+            items: {
+                type: "object",
+                properties: {}
+            }
+        })).toBe("objectList");
+    });
+    it("falls back to json for everything else", ()=>{
+        const schemas = [
+            {},
+            {
+                type: "null"
+            },
+            {
+                type: "object"
+            },
+            {
+                type: "array"
+            },
+            {
+                type: "array",
+                items: {
+                    type: "number"
+                }
+            },
+            {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: [
+                        "a"
+                    ]
+                }
+            },
+            {
+                anyOf: [
+                    {
+                        type: "string"
+                    },
+                    {
+                        type: "null"
+                    }
+                ]
+            },
+            {
+                const: "x"
+            }
+        ];
+        for (const schema of schemas)expect(getJsonSchemaKind(schema)).toBe("json");
+    });
+    it("returns json for a value that is not a schema object", ()=>{
+        expect(getJsonSchemaKind(null)).toBe("json");
+        expect(getJsonSchemaKind("string")).toBe("json");
+    });
+});
+
+//# sourceMappingURL=getJsonSchemaKind.test.js.map

package/features/formModel/jsonSchema/getJsonSchemaKind.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/formModel/jsonSchema/getJsonSchemaKind.test.js","sources":["../../../../src/features/formModel/jsonSchema/getJsonSchemaKind.test.ts"],"sourcesContent":["import { describe } from \"vitest\";\nimport { expect } from \"vitest\";\nimport { it } from \"vitest\";\nimport type { JsonSchema } from \"./JsonSchema.js\";\nimport { getJsonSchemaKind } from \"./getJsonSchemaKind.js\";\n\ndescribe(\"getJsonSchemaKind\", () => {\n    it(\"maps the scalar types\", () => {\n        expect(getJsonSchemaKind({ type: \"string\" })).toBe(\"string\");\n        expect(getJsonSchemaKind({ type: \"number\" })).toBe(\"number\");\n        expect(getJsonSchemaKind({ type: \"integer\" })).toBe(\"number\");\n        expect(getJsonSchemaKind({ type: \"boolean\" })).toBe(\"boolean\");\n    });\n\n    it(\"maps a string or number enum to enum\", () => {\n        expect(getJsonSchemaKind({ type: \"string\", enum: [\"a\", \"b\"] })).toBe(\"enum\");\n        expect(getJsonSchemaKind({ type: \"integer\", enum: [1, 2] })).toBe(\"enum\");\n    });\n\n    it(\"falls back to json for an enum whose values do not match the type or that is empty\", () => {\n        expect(getJsonSchemaKind({ type: \"string\", enum: [\"a\", 1] })).toBe(\"json\");\n        expect(getJsonSchemaKind({ type: \"number\", enum: [\"a\"] })).toBe(\"json\");\n        expect(getJsonSchemaKind({ type: \"string\", enum: [] })).toBe(\"string\");\n    });\n\n    it(\"maps an object with properties to object\", () => {\n        expect(getJsonSchemaKind({ type: \"object\", properties: {} })).toBe(\"object\");\n    });\n\n    it(\"maps an array of strings to stringList and an array of objects to objectList\", () => {\n        expect(getJsonSchemaKind({ type: \"array\", items: { type: \"string\" } })).toBe(\"stringList\");\n        expect(\n            getJsonSchemaKind({ type: \"array\", items: { type: \"object\", properties: {} } })\n        ).toBe(\"objectList\");\n    });\n\n    it(\"falls back to json for everything else\", () => {\n        const schemas: JsonSchema[] = [\n            {},\n            { type: \"null\" },\n            { type: \"object\" },\n            { type: \"array\" },\n            { type: \"array\", items: { type: \"number\" } },\n            { type: \"array\", items: { type: \"string\", enum: [\"a\"] } },\n            { anyOf: [{ type: \"string\" }, { type: \"null\" }] },\n            { const: \"x\" }\n        ];\n\n        for (const schema of schemas) {\n            expect(getJsonSchemaKind(schema)).toBe(\"json\");\n        }\n    });\n\n    it(\"returns json for a value that is not a schema object\", () => {\n        expect(getJsonSchemaKind(null as unknown as JsonSchema)).toBe(\"json\");\n        expect(getJsonSchemaKind(\"string\" as unknown as JsonSchema)).toBe(\"json\");\n    });\n});\n"],"names":["describe","it","expect","getJsonSchemaKind","schemas","schema"],"mappings":";;AAMAA,SAAS,qBAAqB;IAC1BC,GAAG,yBAAyB;QACxBC,OAAOC,kBAAkB;YAAE,MAAM;QAAS,IAAI,IAAI,CAAC;QACnDD,OAAOC,kBAAkB;YAAE,MAAM;QAAS,IAAI,IAAI,CAAC;QACnDD,OAAOC,kBAAkB;YAAE,MAAM;QAAU,IAAI,IAAI,CAAC;QACpDD,OAAOC,kBAAkB;YAAE,MAAM;QAAU,IAAI,IAAI,CAAC;IACxD;IAEAF,GAAG,wCAAwC;QACvCC,OAAOC,kBAAkB;YAAE,MAAM;YAAU,MAAM;gBAAC;gBAAK;aAAI;QAAC,IAAI,IAAI,CAAC;QACrED,OAAOC,kBAAkB;YAAE,MAAM;YAAW,MAAM;gBAAC;gBAAG;aAAE;QAAC,IAAI,IAAI,CAAC;IACtE;IAEAF,GAAG,sFAAsF;QACrFC,OAAOC,kBAAkB;YAAE,MAAM;YAAU,MAAM;gBAAC;gBAAK;aAAE;QAAC,IAAI,IAAI,CAAC;QACnED,OAAOC,kBAAkB;YAAE,MAAM;YAAU,MAAM;gBAAC;aAAI;QAAC,IAAI,IAAI,CAAC;QAChED,OAAOC,kBAAkB;YAAE,MAAM;YAAU,MAAM,EAAE;QAAC,IAAI,IAAI,CAAC;IACjE;IAEAF,GAAG,4CAA4C;QAC3CC,OAAOC,kBAAkB;YAAE,MAAM;YAAU,YAAY,CAAC;QAAE,IAAI,IAAI,CAAC;IACvE;IAEAF,GAAG,gFAAgF;QAC/EC,OAAOC,kBAAkB;YAAE,MAAM;YAAS,OAAO;gBAAE,MAAM;YAAS;QAAE,IAAI,IAAI,CAAC;QAC7ED,OACIC,kBAAkB;YAAE,MAAM;YAAS,OAAO;gBAAE,MAAM;gBAAU,YAAY,CAAC;YAAE;QAAE,IAC/E,IAAI,CAAC;IACX;IAEAF,GAAG,0CAA0C;QACzC,MAAMG,UAAwB;YAC1B,CAAC;YACD;gBAAE,MAAM;YAAO;YACf;gBAAE,MAAM;YAAS;YACjB;gBAAE,MAAM;YAAQ;YAChB;gBAAE,MAAM;gBAAS,OAAO;oBAAE,MAAM;gBAAS;YAAE;YAC3C;gBAAE,MAAM;gBAAS,OAAO;oBAAE,MAAM;oBAAU,MAAM;wBAAC;qBAAI;gBAAC;YAAE;YACxD;gBAAE,OAAO;oBAAC;wBAAE,MAAM;oBAAS;oBAAG;wBAAE,MAAM;oBAAO;iBAAE;YAAC;YAChD;gBAAE,OAAO;YAAI;SAChB;QAED,KAAK,MAAMC,UAAUD,QACjBF,OAAOC,kBAAkBE,SAAS,IAAI,CAAC;IAE/C;IAEAJ,GAAG,wDAAwD;QACvDC,OAAOC,kBAAkB,OAAgC,IAAI,CAAC;QAC9DD,OAAOC,kBAAkB,WAAoC,IAAI,CAAC;IACtE;AACJ"}

package/features/formModel/jsonSchema/isPlainObject.d.ts

@@ -0,0 +1,2 @@
+import type { PlainObject } from "./PlainObject.js";
+export declare const isPlainObject: (value: unknown) => value is PlainObject;

package/features/formModel/jsonSchema/isPlainObject.js

@@ -0,0 +1,4 @@
+const isPlainObject = (value)=>"object" == typeof value && null !== value && !Array.isArray(value);
+export { isPlainObject };
+
+//# sourceMappingURL=isPlainObject.js.map

package/features/formModel/jsonSchema/isPlainObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/formModel/jsonSchema/isPlainObject.js","sources":["../../../../src/features/formModel/jsonSchema/isPlainObject.ts"],"sourcesContent":["import type { PlainObject } from \"./PlainObject.js\";\n\nexport const isPlainObject = (value: unknown): value is PlainObject => {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value);\n};\n"],"names":["isPlainObject","value","Array"],"mappings":"AAEO,MAAMA,gBAAgB,CAACC,QACnB,AAAiB,YAAjB,OAAOA,SAAsBA,AAAU,SAAVA,SAAkB,CAACC,MAAM,OAAO,CAACD"}

package/features/formModel/jsonSchema/jsonSchemaValueToFormData.d.ts

@@ -0,0 +1,3 @@
+import type { JsonSchema } from "./JsonSchema.js";
+import type { PlainObject } from "./PlainObject.js";
+export declare const jsonSchemaValueToFormData: (schema: JsonSchema, value: unknown) => PlainObject;

package/features/formModel/jsonSchema/jsonSchemaValueToFormData.js

@@ -0,0 +1,30 @@
+import { getJsonSchemaKind } from "./getJsonSchemaKind.js";
+import { normalizeJsonSchema } from "./normalizeJsonSchema.js";
+import { isPlainObject } from "./isPlainObject.js";
+const toFormValue = (schema, value)=>{
+    const kind = getJsonSchemaKind(schema);
+    const input = void 0 === value ? schema.default : value;
+    if ("object" === kind) return jsonSchemaValueToFormData(schema, input);
+    if ("objectList" === kind) {
+        const items = Array.isArray(input) ? input : [];
+        const itemSchema = normalizeJsonSchema(schema.items);
+        return items.map((item)=>jsonSchemaValueToFormData(itemSchema, item));
+    }
+    if ("stringList" === kind) return Array.isArray(input) ? input : [];
+    if ("json" === kind) return void 0 === input ? null : JSON.stringify(input, null, 2);
+    return void 0 === input ? null : input;
+};
+const jsonSchemaValueToFormData = (schema, value)=>{
+    const data = {};
+    if ("object" !== getJsonSchemaKind(schema)) return data;
+    const source = isPlainObject(value) ? value : {};
+    const properties = schema.properties ?? {};
+    for (const [name, property] of Object.entries(properties)){
+        const propertySchema = normalizeJsonSchema(property);
+        data[name] = toFormValue(propertySchema, source[name]);
+    }
+    return data;
+};
+export { jsonSchemaValueToFormData };
+
+//# sourceMappingURL=jsonSchemaValueToFormData.js.map

package/features/formModel/jsonSchema/jsonSchemaValueToFormData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/formModel/jsonSchema/jsonSchemaValueToFormData.js","sources":["../../../../src/features/formModel/jsonSchema/jsonSchemaValueToFormData.ts"],"sourcesContent":["import type { JsonSchema } from \"./JsonSchema.js\";\nimport { getJsonSchemaKind } from \"./getJsonSchemaKind.js\";\nimport { normalizeJsonSchema } from \"./normalizeJsonSchema.js\";\nimport { isPlainObject } from \"./isPlainObject.js\";\nimport type { PlainObject } from \"./PlainObject.js\";\n\nconst toFormValue = (schema: JsonSchema, value: unknown): unknown => {\n    const kind = getJsonSchemaKind(schema);\n    const input = value === undefined ? schema.default : value;\n\n    if (kind === \"object\") {\n        return jsonSchemaValueToFormData(schema, input);\n    }\n    if (kind === \"objectList\") {\n        const items = Array.isArray(input) ? input : [];\n        const itemSchema = normalizeJsonSchema(schema.items);\n        return items.map(item => jsonSchemaValueToFormData(itemSchema, item));\n    }\n    if (kind === \"stringList\") {\n        return Array.isArray(input) ? input : [];\n    }\n    if (kind === \"json\") {\n        return input === undefined ? null : JSON.stringify(input, null, 2);\n    }\n    return input === undefined ? null : input;\n};\n\n/*\n * Converts a stored value into form data for the fields `buildFieldsFromJsonSchema` builds\n * (R271): every property is present (its default, else `null`, `[]` for a list), a nested object\n * and each list item become form data too, and a JSON text field holds the stringified value.\n */\nexport const jsonSchemaValueToFormData = (schema: JsonSchema, value: unknown): PlainObject => {\n    const data: PlainObject = {};\n    if (getJsonSchemaKind(schema) !== \"object\") {\n        return data;\n    }\n\n    const source: PlainObject = isPlainObject(value) ? value : {};\n    const properties = schema.properties ?? {};\n\n    for (const [name, property] of Object.entries(properties)) {\n        const propertySchema = normalizeJsonSchema(property);\n        data[name] = toFormValue(propertySchema, source[name]);\n    }\n\n    return data;\n};\n"],"names":["toFormValue","schema","value","kind","getJsonSchemaKind","input","undefined","jsonSchemaValueToFormData","items","Array","itemSchema","normalizeJsonSchema","item","JSON","data","source","isPlainObject","properties","name","property","Object","propertySchema"],"mappings":";;;AAMA,MAAMA,cAAc,CAACC,QAAoBC;IACrC,MAAMC,OAAOC,kBAAkBH;IAC/B,MAAMI,QAAQH,AAAUI,WAAVJ,QAAsBD,OAAO,OAAO,GAAGC;IAErD,IAAIC,AAAS,aAATA,MACA,OAAOI,0BAA0BN,QAAQI;IAE7C,IAAIF,AAAS,iBAATA,MAAuB;QACvB,MAAMK,QAAQC,MAAM,OAAO,CAACJ,SAASA,QAAQ,EAAE;QAC/C,MAAMK,aAAaC,oBAAoBV,OAAO,KAAK;QACnD,OAAOO,MAAM,GAAG,CAACI,CAAAA,OAAQL,0BAA0BG,YAAYE;IACnE;IACA,IAAIT,AAAS,iBAATA,MACA,OAAOM,MAAM,OAAO,CAACJ,SAASA,QAAQ,EAAE;IAE5C,IAAIF,AAAS,WAATA,MACA,OAAOE,AAAUC,WAAVD,QAAsB,OAAOQ,KAAK,SAAS,CAACR,OAAO,MAAM;IAEpE,OAAOA,AAAUC,WAAVD,QAAsB,OAAOA;AACxC;AAOO,MAAME,4BAA4B,CAACN,QAAoBC;IAC1D,MAAMY,OAAoB,CAAC;IAC3B,IAAIV,AAA8B,aAA9BA,kBAAkBH,SAClB,OAAOa;IAGX,MAAMC,SAAsBC,cAAcd,SAASA,QAAQ,CAAC;IAC5D,MAAMe,aAAahB,OAAO,UAAU,IAAI,CAAC;IAEzC,KAAK,MAAM,CAACiB,MAAMC,SAAS,IAAIC,OAAO,OAAO,CAACH,YAAa;QACvD,MAAMI,iBAAiBV,oBAAoBQ;QAC3CL,IAAI,CAACI,KAAK,GAAGlB,YAAYqB,gBAAgBN,MAAM,CAACG,KAAK;IACzD;IAEA,OAAOJ;AACX"}

package/features/formModel/jsonSchema/jsonSchemaValueToFormData.test.d.ts

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

package/features/formModel/jsonSchema/jsonSchemaValueToFormData.test.js

@@ -0,0 +1,207 @@
+import { describe, expect, it } from "vitest";
+import { jsonSchemaValueToFormData } from "./jsonSchemaValueToFormData.js";
+const SCHEMA = {
+    type: "object",
+    properties: {
+        url: {
+            type: "string"
+        },
+        method: {
+            type: "string",
+            enum: [
+                "GET",
+                "POST"
+            ],
+            default: "POST"
+        },
+        timeout: {
+            type: "integer"
+        },
+        enabled: {
+            type: "boolean"
+        },
+        labels: {
+            type: "array",
+            items: {
+                type: "string"
+            }
+        },
+        auth: {
+            type: "object",
+            properties: {
+                user: {
+                    type: "string"
+                },
+                retries: {
+                    type: "integer",
+                    default: 3
+                }
+            }
+        },
+        headers: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string"
+                    },
+                    value: {
+                        type: "string"
+                    }
+                }
+            }
+        },
+        payload: {}
+    }
+};
+describe("jsonSchemaValueToFormData", ()=>{
+    it("fills every property of an empty value with its default, null or an empty list", ()=>{
+        expect(jsonSchemaValueToFormData(SCHEMA, {})).toEqual({
+            url: null,
+            method: "POST",
+            timeout: null,
+            enabled: null,
+            labels: [],
+            auth: {
+                user: null,
+                retries: 3
+            },
+            headers: [],
+            payload: null
+        });
+    });
+    it("keeps the stored scalars, lists and nested values", ()=>{
+        const stored = {
+            url: "https://a.test",
+            method: "GET",
+            timeout: 30,
+            enabled: false,
+            labels: [
+                "a",
+                "b"
+            ],
+            auth: {
+                user: "ana"
+            },
+            headers: [
+                {
+                    name: "X-Id",
+                    value: "1"
+                },
+                {
+                    name: "X-Team"
+                }
+            ]
+        };
+        expect(jsonSchemaValueToFormData(SCHEMA, stored)).toEqual({
+            url: "https://a.test",
+            method: "GET",
+            timeout: 30,
+            enabled: false,
+            labels: [
+                "a",
+                "b"
+            ],
+            auth: {
+                user: "ana",
+                retries: 3
+            },
+            headers: [
+                {
+                    name: "X-Id",
+                    value: "1"
+                },
+                {
+                    name: "X-Team",
+                    value: null
+                }
+            ],
+            payload: null
+        });
+    });
+    it("stringifies the value of a JSON field with two spaces of indent", ()=>{
+        const data = jsonSchemaValueToFormData(SCHEMA, {
+            payload: {
+                a: [
+                    1,
+                    2
+                ]
+            }
+        });
+        expect(data.payload).toBe('{\n  "a": [\n    1,\n    2\n  ]\n}');
+    });
+    it("stringifies a JSON field's default when nothing is stored", ()=>{
+        const schema = {
+            type: "object",
+            properties: {
+                payload: {
+                    default: {
+                        a: 1
+                    }
+                }
+            }
+        };
+        expect(jsonSchemaValueToFormData(schema, {}).payload).toBe('{\n  "a": 1\n}');
+    });
+    it("uses a default object when the nested object is not stored", ()=>{
+        const schema = {
+            type: "object",
+            properties: {
+                auth: {
+                    type: "object",
+                    properties: {
+                        user: {
+                            type: "string"
+                        }
+                    },
+                    default: {
+                        user: "bot"
+                    }
+                }
+            }
+        };
+        expect(jsonSchemaValueToFormData(schema, {})).toEqual({
+            auth: {
+                user: "bot"
+            }
+        });
+    });
+    it("treats a value that is not an object, or a wrong list value, as empty", ()=>{
+        expect(jsonSchemaValueToFormData(SCHEMA, null).labels).toEqual([]);
+        expect(jsonSchemaValueToFormData(SCHEMA, "text").labels).toEqual([]);
+        expect(jsonSchemaValueToFormData(SCHEMA, [
+            1
+        ]).headers).toEqual([]);
+        expect(jsonSchemaValueToFormData(SCHEMA, {
+            labels: "a",
+            headers: "b"
+        })).toMatchObject({
+            labels: [],
+            headers: []
+        });
+    });
+    it("returns no data for a schema that is not an object", ()=>{
+        expect(jsonSchemaValueToFormData({
+            type: "string"
+        }, "x")).toEqual({});
+        expect(jsonSchemaValueToFormData({}, {
+            a: 1
+        })).toEqual({});
+    });
+    it("does not crash on a property that is not a schema", ()=>{
+        const properties = {
+            broken: null
+        };
+        expect(jsonSchemaValueToFormData({
+            type: "object",
+            properties
+        }, {
+            broken: 1
+        })).toEqual({
+            broken: "1"
+        });
+    });
+});
+
+//# sourceMappingURL=jsonSchemaValueToFormData.test.js.map

package/features/formModel/jsonSchema/jsonSchemaValueToFormData.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/formModel/jsonSchema/jsonSchemaValueToFormData.test.js","sources":["../../../../src/features/formModel/jsonSchema/jsonSchemaValueToFormData.test.ts"],"sourcesContent":["import { describe } from \"vitest\";\nimport { expect } from \"vitest\";\nimport { it } from \"vitest\";\nimport type { JsonSchema } from \"./JsonSchema.js\";\nimport { jsonSchemaValueToFormData } from \"./jsonSchemaValueToFormData.js\";\n\nconst SCHEMA: JsonSchema = {\n    type: \"object\",\n    properties: {\n        url: { type: \"string\" },\n        method: { type: \"string\", enum: [\"GET\", \"POST\"], default: \"POST\" },\n        timeout: { type: \"integer\" },\n        enabled: { type: \"boolean\" },\n        labels: { type: \"array\", items: { type: \"string\" } },\n        auth: {\n            type: \"object\",\n            properties: { user: { type: \"string\" }, retries: { type: \"integer\", default: 3 } }\n        },\n        headers: {\n            type: \"array\",\n            items: {\n                type: \"object\",\n                properties: { name: { type: \"string\" }, value: { type: \"string\" } }\n            }\n        },\n        payload: {}\n    }\n};\n\ndescribe(\"jsonSchemaValueToFormData\", () => {\n    it(\"fills every property of an empty value with its default, null or an empty list\", () => {\n        expect(jsonSchemaValueToFormData(SCHEMA, {})).toEqual({\n            url: null,\n            method: \"POST\",\n            timeout: null,\n            enabled: null,\n            labels: [],\n            auth: { user: null, retries: 3 },\n            headers: [],\n            payload: null\n        });\n    });\n\n    it(\"keeps the stored scalars, lists and nested values\", () => {\n        const stored = {\n            url: \"https://a.test\",\n            method: \"GET\",\n            timeout: 30,\n            enabled: false,\n            labels: [\"a\", \"b\"],\n            auth: { user: \"ana\" },\n            headers: [{ name: \"X-Id\", value: \"1\" }, { name: \"X-Team\" }]\n        };\n\n        expect(jsonSchemaValueToFormData(SCHEMA, stored)).toEqual({\n            url: \"https://a.test\",\n            method: \"GET\",\n            timeout: 30,\n            enabled: false,\n            labels: [\"a\", \"b\"],\n            auth: { user: \"ana\", retries: 3 },\n            headers: [\n                { name: \"X-Id\", value: \"1\" },\n                { name: \"X-Team\", value: null }\n            ],\n            payload: null\n        });\n    });\n\n    it(\"stringifies the value of a JSON field with two spaces of indent\", () => {\n        const data = jsonSchemaValueToFormData(SCHEMA, { payload: { a: [1, 2] } });\n\n        expect(data.payload).toBe('{\\n  \"a\": [\\n    1,\\n    2\\n  ]\\n}');\n    });\n\n    it(\"stringifies a JSON field's default when nothing is stored\", () => {\n        const schema: JsonSchema = {\n            type: \"object\",\n            properties: { payload: { default: { a: 1 } } }\n        };\n\n        expect(jsonSchemaValueToFormData(schema, {}).payload).toBe('{\\n  \"a\": 1\\n}');\n    });\n\n    it(\"uses a default object when the nested object is not stored\", () => {\n        const schema: JsonSchema = {\n            type: \"object\",\n            properties: {\n                auth: {\n                    type: \"object\",\n                    properties: { user: { type: \"string\" } },\n                    default: { user: \"bot\" }\n                }\n            }\n        };\n\n        expect(jsonSchemaValueToFormData(schema, {})).toEqual({ auth: { user: \"bot\" } });\n    });\n\n    it(\"treats a value that is not an object, or a wrong list value, as empty\", () => {\n        expect(jsonSchemaValueToFormData(SCHEMA, null).labels).toEqual([]);\n        expect(jsonSchemaValueToFormData(SCHEMA, \"text\").labels).toEqual([]);\n        expect(jsonSchemaValueToFormData(SCHEMA, [1]).headers).toEqual([]);\n        expect(jsonSchemaValueToFormData(SCHEMA, { labels: \"a\", headers: \"b\" })).toMatchObject({\n            labels: [],\n            headers: []\n        });\n    });\n\n    it(\"returns no data for a schema that is not an object\", () => {\n        expect(jsonSchemaValueToFormData({ type: \"string\" }, \"x\")).toEqual({});\n        expect(jsonSchemaValueToFormData({}, { a: 1 })).toEqual({});\n    });\n\n    it(\"does not crash on a property that is not a schema\", () => {\n        const properties = { broken: null } as unknown as Record<string, JsonSchema>;\n\n        expect(jsonSchemaValueToFormData({ type: \"object\", properties }, { broken: 1 })).toEqual({\n            broken: \"1\"\n        });\n    });\n});\n"],"names":["SCHEMA","describe","it","expect","jsonSchemaValueToFormData","stored","data","schema","properties"],"mappings":"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"}

package/features/formModel/jsonSchema/normalizeJsonSchema.d.ts

@@ -0,0 +1,2 @@
+import type { JsonSchema } from "./JsonSchema.js";
+export declare const normalizeJsonSchema: (schema: unknown) => JsonSchema;

package/features/formModel/jsonSchema/normalizeJsonSchema.js

@@ -0,0 +1,10 @@
+const normalizeJsonSchema = (schema)=>{
+    if ("object" == typeof schema && null !== schema && !Array.isArray(schema)) {
+        const normalized = schema;
+        return normalized;
+    }
+    return {};
+};
+export { normalizeJsonSchema };
+
+//# sourceMappingURL=normalizeJsonSchema.js.map

package/features/formModel/jsonSchema/normalizeJsonSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/formModel/jsonSchema/normalizeJsonSchema.js","sources":["../../../../src/features/formModel/jsonSchema/normalizeJsonSchema.ts"],"sourcesContent":["import type { JsonSchema } from \"./JsonSchema.js\";\n\n/*\n * A schema value that is not an object (a stored `null`, a boolean schema) has no keywords the\n * adapter can read, so it becomes the empty schema, which renders as a JSON text field.\n */\nexport const normalizeJsonSchema = (schema: unknown): JsonSchema => {\n    if (typeof schema === \"object\" && schema !== null && !Array.isArray(schema)) {\n        const normalized = schema as JsonSchema;\n        return normalized;\n    }\n    return {};\n};\n"],"names":["normalizeJsonSchema","schema","Array","normalized"],"mappings":"AAMO,MAAMA,sBAAsB,CAACC;IAChC,IAAI,AAAkB,YAAlB,OAAOA,UAAuBA,AAAW,SAAXA,UAAmB,CAACC,MAAM,OAAO,CAACD,SAAS;QACzE,MAAME,aAAaF;QACnB,OAAOE;IACX;IACA,OAAO,CAAC;AACZ"}

package/features/formModel/renderers.d.ts

@@ -16,6 +16,7 @@ import "../../base/Base/FieldRenderers/RadioButtonsRenderer.js";
 import "../../base/Base/FieldRenderers/CheckboxesRenderer.js";
 import "../../base/Base/FieldRenderers/DateTimeRenderer.js";
 import "../../base/Base/FieldRenderers/DateTimeInputsRenderer.js";
+import "../../base/Base/FieldRenderers/BirthdayInputRenderer.js";
 import "../../base/Base/FieldRenderers/HiddenRenderer.js";
 import "../../base/Base/FieldRenderers/FilePickerRenderer.js";
 import "../../base/Base/FieldRenderers/CodeEditorRenderer.js";

package/features/formModel/renderers.js

@@ -16,6 +16,7 @@ import "../../base/Base/FieldRenderers/RadioButtonsRenderer.js";
 import "../../base/Base/FieldRenderers/CheckboxesRenderer.js";
 import "../../base/Base/FieldRenderers/DateTimeRenderer.js";
 import "../../base/Base/FieldRenderers/DateTimeInputsRenderer.js";
+import "../../base/Base/FieldRenderers/BirthdayInputRenderer.js";
 import "../../base/Base/FieldRenderers/HiddenRenderer.js";
 import "../../base/Base/FieldRenderers/FilePickerRenderer.js";
 import "../../base/Base/FieldRenderers/CodeEditorRenderer.js";

package/features/notifications/Notifications.d.ts

@@ -6,6 +6,7 @@ declare class NotificationsImpl implements Abstraction.Interface {
     notify(input: INotificationInput): void;
     success(input: INotificationInput): void;
     warning(input: INotificationInput): void;
+    error(input: INotificationInput): void;
     getNotifications(): INotification[];
     remove(id: string): void;
     private push;

package/features/notifications/Notifications.js

@@ -15,6 +15,9 @@ class NotificationsImpl {
     warning(input) {
         this.push(input, "warning");
     }
+    error(input) {
+        this.push(input, "error");
+    }
     getNotifications() {
         return this.notifications;
     }

package/features/notifications/Notifications.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/notifications/Notifications.js","sources":["../../../src/features/notifications/Notifications.ts"],"sourcesContent":["import { makeAutoObservable } from \"mobx\";\nimport {\n    Notifications as Abstraction,\n    type INotification,\n    type INotificationInput,\n    type NotificationVariant\n} from \"./abstractions.js\";\n\nclass NotificationsImpl implements Abstraction.Interface {\n    private notifications: INotification[] = [];\n    private counter = 0;\n\n    constructor() {\n        makeAutoObservable(this);\n    }\n\n    notify(input: INotificationInput): void {\n        this.push(input, \"default\");\n    }\n\n    success(input: INotificationInput): void {\n        this.push(input, \"success\");\n    }\n\n    warning(input: INotificationInput): void {\n        this.push(input, \"warning\");\n    }\n\n    getNotifications(): INotification[] {\n        return this.notifications;\n    }\n\n    remove(id: string): void {\n        this.notifications = this.notifications.filter(notification => notification.id !== id);\n    }\n\n    private push(input: INotificationInput, variant: NotificationVariant): void {\n        this.counter++;\n        this.notifications.push({ id: `notification-${this.counter}`, variant, ...input });\n    }\n}\n\nexport const Notifications = Abstraction.createImplementation({\n    implementation: NotificationsImpl,\n    dependencies: []\n});\n"],"names":["NotificationsImpl","makeAutoObservable","input","id","notification","variant","Notifications","Abstraction"],"mappings":";;AAQA,MAAMA;IAIF,aAAc;aAHN,aAAa,GAAoB,EAAE;aACnC,OAAO,GAAG;QAGdC,mBAAmB,IAAI;IAC3B;IAEA,OAAOC,KAAyB,EAAQ;QACpC,IAAI,CAAC,IAAI,CAACA,OAAO;IACrB;IAEA,QAAQA,KAAyB,EAAQ;QACrC,IAAI,CAAC,IAAI,CAACA,OAAO;IACrB;IAEA,QAAQA,KAAyB,EAAQ;QACrC,IAAI,CAAC,IAAI,CAACA,OAAO;IACrB;IAEA,mBAAoC;QAChC,OAAO,IAAI,CAAC,aAAa;IAC7B;IAEA,OAAOC,EAAU,EAAQ;QACrB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAACC,CAAAA,eAAgBA,aAAa,EAAE,KAAKD;IACvF;IAEQ,KAAKD,KAAyB,EAAEG,OAA4B,EAAQ;QACxE,IAAI,CAAC,OAAO;QACZ,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;YAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,OAAO,EAAE;YAAEA;YAAS,GAAGH,KAAK;QAAC;IACpF;AACJ;AAEO,MAAMI,8BAAgBC,cAAAA,oBAAgC,CAAC;IAC1D,gBAAgBP;IAChB,cAAc,EAAE;AACpB"}
+{"version":3,"file":"features/notifications/Notifications.js","sources":["../../../src/features/notifications/Notifications.ts"],"sourcesContent":["import { makeAutoObservable } from \"mobx\";\nimport {\n    Notifications as Abstraction,\n    type INotification,\n    type INotificationInput,\n    type NotificationVariant\n} from \"./abstractions.js\";\n\nclass NotificationsImpl implements Abstraction.Interface {\n    private notifications: INotification[] = [];\n    private counter = 0;\n\n    constructor() {\n        makeAutoObservable(this);\n    }\n\n    notify(input: INotificationInput): void {\n        this.push(input, \"default\");\n    }\n\n    success(input: INotificationInput): void {\n        this.push(input, \"success\");\n    }\n\n    warning(input: INotificationInput): void {\n        this.push(input, \"warning\");\n    }\n\n    error(input: INotificationInput): void {\n        this.push(input, \"error\");\n    }\n\n    getNotifications(): INotification[] {\n        return this.notifications;\n    }\n\n    remove(id: string): void {\n        this.notifications = this.notifications.filter(notification => notification.id !== id);\n    }\n\n    private push(input: INotificationInput, variant: NotificationVariant): void {\n        this.counter++;\n        this.notifications.push({ id: `notification-${this.counter}`, variant, ...input });\n    }\n}\n\nexport const Notifications = Abstraction.createImplementation({\n    implementation: NotificationsImpl,\n    dependencies: []\n});\n"],"names":["NotificationsImpl","makeAutoObservable","input","id","notification","variant","Notifications","Abstraction"],"mappings":";;AAQA,MAAMA;IAIF,aAAc;aAHN,aAAa,GAAoB,EAAE;aACnC,OAAO,GAAG;QAGdC,mBAAmB,IAAI;IAC3B;IAEA,OAAOC,KAAyB,EAAQ;QACpC,IAAI,CAAC,IAAI,CAACA,OAAO;IACrB;IAEA,QAAQA,KAAyB,EAAQ;QACrC,IAAI,CAAC,IAAI,CAACA,OAAO;IACrB;IAEA,QAAQA,KAAyB,EAAQ;QACrC,IAAI,CAAC,IAAI,CAACA,OAAO;IACrB;IAEA,MAAMA,KAAyB,EAAQ;QACnC,IAAI,CAAC,IAAI,CAACA,OAAO;IACrB;IAEA,mBAAoC;QAChC,OAAO,IAAI,CAAC,aAAa;IAC7B;IAEA,OAAOC,EAAU,EAAQ;QACrB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAACC,CAAAA,eAAgBA,aAAa,EAAE,KAAKD;IACvF;IAEQ,KAAKD,KAAyB,EAAEG,OAA4B,EAAQ;QACxE,IAAI,CAAC,OAAO;QACZ,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;YAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,OAAO,EAAE;YAAEA;YAAS,GAAGH,KAAK;QAAC;IACpF;AACJ;AAEO,MAAMI,8BAAgBC,cAAAA,oBAAgC,CAAC;IAC1D,gBAAgBP;IAChB,cAAc,EAAE;AACpB"}

package/features/notifications/Notifications.test.d.ts

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

package/features/notifications/Notifications.test.js

@@ -0,0 +1,106 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { Container } from "@webiny/di";
+import { NotificationsFeature } from "./feature.js";
+import { Notifications } from "./abstractions.js";
+const createNotifications = ()=>{
+    const container = new Container();
+    NotificationsFeature.register(container);
+    return container.resolve(Notifications);
+};
+describe("Notifications", ()=>{
+    let notifications;
+    beforeEach(()=>{
+        notifications = createNotifications();
+    });
+    it("queues a plain notification with exactly its own fields", ()=>{
+        notifications.notify({
+            title: "Saved",
+            description: "All good."
+        });
+        expect(notifications.getNotifications()).toEqual([
+            {
+                id: "notification-1",
+                variant: "default",
+                title: "Saved",
+                description: "All good."
+            }
+        ]);
+    });
+    it("queues success and warning notifications with their variant", ()=>{
+        notifications.success({
+            title: "Done"
+        });
+        notifications.warning({
+            title: "Careful"
+        });
+        const queued = notifications.getNotifications();
+        expect(queued.map((item)=>item.variant)).toEqual([
+            "success",
+            "warning"
+        ]);
+        expect(queued.map((item)=>item.id)).toEqual([
+            "notification-1",
+            "notification-2"
+        ]);
+    });
+    it("queues an error notification with the error variant", ()=>{
+        notifications.error({
+            title: "Failed",
+            description: "Try again."
+        });
+        expect(notifications.getNotifications()).toEqual([
+            {
+                id: "notification-1",
+                variant: "error",
+                title: "Failed",
+                description: "Try again."
+            }
+        ]);
+    });
+    it("keeps link, duration, position and dismissible on the queued notification", ()=>{
+        notifications.success({
+            title: "Requested",
+            description: "Spring launch",
+            link: {
+                label: "Open Content Reviews",
+                url: "/cms/content-reviews"
+            },
+            duration: 8000,
+            position: "bottom-right",
+            dismissible: true
+        });
+        expect(notifications.getNotifications()).toEqual([
+            {
+                id: "notification-1",
+                variant: "success",
+                title: "Requested",
+                description: "Spring launch",
+                link: {
+                    label: "Open Content Reviews",
+                    url: "/cms/content-reviews"
+                },
+                duration: 8000,
+                position: "bottom-right",
+                dismissible: true
+            }
+        ]);
+    });
+    it("removes a notification by id and leaves the others", ()=>{
+        notifications.notify({
+            title: "One"
+        });
+        notifications.error({
+            title: "Two"
+        });
+        notifications.warning({
+            title: "Three"
+        });
+        notifications.remove("notification-2");
+        expect(notifications.getNotifications().map((item)=>item.title)).toEqual([
+            "One",
+            "Three"
+        ]);
+    });
+});
+
+//# sourceMappingURL=Notifications.test.js.map