@fibery/schema 8.4.0 → 10.0.0

package/lib/index.js

@@ -1,788 +1,22 @@
-/******/ (() => { // webpackBootstrap
-/******/ 	"use strict";
-/******/ 	// The require scope
-/******/ 	var __webpack_require__ = {};
-/******/ 	
-/************************************************************************/
-/******/ 	/* webpack/runtime/compat get default export */
-/******/ 	(() => {
-/******/ 		// getDefaultExport function for compatibility with non-harmony modules
-/******/ 		__webpack_require__.n = (module) => {
-/******/ 			var getter = module && module.__esModule ?
-/******/ 				() => (module['default']) :
-/******/ 				() => (module);
-/******/ 			__webpack_require__.d(getter, { a: getter });
-/******/ 			return getter;
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/define property getters */
-/******/ 	(() => {
-/******/ 		// define getter functions for harmony exports
-/******/ 		__webpack_require__.d = (exports, definition) => {
-/******/ 			for(var key in definition) {
-/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
-/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
-/******/ 				}
-/******/ 			}
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
-/******/ 	(() => {
-/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/make namespace object */
-/******/ 	(() => {
-/******/ 		// define __esModule on exports
-/******/ 		__webpack_require__.r = (exports) => {
-/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 			}
-/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/************************************************************************/
-var __webpack_exports__ = {};
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  factory: () => (/* binding */ factory),
-  protectiveFactory: () => (/* binding */ protectiveFactory)
-});
-
-;// CONCATENATED MODULE: external "lodash"
-const external_lodash_namespaceObject = require("lodash");
-var external_lodash_default = /*#__PURE__*/__webpack_require__.n(external_lodash_namespaceObject);
-;// CONCATENATED MODULE: external "util"
-const external_util_namespaceObject = require("util");
-;// CONCATENATED MODULE: external "memoize-one"
-const external_memoize_one_namespaceObject = require("memoize-one");
-var external_memoize_one_default = /*#__PURE__*/__webpack_require__.n(external_memoize_one_namespaceObject);
-;// CONCATENATED MODULE: ../helpers/utils/trace.ts
-
-
-const formatWithCustomInspectParams = values => {
-  return values.map(value => {
-    if (typeof value === "object") {
-      return util.inspect(value, {
-        showHidden: false,
-        depth: null,
-        maxArrayLength: null
-      });
-    }
-    return value;
-  }).join(" ");
-};
-function assert(condition) {
-  if (!condition) {
-    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      args[_key - 1] = arguments[_key];
-    }
-    const message = args.length > 0 ? formatWithCustomInspectParams(args) : `Assertion failed with no details`;
-    throw new Error(message);
-  }
-}
-function assertWithTraceError(condition) {
-  if (!condition) {
-    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-      args[_key2 - 1] = arguments[_key2];
-    }
-    const message = args.length > 0 ? formatWithCustomInspectParams(args) : `Assertion failed with no details`;
-    traceError(message);
-  }
-}
-
-// eslint-disable-next-line no-console
-let traceErrorSubscribers = [console.error.bind(console)];
-const overridden = false;
-function subscribeOnTraceError(fn) {
-  if (overridden) {
-    throw new Error("can't subscribe while overridden");
-  }
-  traceErrorSubscribers.push(fn);
-  let unsubscribed = false;
-  return function unsubscribe() {
-    assert(!unsubscribed, "Can't unsubscribe more than once");
-    unsubscribed = true;
-    traceErrorSubscribers = traceErrorSubscribers.filter(x => x !== fn);
-  };
-}
-const traceError = external_memoize_one_default()(function traceError() {
-  for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-    args[_key3] = arguments[_key3];
-  }
-  traceErrorSubscribers.forEach(fn => {
-    fn(...args);
-  });
-});
-
-// eslint-disable-next-line no-console
-let captureMessageSubscribers = [console.info.bind(console)];
-function subscribeOnCaptureMessage(fn) {
-  captureMessageSubscribers.push(fn);
-  let unsubscribed = false;
-  return function unsubscribe() {
-    assert(!unsubscribed, "Can't unsubscribe more than once");
-    unsubscribed = true;
-    captureMessageSubscribers = captureMessageSubscribers.filter(x => x !== fn);
-  };
-}
-const captureMessage = external_memoize_one_default()(function captureMessage() {
-  for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-    args[_key4] = arguments[_key4];
-  }
-  captureMessageSubscribers.forEach(fn => {
-    fn(...args);
-  });
-});
-const tracedErrorTracker = {};
-const traceErrorOncePerSession = (seed, err) => {
-  if (tracedErrorTracker[seed]) {
-    return;
-  }
-  tracedErrorTracker[seed] = true;
-  const message = [seed, err].filter(Boolean).join(": ");
-  traceError(message);
-};
-const capturedMessageTracker = {};
-const captureMessageOncePerSession = (seed, err) => {
-  if (capturedMessageTracker[seed]) {
-    return;
-  }
-  capturedMessageTracker[seed] = true;
-  const message = [seed, err].filter(Boolean).join(": ");
-  captureMessage(message);
-};
-function withErrorTrace(f) {
-  return async function () {
-    try {
-      return await f(...arguments);
-    } catch (err) {
-      traceError(err);
-      throw err;
-    }
-  };
-}
-;// CONCATENATED MODULE: ./utils.ts
-
-
-
-
-const jestKey = new Set(["nodeType", "tagName", "hasAttribute"]);
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const withOnlyDefinedGets = function (target) {
-  let targetKind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "object";
-  return new Proxy(target, {
-    get(target, key) {
-      if (!(key in target) && "production" !== "production") {}
-      return target[key];
-    }
-  });
-};
-const getNamePart = str => splitKeyword(str).name;
-const capitalizeFirstChar = input => {
-  const str = input || "";
-  return str ? str.charAt(0).toUpperCase() + str.slice(1) : str;
-};
-const replaceTildes = str => (str || "").split("~").join(" ");
-const toTypeOrFieldNamePartTitle = external_lodash_default().flow([capitalizeFirstChar, replaceTildes]);
-const toTypeOrFieldTitle = external_lodash_default().flow([getNamePart, toTypeOrFieldNamePartTitle]);
-const toPascalCase = function () {
-  let lispCasedString = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
-  return lispCasedString && (external_lodash_default().last(lispCasedString.split("/")) || "").split("-").map((external_lodash_default()).capitalize).join(" ");
-};
-const isObsoleteTitle = str => {
-  const {
-    name
-  } = splitKeyword(str);
-  return name.toLowerCase() === name && !hasTildes(name);
-};
-const hasTildes = str => str.includes("~");
-const toNonEnumTitle = str => {
-  return isObsoleteTitle(str) ? toPascalCase(str) : toTypeOrFieldTitle(str);
-};
-const parseEnumType = type => {
-  const [templateType, targetType] = type.split("_");
-  const {
-    name: templateName,
-    namespace: templateNamespace
-  } = parseType(templateType);
-  const {
-    name: targetName,
-    namespace: targetNamespace
-  } = parseType(targetType);
-  return {
-    templateName,
-    templateNamespace,
-    targetName,
-    targetNamespace
-  };
-};
-const toEnumTitle = type => {
-  // enum logic
-  const {
-    templateName,
-    targetName
-  } = parseEnumType(type);
-  return toTitle(targetName) + " " + toTitle(templateName);
-};
-const toTitle = typeOrAttr => {
-  const str = typeOrAttr || "";
-  return str.includes("_") ? toEnumTitle(str) : toNonEnumTitle(str);
-};
-const splitKeyword = keyword => {
-  const str = keyword || "";
-  const index = str.indexOf("/");
-  if (index === -1) {
-    return {
-      namespace: "",
-      name: str
-    };
-  }
-  const namespace = str.substring(0, index);
-  const name = str.substring(index + 1);
-  return {
-    namespace,
-    name
-  };
-};
-const parseType = external_lodash_default().memoize(type => {
-  if (!type.includes("/")) {
-    traceError(`parseType invalid usage: passed type is '${type}'`);
-  }
-  return splitKeyword(type);
-});
-const makeEnumTypeNamePart = _ref => {
-  let {
-    holderType,
-    enumName
-  } = _ref;
-  const {
-    namespace,
-    name
-  } = parseType(holderType);
-  return `${enumName}_${namespace}/${name}`;
-};
-const attachEnumNamespace = _ref2 => {
-  let {
-    enumNamespace,
-    typeNamePart
-  } = _ref2;
-  return `${enumNamespace}/${typeNamePart}`;
-};
-const removeDeletedTypesAndFields = rawSchema => {
-  const {
-    "fibery/types": rawTypeObjects,
-    ...schemaRest
-  } = rawSchema;
-  const filteredRawTypeObjects = rawTypeObjects.filter(rawTypeObject => rawTypeObject["fibery/deleted?"] !== true).map(rawTypeObject => {
-    const {
-      "fibery/fields": rawFieldObjects,
-      ...rawTypeObjectRest
-    } = rawTypeObject;
-    const filteredRawFieldObjects = rawFieldObjects.filter(rawFieldObject => rawFieldObject["fibery/deleted?"] !== true);
-    return {
-      ...rawTypeObjectRest,
-      "fibery/fields": filteredRawFieldObjects
-    };
-  });
-  return {
-    ...schemaRest,
-    "fibery/types": filteredRawTypeObjects
-  };
-};
-;// CONCATENATED MODULE: ./FieldObject.js
-
-
-class FieldObject {
-  constructor(_ref) {
-    let {
-      rawFieldObject,
-      holderType,
-      resolveTypeObject,
-      version,
-      resolveMultiRelatedFieldObjects
-    } = _ref;
-    if (!external_lodash_default().isPlainObject(rawFieldObject)) {
-      throw new Error("rawFieldObject arg must be plain object");
-    }
-    if (!external_lodash_default().isString(holderType)) {
-      throw new Error("holderType arg must be string");
-    }
-    if (!external_lodash_default().isFunction(resolveTypeObject)) {
-      throw new Error("resolveTypeObject arg must be function");
-    }
-    if (!external_lodash_default().isFunction(resolveMultiRelatedFieldObjects)) {
-      throw new Error("resolveMultiRelationFieldObjects arg must be function");
-    }
-    this.name = rawFieldObject["fibery/name"];
-    this.description = rawFieldObject["fibery/description"] || null;
-    this.id = rawFieldObject["fibery/id"];
-    this.type = rawFieldObject["fibery/type"];
-    const rawMeta = rawFieldObject["fibery/meta"] || {};
-    this.rawMeta = rawMeta;
-    this.holderType = holderType;
-    this.isCollection = rawMeta["fibery/collection?"] || false;
-    this.isTitle = rawMeta["ui/title?"] || false;
-    this.isId = rawMeta["fibery/id?"] || false;
-    this.isPublicId = rawMeta["fibery/public-id?"] || false;
-    this.isReadOnly = rawMeta["fibery/readonly?"] || false;
-    this.isFormula = rawMeta["formula/formula?"] || false;
-    this.isFormulaDisabled = rawMeta["formula/disabled?"] || false;
-    this.formulaDisableReason = rawMeta["formula/disable-reason"] || null;
-    this.formula = rawMeta["formula/formula"] || null;
-    this.isLookup = rawMeta["formula/lookup?"] || false;
-    this.hasLinkRule = rawMeta["link-rule/link-rule?"] || false;
-    this.linkRule = rawMeta["link-rule/link-rule"] || null;
-    this.isLinkRuleDisabled = rawMeta["link-rule/disabled?"] || false;
-    this.linkRuleDisableReason = rawMeta["link-rule/disable-reason"] || null;
-    this.relation = rawMeta["fibery/relation"] || null;
-    this.defaultValue = rawMeta["fibery/default-value"] || null;
-    this.objectEditorOrder = rawMeta["ui/object-editor-order"] || 0;
-    this.isRequired = rawMeta["fibery/required?"] === true;
-    this.isHidden = rawMeta["ui/hidden?"] === true;
-    this.isDeleted = rawFieldObject["fibery/deleted?"] || false;
-    this.disableLinkExistingItems = rawMeta["ui/disable-link-existing-items"] || false;
-    this.version = version;
-    this.multiRelation = rawMeta["fibery/multi-relation"] || null;
-    Object.defineProperties(this, {
-      typeObject: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => resolveTypeObject(this.type))
-      },
-      mixinTypeObject: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => {
-          return this.holderTypeObject.installedMixinTypeObjects.find(mixinTypeObject => mixinTypeObject.fieldObjectsByName.hasOwnProperty(this.name) || this.name === "workflow/state" && mixinTypeObject.name === "workflow/workflow");
-        })
-      },
-      holderTypeObject: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => {
-          return resolveTypeObject(holderType);
-        })
-      },
-      nameParts: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => parseType(rawFieldObject["fibery/name"]))
-      },
-      title: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => toNonEnumTitle(rawFieldObject["fibery/name"]))
-      },
-      multiRelatedFieldObjects: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => {
-          const {
-            multiRelation,
-            typeObject
-          } = this;
-          if (!multiRelation || !typeObject.isEntityRef) {
-            return [];
-          }
-          return resolveMultiRelatedFieldObjects(multiRelation);
-        })
-      }
-    });
-  }
-  get relatedFieldObject() {
-    const {
-      name,
-      relation,
-      multiRelation,
-      typeObject
-    } = this;
-    if (!relation && !multiRelation) {
-      return null;
-    }
-    if (!relation && multiRelation && typeObject.isEntityRef) {
-      return null;
-    }
-    let relationKey;
-    let relationId;
-    if (relation) {
-      relationKey = "relation";
-      relationId = relation;
-    } else {
-      relationId = multiRelation;
-      relationKey = "multiRelation";
-    }
-    const selector = this.type !== this.holderType ? fieldObject => fieldObject[relationKey] === relationId : fieldObject => fieldObject[relationKey] === relationId && fieldObject.name !== name;
-    const fieldObject = this.typeObject.fieldObjects.find(selector);
-    if (!fieldObject) {
-      throw new Error(`there no other end for ${relationKey} ${relationId}`);
-    }
-    return fieldObject;
-  }
-  get cardinality() {
-    const {
-      isCollection,
-      relatedFieldObject,
-      typeObject
-    } = this;
-    if (typeObject.isPrimitive) {
-      throw new Error("Only non-basic fields have cardinality");
-    }
-    if (isCollection && this.rawMeta["fibery/field-reversed-collection?"]) {
-      return ":cardinality/many-to-many";
-    }
-    if (!relatedFieldObject) {
-      return isCollection ? ":cardinality/one-to-many" : ":cardinality/many-to-one";
-    }
-    const isRelationCollection = relatedFieldObject.isCollection;
-    if (!isCollection && !isRelationCollection) {
-      return ":cardinality/one-to-one";
-    }
-    if (isCollection && !isRelationCollection) {
-      return ":cardinality/one-to-many";
-    }
-    if (!isCollection && isRelationCollection) {
-      return ":cardinality/many-to-one";
-    }
-    if (isCollection && isRelationCollection) {
-      return ":cardinality/many-to-many";
-    }
-    throw new Error("get cardinality invariant");
-  }
-
-  /** @deprecated use !typeObject.isPrimitive && cardinality === ... instead */
-  get kind() {
-    if (this.typeObject.isPrimitive) {
-      if (this.isCollection) {
-        throw new Error("basic collection is not implemented");
-      } else {
-        return ":field/basic";
-      }
-    } else {
-      if (this.isCollection) {
-        return ":field/reference-collection";
-      } else {
-        return ":field/reference";
-      }
-    }
-  }
-}
-;// CONCATENATED MODULE: ./Schema.js
-
-class Schema {
-  constructor(_ref) {
-    let {
-      factory,
-      rawSchema: {
-        "fibery/id": id,
-        "fibery/types": rawTypeObjects,
-        "fibery/version": version
-      }
-    } = _ref;
-    if (!Array.isArray(rawTypeObjects)) {
-      throw new Error("rawTypeObjects arg must be array");
-    }
-    Object.defineProperties(this, {
-      toJSON: {
-        value: () => ({
-          "fibery/types": rawTypeObjects,
-          "fibery/meta": {
-            "fibery/version": version
-          }
-        }),
-        enumerable: false
-      }
-    });
-    const getTypeComponentTypeToFieldObject = external_lodash_default().once(() => {
-      const typeComponentTypeToFieldObject = new Map();
-      this.typeObjects.flatMap(typeObject => typeObject.fieldObjects).filter(fieldObject => {
-        return fieldObject.rawMeta["fibery/type-component?"] === true && fieldObject.typeObject.rawMeta["fibery/type-component?"] === true;
-      }).forEach(fieldObject => {
-        typeComponentTypeToFieldObject.set(fieldObject.type, fieldObject);
-      });
-      return typeComponentTypeToFieldObject;
-    });
-    let multiRelatedFieldsObjectsMap = null;
-    const initMultiRelatedFieldsObjectsMap = () => {
-      multiRelatedFieldsObjectsMap = new Map();
-      this.typeObjects.forEach(typeObject => {
-        typeObject.fieldObjects.forEach(fieldObject => {
-          if (fieldObject.multiRelation && !fieldObject.typeObject.isEntityRef) {
-            const store = multiRelatedFieldsObjectsMap.get(fieldObject.multiRelation) || [];
-            store.push(fieldObject);
-            multiRelatedFieldsObjectsMap.set(fieldObject.multiRelation, store);
-          }
-        });
-      });
-    };
-    this.typeObjects = rawTypeObjects.map(rawTypeObject => factory.makeTypeObject({
-      rawTypeObject,
-      resolveTypeObject: type => this.typeObjectsByName[type] || null,
-      getTypeComponentTypeToFieldObject: type => getTypeComponentTypeToFieldObject().get(type),
-      resolveMultiRelatedFieldObjects: multiRelation => {
-        if (!multiRelatedFieldsObjectsMap) {
-          initMultiRelatedFieldsObjectsMap();
-        }
-        return multiRelatedFieldsObjectsMap.get(multiRelation) || [];
-      },
-      version
-    }));
-    this.typeObjectsById = factory.makeTypeObjectsById(this.typeObjects);
-    this.typeObjectsByName = factory.makeTypeObjectsByName(this.typeObjects);
-    this.id = id;
-    this.version = version;
-  }
-}
-;// CONCATENATED MODULE: external "pluralize"
-const external_pluralize_namespaceObject = require("pluralize");
-var external_pluralize_default = /*#__PURE__*/__webpack_require__.n(external_pluralize_namespaceObject);
-;// CONCATENATED MODULE: ./TypeObject.js
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-
-
-
-class TypeObject {
-  constructor(_ref) {
-    let {
-      rawTypeObject,
-      resolveTypeObject,
-      getTypeComponentTypeToFieldObject,
-      version,
-      factory,
-      resolveMultiRelatedFieldObjects
-    } = _ref;
-    _defineProperty(this, "_getFieldObjectShortcuts", external_lodash_default().once(() => {
-      const hasRank = this.installedMixins.has("fibery/rank-mixin");
-      return this.fieldObjects.reduce((result, fieldObject) => {
-        if (fieldObject.isId) {
-          result.idField = fieldObject.name;
-          result.idFieldObject = fieldObject;
-        } else if (fieldObject.isPublicId) {
-          result.publicIdField = fieldObject.name;
-          result.publicIdFieldObject = fieldObject;
-        } else if (fieldObject.isTitle) {
-          result.titleField = fieldObject.name;
-          result.titleFieldObject = fieldObject;
-        } else if (hasRank && fieldObject.name === "fibery/rank") {
-          result.rankField = fieldObject.name;
-          result.rankFieldObject = fieldObject;
-        }
-        return result;
-      }, {
-        idField: null,
-        idFieldObject: null,
-        publicIdField: null,
-        publicIdFieldObject: null,
-        titleField: null,
-        titleFieldObject: null,
-        rankField: null,
-        rankFieldObject: null
-      });
-    }));
-    if (!external_lodash_default().isPlainObject(rawTypeObject)) {
-      throw new Error("rawTypeObject arg must be plain object");
-    }
-    if (!external_lodash_default().isFunction(resolveTypeObject)) {
-      throw new Error("resolveTypeObject arg must be function");
-    }
-    this.name = rawTypeObject["fibery/name"];
-    this.description = rawTypeObject["fibery/description"] || null;
-    this.id = rawTypeObject["fibery/id"];
-    const rawMeta = rawTypeObject["fibery/meta"] || {};
-    this.rawMeta = rawMeta;
-    this.isDomain = rawMeta["fibery/domain?"] || false;
-    this.isPlatform = rawMeta["fibery/platform?"] || false;
-    this.isHighlight = rawMeta["fibery/highlight?"] || false;
-    this.isMixin = rawMeta["app/mixin?"] || false;
-    this.mixinIcon = rawMeta["ui/mixin-icon"] || null;
-    this.isEnum = rawMeta["fibery/enum?"] || false;
-    this.isPrimitive = rawMeta["fibery/primitive?"] || false;
-    this.isWriterModeByDefault = rawMeta["ui/writer-mode?"] || false;
-    this.isDeleted = rawTypeObject["fibery/deleted?"] || false;
-    this.nameParts = parseType(this.name);
-    this.color = rawMeta["ui/color"] || "#4568FB";
-    this.units = rawMeta["ui/units"] || null;
-    this.installedMixins = new Set(Object.keys(rawMeta["app/mixins"] || {}));
-    this.syncSource = rawMeta["sync/source"] || null;
-    this.version = version;
-    this.isEntityRef = rawTypeObject["fibery/name"] === "fibery/entity-ref";
-    const fieldObjectsByNameOnceGetter = external_lodash_default().once(() => {
-      return factory.makeFieldObjectsByName({
-        type: this.name,
-        fieldObjects: this.fieldObjects
-      });
-    });
-    const fieldObjectsGetter = external_lodash_default().once(() => rawTypeObject["fibery/fields"].map(rawFieldObject => {
-      return factory.makeFieldObject({
-        rawFieldObject,
-        holderType: this.name,
-        resolveTypeObject,
-        version,
-        resolveMultiRelatedFieldObjects
-      });
-    }));
-    Object.defineProperties(this, {
-      toJSON: {
-        value() {
-          if (false) {}
-          return rawTypeObject;
-        },
-        enumerable: false
-      },
-      fieldObjects: {
-        configurable: false,
-        enumerable: true,
-        get: fieldObjectsGetter
-      },
-      typeComponentFieldObject: {
-        configurable: false,
-        enumerable: true,
-        get: () => {
-          return getTypeComponentTypeToFieldObject(this.name);
-        }
-      },
-      fieldObjectsById: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => {
-          return factory.makeFieldObjectsById({
-            type: this.name,
-            fieldObjects: this.fieldObjects
-          });
-        })
-      },
-      fieldObjectsByName: {
-        configurable: false,
-        enumerable: true,
-        get: fieldObjectsByNameOnceGetter
-      },
-      installedMixinTypeObjects: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => [...this.installedMixins].map(resolveTypeObject).filter(typeObject => typeObject))
-      },
-      title: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => toTitle(this.name))
-      },
-      pluralTitle: {
-        configurable: false,
-        enumerable: true,
-        get: external_lodash_default().once(() => toTitle(external_pluralize_default().plural(this.name)))
-      }
-    });
-  }
-  get idField() {
-    return this._getFieldObjectShortcuts().idField;
-  }
-  get idFieldObject() {
-    return this._getFieldObjectShortcuts().idFieldObject;
-  }
-  get publicIdField() {
-    return this._getFieldObjectShortcuts().publicIdField;
-  }
-  get publicIdFieldObject() {
-    return this._getFieldObjectShortcuts().publicIdFieldObject;
-  }
-  get titleField() {
-    return this._getFieldObjectShortcuts().titleField;
-  }
-  get titleFieldObject() {
-    return this._getFieldObjectShortcuts().titleFieldObject;
-  }
-  get rankField() {
-    return this._getFieldObjectShortcuts().rankField;
-  }
-  get rankFieldObject() {
-    return this._getFieldObjectShortcuts().rankFieldObject;
-  }
-}
-;// CONCATENATED MODULE: ./index.js
-
-
-
-
-
-const factory = {
-  makeSchema: function (rawSchema) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      shouldRemoveDeletedTypesAndFields: true
-    };
-    return new Schema({
-      rawSchema: options.shouldRemoveDeletedTypesAndFields ? removeDeletedTypesAndFields(rawSchema) : rawSchema,
-      factory
-    });
-  },
-  makeTypeObject: args => new TypeObject({
-    ...args,
-    factory
-  }),
-  makeTypeObjectsById: typeObjects => external_lodash_default().keyBy(typeObjects, x => x.id),
-  makeTypeObjectsByName: typeObjects => external_lodash_default().keyBy(typeObjects, x => x.name),
-  makeFieldObject: args => new FieldObject(args),
-  makeFieldObjectsById: _ref => {
-    let {
-      type,
-      fieldObjects
-    } = _ref;
-    return external_lodash_default().keyBy(fieldObjects, x => x.id);
-  },
-  makeFieldObjectsByName: _ref2 => {
-    let {
-      type,
-      fieldObjects
-    } = _ref2;
-    return external_lodash_default().keyBy(fieldObjects, x => x.name);
-  }
-};
-const protectiveFactory = {
-  makeSchema: function (rawSchema) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      shouldRemoveDeletedTypesAndFields: true
-    };
-    return withOnlyDefinedGets(new Schema({
-      rawSchema: options.shouldRemoveDeletedTypesAndFields ? removeDeletedTypesAndFields(rawSchema) : rawSchema,
-      factory: protectiveFactory
-    }), `schema`);
-  },
-  makeTypeObject: args => {
-    const typeObject = new TypeObject({
-      ...args,
-      factory: protectiveFactory
-    });
-    return withOnlyDefinedGets(typeObject, `schema.typeObjectsByName["${typeObject.name}"]`);
-  },
-  makeTypeObjectsById: typeObjects => withOnlyDefinedGets(external_lodash_default().keyBy(typeObjects, x => x.id), "schema.typeObjectsById"),
-  makeTypeObjectsByName: typeObjects => withOnlyDefinedGets(external_lodash_default().keyBy(typeObjects, x => x.name), "schema.typeObjectsByName"),
-  makeFieldObject: args => {
-    const fieldObject = new FieldObject(args);
-    return withOnlyDefinedGets(fieldObject, `schema.typeObjectsByName["${fieldObject.holderType}"].fieldObjectsByName["${fieldObject.name}"]`);
-  },
-  makeFieldObjectsById: _ref3 => {
-    let {
-      type,
-      fieldObjects
-    } = _ref3;
-    return withOnlyDefinedGets(external_lodash_default().keyBy(fieldObjects, x => x.id), `schema.typeObjectsByName["${type}"].fieldObjectsById`);
-  },
-  makeFieldObjectsByName: _ref4 => {
-    let {
-      type,
-      fieldObjects
-    } = _ref4;
-    return withOnlyDefinedGets(external_lodash_default().keyBy(fieldObjects, x => x.name), `schema.typeObjectsByName["${type}"].fieldObjectsByName`);
-  }
-};
-module.exports = __webpack_exports__;
-/******/ })()
-;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/factory"), exports);
+__exportStar(require("./src/schema"), exports);
+__exportStar(require("./src/type-object"), exports);
+__exportStar(require("./src/field-object"), exports);
+__exportStar(require("./src/utils"), exports);
+__exportStar(require("./src/errors"), exports);