json-schema-library 5.3.0 → 7.0.0

package/dist/module/lib/getTemplate.js

@@ -4,6 +4,7 @@ import getTypeOf from "./getTypeOf";
 import merge from "./utils/merge";
 import copy from "./utils/copy";
 import settings from "./config/settings";
+import { isJSONError } from "./types";
 const defaultOptions = {
     addOptionalProps: true
 };
@@ -17,7 +18,7 @@ function shouldResolveRef(schema, pointer) {
     if ($ref == null) {
         return true;
     }
-    const value = (cache[pointer] == null || cache[pointer][$ref] == null) ? 0 : cache[pointer][$ref];
+    const value = cache[pointer] == null || cache[pointer][$ref] == null ? 0 : cache[pointer][$ref];
     return value < settings.GET_TEMPLATE_RECURSION_LIMIT;
 }
 function resolveRef(core, schema, pointer) {
@@ -118,13 +119,16 @@ function getTemplate(core, data, _schema, pointer, opts) {
         return undefined;
     }
     pointer = schema.pointer;
+    if (schema === null || schema === void 0 ? void 0 : schema.const) {
+        return schema.const;
+    }
     if (schema.oneOf) {
         // find correct schema for data
         const resolvedSchema = resolveOneOfFuzzy(core, data, schema);
-        if (data == null && resolvedSchema.type === "error") {
+        if (data == null && isJSONError(resolvedSchema)) {
             schema = schema.oneOf[0];
         }
-        else if (resolvedSchema.type === "error") {
+        else if (isJSONError(resolvedSchema.type)) {
             // @todo - check: do not return schema, but either input-data or undefined (clearing wrong data)
             return data;
         }
@@ -132,6 +136,9 @@ function getTemplate(core, data, _schema, pointer, opts) {
             schema = resolvedSchema;
         }
     }
+    // @todo Array.isArray(schema.type)
+    // -> hasDefault? return
+    // if not -> pick first type
     if (!isJSONSchema(schema) || schema.type == null) {
         return undefined;
     }
@@ -139,23 +146,25 @@ function getTemplate(core, data, _schema, pointer, opts) {
     if (data != null && getTypeOf(data) !== schema.type) {
         data = convertValue(schema.type, data);
     }
-    if (TYPE[schema.type] == null) { // eslint-disable-line no-use-before-define
+    if (TYPE[schema.type] == null) {
+        // eslint-disable-line no-use-before-define
         throw new Error(`Unsupported type '${schema.type} in ${JSON.stringify(schema)}'`);
     }
     const templateData = TYPE[schema.type](core, schema, data, pointer, opts); // eslint-disable-line no-use-before-define
     return templateData;
 }
 const TYPE = {
-    "string": (core, schema, data) => getDefault(schema, data, ""),
-    "number": (core, schema, data) => getDefault(schema, data, 0),
-    "integer": (core, schema, data) => getDefault(schema, data, 0),
-    "boolean": (core, schema, data) => getDefault(schema, data, false),
-    "object": (core, schema, data, pointer, opts) => {
+    null: (core, schema, data) => getDefault(schema, data, null),
+    string: (core, schema, data) => getDefault(schema, data, ""),
+    number: (core, schema, data) => getDefault(schema, data, 0),
+    integer: (core, schema, data) => getDefault(schema, data, 0),
+    boolean: (core, schema, data) => getDefault(schema, data, false),
+    object: (core, schema, data, pointer, opts) => {
         const template = schema.default === undefined ? {} : schema.default;
         const d = {}; // do not assign data here, to keep ordering from json-schema
         if (schema.properties) {
-            Object.keys(schema.properties).forEach(key => {
-                const value = (data == null || data[key] == null) ? template[key] : data[key];
+            Object.keys(schema.properties).forEach((key) => {
+                const value = data == null || data[key] == null ? template[key] : data[key];
                 const isRequired = Array.isArray(schema.required) && schema.required.includes(key);
                 // Omit adding a property if it is not required or optional props should be added
                 if (value != null || isRequired || opts.addOptionalProps) {
@@ -163,18 +172,33 @@ const TYPE = {
                 }
             });
         }
+        if (schema.dependencies) {
+            Object.keys(schema.dependencies).forEach((key) => {
+                const dependency = schema.dependencies[key];
+                if (getTypeOf(dependency) !== "object") {
+                    return;
+                }
+                if (d[key] === undefined) {
+                    return;
+                }
+                const result = getTemplate(core, data, { ...dependency, type: "object" }, `${pointer}/dependencies/${key}`, opts);
+                if (result && !isJSONError(result)) {
+                    Object.assign(d, result);
+                }
+            });
+        }
         if (data) {
             // merge any missing data (additionals) to resulting object
-            Object.keys(data).forEach(key => (d[key] == null && (d[key] = data[key])));
+            Object.keys(data).forEach((key) => d[key] == null && (d[key] = data[key]));
         }
         // returns object, which is ordered by json-schema
         return d;
     },
     // build array type of items, ignores additionalItems
-    "array": (core, schema, data, pointer, opts) => {
+    array: (core, schema, data, pointer, opts) => {
         const template = schema.default === undefined ? [] : schema.default;
-        const d = data || [];
         schema.minItems = schema.minItems || 0;
+        const d = data || [];
         // items are undefined
         if (schema.items == null) {
             return d;
@@ -232,6 +256,9 @@ function getDefault(schema, templateValue, initValue) {
     if (templateValue != null) {
         return templateValue;
     }
+    else if (schema.const) {
+        return schema.const;
+    }
     else if (schema.default === undefined && Array.isArray(schema.enum)) {
         return schema.enum[0];
     }
@@ -241,6 +268,6 @@ function getDefault(schema, templateValue, initValue) {
     return schema.default;
 }
 export default (core, data, schema = core.rootSchema, opts = defaultOptions) => {
-    cache = { "mi": ".." };
+    cache = { mi: {} };
     return getTemplate(core, data, schema, "#", opts);
 };

package/dist/module/lib/jsoneditor/index.js

@@ -0,0 +1,16 @@
+import merge from "../utils/merge";
+import resolveOneOf from "../resolveOneOf.fuzzy";
+import resolveRef from "../resolveRef.merge";
+import { Draft } from "../draft";
+import { draft07Config } from "../draft07";
+const draftJsonEditorConfig = {
+    ...draft07Config,
+    resolveOneOf,
+    resolveRef
+};
+class JsonEditor extends Draft {
+    constructor(schema, config = {}) {
+        super(merge(draftJsonEditorConfig, config), schema);
+    }
+}
+export { JsonEditor, draftJsonEditorConfig };

package/dist/module/lib/resolveAllOf.js

@@ -1,13 +1,12 @@
 import copy from "./utils/copy";
 import merge from "./utils/merge";
-import errors from "./validation/errors";
 export default function resolveAllOf(core, data, schema = core.rootSchema, pointer = "#") {
     let mergedSchema = copy(schema);
     for (let i = 0; i < schema.allOf.length; i += 1) {
         const allOfSchema = core.resolveRef(schema.allOf[i]);
-        if (core.isValid(data, allOfSchema, pointer) === false) {
-            return errors.allOfError({ value: data, pointer, allOf: JSON.stringify(schema.allOf) });
-        }
+        // if (core.isValid(data, allOfSchema, pointer) === false) {
+        //     return errors.allOfError({ value: data, pointer, allOf: JSON.stringify(schema.allOf) });
+        // }
         mergedSchema = merge(mergedSchema, allOfSchema);
     }
     delete mergedSchema.allOf;

package/dist/module/lib/resolveOneOf.fuzzy.js

@@ -2,6 +2,7 @@ import { errorOrPromise } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
 import getTypeOf from "./getTypeOf";
 import settings from "./config/settings";
+import { isJSONError } from "./types";
 const { DECLARATOR_ONEOF } = settings;
 /**
  * Returns a ranking for the data and given schema
@@ -52,7 +53,7 @@ export default function resolveOneOf(core, data, schema = core.rootSchema, point
         for (let i = 0; i < schema.oneOf.length; i += 1) {
             const one = core.resolveRef(schema.oneOf[i]);
             const oneOfPropertySchema = core.step(oneOfProperty, one, data, pointer);
-            if (oneOfPropertySchema && oneOfPropertySchema.type === "error") {
+            if (isJSONError(oneOfPropertySchema)) {
                 return oneOfPropertySchema;
             }
             let result = flattenArray(core.validate(oneOfValue, oneOfPropertySchema, pointer));
@@ -64,7 +65,12 @@ export default function resolveOneOf(core, data, schema = core.rootSchema, point
                 return one; // return resolved schema
             }
         }
-        return core.errors.oneOfPropertyError({ property: oneOfProperty, value: oneOfValue, pointer, errors });
+        return core.errors.oneOfPropertyError({
+            property: oneOfProperty,
+            value: oneOfValue,
+            pointer,
+            errors
+        });
     }
     // keyword: oneOf
     const matches = [];
@@ -90,7 +96,11 @@ export default function resolveOneOf(core, data, schema = core.rootSchema, point
             }
         }
         if (schemaOfItem === undefined) {
-            return core.errors.oneOfError({ value: JSON.stringify(data), pointer, oneOf: schema.oneOf });
+            return core.errors.oneOfError({
+                value: JSON.stringify(data),
+                pointer,
+                oneOf: schema.oneOf
+            });
         }
         return schemaOfItem;
     }

package/dist/module/lib/resolveOneOf.strict.js

@@ -1,5 +1,8 @@
 import { errorOrPromise } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
+import settings from "./config/settings";
+import { isJSONError } from "./types";
+const { DECLARATOR_ONEOF } = settings;
 /**
  * Selects and returns a oneOf schema for the given data
  *
@@ -10,6 +13,41 @@ import flattenArray from "./utils/flattenArray";
  * @return oneOf schema or an error
  */
 export default function resolveOneOf(core, data, schema = core.rootSchema, pointer = "#") {
+    // !keyword: oneOfProperty
+    // an additional <DECLARATOR_ONEOF> (default `oneOfProperty`) on the schema will exactly determine the
+    // oneOf value (if set in data)
+    // @fixme
+    // abort if no data is given an DECLARATOR_ONEOF is set (used by getChildSchemaSelection)
+    // this case (data != null) should not be necessary
+    if (data != null && schema[DECLARATOR_ONEOF]) {
+        const errors = [];
+        const oneOfProperty = schema[DECLARATOR_ONEOF];
+        const oneOfValue = data[schema[DECLARATOR_ONEOF]];
+        if (oneOfValue === undefined) {
+            return core.errors.missingOneOfPropertyError({ property: oneOfProperty, pointer });
+        }
+        for (let i = 0; i < schema.oneOf.length; i += 1) {
+            const one = core.resolveRef(schema.oneOf[i]);
+            const oneOfPropertySchema = core.step(oneOfProperty, one, data, pointer);
+            if (isJSONError(oneOfPropertySchema)) {
+                return oneOfPropertySchema;
+            }
+            let result = flattenArray(core.validate(oneOfValue, oneOfPropertySchema, pointer));
+            result = result.filter(errorOrPromise);
+            if (result.length > 0) {
+                errors.push(...result);
+            }
+            else {
+                return one; // return resolved schema
+            }
+        }
+        return core.errors.oneOfPropertyError({
+            property: oneOfProperty,
+            value: oneOfValue,
+            pointer,
+            errors
+        });
+    }
     const matches = [];
     const errors = [];
     for (let i = 0; i < schema.oneOf.length; i += 1) {
@@ -27,7 +65,16 @@ export default function resolveOneOf(core, data, schema = core.rootSchema, point
         return matches[0];
     }
     if (matches.length > 1) {
-        return core.errors.multipleOneOfError({ value: data, pointer, matches });
+        return core.errors.multipleOneOfError({
+            value: data,
+            pointer,
+            matches
+        });
     }
-    return core.errors.oneOfError({ value: JSON.stringify(data), pointer, oneOf: schema.oneOf, errors });
+    return core.errors.oneOfError({
+        value: JSON.stringify(data),
+        pointer,
+        oneOf: schema.oneOf,
+        errors
+    });
 }

package/dist/module/lib/resolveRef.strict.js

@@ -2,6 +2,14 @@ export default function resolveRef(schema, rootSchema) {
     if (schema == null || schema.$ref == null) {
         return schema;
     }
+    if (schema.getRoot) {
+        // we actually always need to resolve the schema like this, since returned subschemas
+        // must resolve relative from their schema
+        const resolvedSchema = schema.getRoot().getRef(schema);
+        // console.log(schema.$ref, "=>", resolvedSchema);
+        return resolvedSchema;
+    }
+    // tryout - this should never be called, except we missed something
     const resolvedSchema = rootSchema.getRef(schema);
     return resolvedSchema;
 }

package/dist/module/lib/schema/getTypeDefs.js

@@ -2,7 +2,7 @@ import gp from "gson-pointer";
 import { get } from "gson-query";
 import getTypeId from "./getTypeId";
 import types from "./types";
-const isObject = value => Object.prototype.toString.call(value) === "[object Object]";
+const isObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
 /**
  * Returns a list of all (direct) type definitions from the given schema
  * @param schema
@@ -14,11 +14,22 @@ export default function getTypeDefs(schema) {
     if (id == null) {
         return defs;
     }
-    const type = types[id];
+    let type;
+    if (Array.isArray(id)) {
+        // since types can also be declared as a set of types, merge the definitions
+        // maybe this will require a more sophisticated approach
+        type = {};
+        for (let i = 0, l = id.length; i < l; i += 1) {
+            Object.assign(type, types[id[i]]);
+        }
+    }
+    else {
+        type = types[id];
+    }
     if (type.definitions == null) {
         return defs;
     }
-    type.definitions.forEach(query => {
+    type.definitions.forEach((query) => {
         get(schema, query, (value, key, parent, pointer) => {
             if (isObject(value) && getTypeId(value)) {
                 defs.push({ pointer: gp.join(gp.split(pointer), false), def: value });

package/dist/module/lib/schema/getTypeId.js

@@ -1,6 +1,7 @@
 import types from "./types";
-const isObject = value => Object.prototype.toString.call(value) === "[object Object]";
-const typeKeywords = Object.keys(types).filter(id => types[id].type === false);
+const isObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
+const typeKeywords = Object.keys(types).filter((id) => types[id].type === false);
+const hasOwnProperty = Object.prototype.hasOwnProperty;
 /**
  * @throws Error    on multiple matches (invalid schema)
  *
@@ -15,10 +16,11 @@ export default function getTypeId(schema) {
     if (schema.enum) {
         return "enum";
     }
-    if (types[schema.type]) {
+    // @ts-ignore
+    if (types[schema.type] || Array.isArray(schema.type)) {
         return schema.type;
     }
-    const ids = typeKeywords.filter(type => schema[type]);
+    const ids = typeKeywords.filter((type) => schema[type]);
     if (ids.length === 1) {
         return ids[0];
     }
@@ -26,14 +28,16 @@ export default function getTypeId(schema) {
         // @expensive, guess type object
         for (let i = 0, l = types.object.keywords.length; i < l; i += 1) {
             const keyword = types.object.keywords[i];
-            if (schema.hasOwnProperty(keyword)) { // eslint-disable-line
+            if (hasOwnProperty.call(schema, keyword)) {
+                // eslint-disable-line
                 return "object";
             }
         }
         // @expensive, guess type array
         for (let i = 0, l = types.array.keywords.length; i < l; i += 1) {
             const keyword = types.array.keywords[i];
-            if (schema.hasOwnProperty(keyword)) { // eslint-disable-line
+            if (hasOwnProperty.call(schema, keyword)) {
+                // eslint-disable-line
                 return "array";
             }
         }

package/dist/module/lib/schema/types.js

@@ -1,4 +1,4 @@
-export default {
+const Types = {
     $ref: {
         type: false
     },
@@ -13,14 +13,22 @@ export default {
     array: {
         type: true,
         // ignore additionalItems:TypeDef, when items:TypeDef
-        definitions: ["allOf/*", "anyOf/*", "oneOf/*", "not", "items", "items/*", "additionalItems"],
+        definitions: [
+            "allOf/*",
+            "anyOf/*",
+            "oneOf/*",
+            "not",
+            "items",
+            "items/*",
+            "additionalItems"
+        ],
         validationKeywords: ["minItems", "maxItems", "uniqueItems"],
         keywords: ["items", "additionalItems", "minItems", "maxItems", "uniqueItems"]
     },
-    "boolean": {
+    boolean: {
         type: true
     },
-    "enum": {
+    enum: {
         type: false
     },
     integer: {
@@ -37,7 +45,7 @@ export default {
         definitions: ["allOf/*", "anyOf/*", "oneOf/*", "not"],
         validationKeywords: ["minimum", "maximum", "multipleOf"]
     },
-    "null": {
+    null: {
         type: true
     },
     object: {
@@ -45,11 +53,26 @@ export default {
         // patternProperties also validate properties
         // dependencies:(string, TypeDef) extend current TypeDef
         // additional Properties validate only remaining properties (after properties & pattern)
-        definitions: ["allOf/*", "anyOf/*", "oneOf/*", "not",
-            "properties/*", "additionalProperties", "patternProperties/*", "dependencies/*"],
+        definitions: [
+            "allOf/*",
+            "anyOf/*",
+            "oneOf/*",
+            "not",
+            "properties/*",
+            "additionalProperties",
+            "patternProperties/*",
+            "dependencies/*"
+        ],
         validationKeywords: ["minProperties", "maxProperties", "required"],
-        keywords: ["properties", "additionalProperties", "patternProperties", "dependencies", "minProperties",
-            "maxProperties", "required"]
+        keywords: [
+            "properties",
+            "additionalProperties",
+            "patternProperties",
+            "dependencies",
+            "minProperties",
+            "maxProperties",
+            "required"
+        ]
     },
     oneOf: {
         type: false,
@@ -61,3 +84,4 @@ export default {
         validationKeywords: ["minLength", "maxLength", "pattern"]
     }
 };
+export default Types;

package/dist/module/lib/step.js

@@ -2,6 +2,7 @@ import getTypeOf from "./getTypeOf";
 import createSchemaOf from "./createSchemaOf";
 import errors from "./validation/errors";
 import merge from "./utils/merge";
+import { isJSONError } from "./types";
 const stepType = {
     array: (core, key, schema, data, pointer) => {
         const itemsType = getTypeOf(schema.items);
@@ -23,11 +24,27 @@ const stepType = {
             return core.resolveRef(schema.items);
         }
         if (itemsType === "array") {
+            // @draft >= 7 bool schema, items:[true, false]
+            if (schema.items[key] === true) {
+                return createSchemaOf(data[key]);
+            }
+            // @draft >= 7 bool schema, items:[true, false]
+            if (schema.items[key] === false) {
+                return errors.invalidDataError({
+                    key,
+                    value: data[key],
+                    pointer
+                });
+            }
             if (schema.items[key]) {
                 return core.resolveRef(schema.items[key]);
             }
             if (schema.additionalItems === false) {
-                return errors.additionalItemsError({ key, value: data[key], pointer });
+                return errors.additionalItemsError({
+                    key,
+                    value: data[key],
+                    pointer
+                });
             }
             if (schema.additionalItems === true || schema.additionalItems === undefined) {
                 return createSchemaOf(data[key]);
@@ -50,21 +67,21 @@ const stepType = {
             const oneOfSchema = core.resolveOneOf(data, schema, pointer);
             // resolveOneOf does currently not apply merge with base schema
             schema = merge(schema, oneOfSchema);
-            if (schema && schema.type === "error") {
+            if (isJSONError(schema)) {
                 return schema;
             }
         }
         if (Array.isArray(schema.anyOf)) {
             // update current schema
             schema = core.resolveAnyOf(data, schema, pointer);
-            if (schema && schema.type === "error") {
+            if (isJSONError(schema)) {
                 return schema;
             }
         }
         if (Array.isArray(schema.allOf)) {
             // update current schema
             schema = core.resolveAllOf(data, schema, pointer);
-            if (schema && schema.type === "error") {
+            if (isJSONError(schema)) {
                 return schema;
             }
         }
@@ -73,7 +90,7 @@ const stepType = {
         if (schema.properties && schema.properties[key] !== undefined) {
             // @todo patternProperties also validate properties
             targetSchema = core.resolveRef(schema.properties[key]);
-            if (targetSchema && targetSchema.type === "error") {
+            if (isJSONError(targetSchema)) {
                 return targetSchema;
             }
             // check if there is a oneOf selection, which must be resolved
@@ -81,8 +98,10 @@ const stepType = {
                 // @special case: this is a mix of a schema and optional definitions
                 // we resolve the schema here and add the original schema to `oneOfSchema`
                 let resolvedSchema = core.resolveOneOf(data[key], targetSchema, `${pointer}/${key}`);
+                const oneOfIndex = targetSchema.oneOf.findIndex((s) => s === resolvedSchema);
                 resolvedSchema = JSON.parse(JSON.stringify(resolvedSchema));
                 resolvedSchema.variableSchema = true;
+                resolvedSchema.oneOfIndex = oneOfIndex;
                 resolvedSchema.oneOfSchema = targetSchema;
                 return resolvedSchema;
             }
@@ -91,6 +110,20 @@ const stepType = {
                 return targetSchema;
             }
         }
+        // @draft <= 07
+        const { dependencies } = schema;
+        if (getTypeOf(dependencies) === "object") {
+            const dependentProperties = Object.keys(dependencies).filter((propertyName) => 
+            // data[propertyName] !== undefined &&
+            getTypeOf(dependencies[propertyName]) === "object");
+            for (let i = 0, l = dependentProperties.length; i < l; i += 1) {
+                const dependentProperty = dependentProperties[i];
+                const schema = step(core, key, dependencies[dependentProperty], data);
+                if (!isJSONError(schema)) {
+                    return schema;
+                }
+            }
+        }
         // find matching property key
         if (getTypeOf(schema.patternProperties) === "object") {
             let regex;
@@ -106,9 +139,14 @@ const stepType = {
             return schema.additionalProperties;
         }
         if (schema.additionalProperties === true) {
-            return createSchemaOf(data);
+            return createSchemaOf(data[key]);
         }
-        return errors.unknownPropertyError({ property: key, value: data, pointer });
+        return errors.unknownPropertyError({
+            property: key,
+            value: data,
+            // pointer: `${pointer}/${key}`,
+            pointer: `${pointer}`
+        });
     }
 };
 /**
@@ -118,17 +156,33 @@ const stepType = {
  *  This helper determines the location of the property within the schema (additional properties, oneOf, ...) and
  *  returns the correct schema.
  *
- * @param  core     - validator
- * @param  key      - property-name or array-index
- * @param  schema          - json schema of current data
+ * @param  core      - validator
+ * @param  key       - property-name or array-index
+ * @param  schema    - json schema of current data
  * @param  data      - parent of key
- * @param  [pointer]
+ * @param  [pointer] - pointer to schema and data (parent of key)
  * @return Schema or Error if failed resolving key
  */
 export default function step(core, key, schema, data, pointer = "#") {
+    // @draft >= 4 ?
+    if (Array.isArray(schema.type)) {
+        const dataType = getTypeOf(data);
+        if (schema.type.includes(dataType)) {
+            // @ts-ignore
+            return stepType[dataType](core, `${key}`, schema, data, pointer);
+        }
+        return core.errors.typeError({
+            value: data,
+            pointer,
+            expected: schema.type,
+            received: dataType
+        });
+    }
     const expectedType = schema.type || getTypeOf(data);
-    if (stepType[expectedType]) {
-        return stepType[expectedType](core, key, schema, data, pointer);
+    // @ts-ignore
+    const stepFunction = stepType[expectedType];
+    if (stepFunction) {
+        return stepFunction(core, `${key}`, schema, data, pointer);
     }
     return new Error(`Unsupported schema type ${schema.type} for key ${key}`);
 }

package/dist/module/lib/types.js

@@ -1 +1,7 @@
-export {};
+/**
+ * ts type guard for json error
+ * @returns true if passed type is a JSONError
+ */
+export function isJSONError(error) {
+    return (error === null || error === void 0 ? void 0 : error.type) === "error";
+}

package/dist/module/lib/utils/createCustomError.js

@@ -1,6 +1,6 @@
 import __ from "./__";
-function dashCase(str) {
-    return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+function dashCase(text) {
+    return text.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
 }
 export function createError(name, data) {
     return {
@@ -13,11 +13,11 @@ export function createError(name, data) {
 }
 /**
  * Creates a custom Error-Constructor which instances may be identified by `customError instanceof Error`. Its messages
- * are defined by strings-object __@see config/strings.ts
+ * are defined by strings-object @see config/strings.ts
  *
  * @param name - id of error (camelcased)
  * @return error constructor function
  */
-export default function createCustomError(name) {
+export function createCustomError(name) {
     return createError.bind(null, name);
 }

package/dist/module/lib/utils/filter.js

@@ -1,12 +1,10 @@
+import { isJSONError } from "../types";
 export function isPromise(obj) {
     return obj instanceof Promise;
 }
-export function isError(obj) {
-    return obj && obj.type === "error";
-}
 export function errorOrPromise(error) {
-    return isError(error) || isPromise(error);
+    return isJSONError(error) || isPromise(error);
 }
 export function errorsOnly(error) {
-    return isError(error);
+    return isJSONError(error);
 }