@revisium/schema-toolkit 0.2.0 → 0.2.2

package/dist/chunk-JLIZ7QT2.cjs

@@ -0,0 +1,787 @@
+'use strict';
+
+var nanoid = require('nanoid');
+var events = require('events');
+
+// src/lib/addSharedFieldsFromStore.ts
+var addSharedFieldsFromState = (schema, state) => {
+  if (state.title) {
+    schema.title = state.title;
+  }
+  if (state.description) {
+    schema.description = state.description;
+  }
+  if (state.deprecated) {
+    schema.deprecated = state.deprecated;
+  }
+  return schema;
+};
+var JsonStringStore = class extends events.EventEmitter {
+  constructor(nodeId = nanoid.nanoid()) {
+    super();
+    this.nodeId = nodeId;
+  }
+  type = "string" /* String */;
+  $ref = "";
+  name = "";
+  parent = null;
+  default = "";
+  readOnly;
+  title;
+  description;
+  deprecated;
+  foreignKey;
+  pattern;
+  enum;
+  format;
+  contentMediaType;
+  valuesMap = /* @__PURE__ */ new Map();
+  registerValue(value) {
+    const length = this.getOrCreateValues(value.rowId).push(value);
+    return length - 1;
+  }
+  getValue(rowId, index = 0) {
+    return this.getOrCreateValues(rowId)[index];
+  }
+  getPlainSchema(options) {
+    if (this.$ref && options?.skip$Ref !== true) {
+      return addSharedFieldsFromState({ $ref: this.$ref }, this);
+    }
+    return addSharedFieldsFromState(
+      {
+        type: this.type,
+        default: this.default,
+        ...this.foreignKey ? { foreignKey: this.foreignKey } : {},
+        ...this.readOnly ? { readOnly: this.readOnly } : {},
+        ...this.pattern ? { pattern: this.pattern } : {},
+        ...this.enum ? { enum: this.enum } : {},
+        ...this.format ? { format: this.format } : {},
+        ...this.contentMediaType ? { contentMediaType: this.contentMediaType } : {}
+      },
+      this
+    );
+  }
+  getOrCreateValues(rowId) {
+    let values = this.valuesMap.get(rowId);
+    if (!values) {
+      values = [];
+      this.valuesMap.set(rowId, values);
+    }
+    return values;
+  }
+};
+var JsonNumberStore = class extends events.EventEmitter {
+  constructor(nodeId = nanoid.nanoid()) {
+    super();
+    this.nodeId = nodeId;
+  }
+  type = "number" /* Number */;
+  $ref = "";
+  name = "";
+  parent = null;
+  default = 0;
+  readOnly;
+  title;
+  description;
+  deprecated;
+  valuesMap = /* @__PURE__ */ new Map();
+  registerValue(value) {
+    const length = this.getOrCreateValues(value.rowId).push(value);
+    return length - 1;
+  }
+  getValue(rowId, index = 0) {
+    return this.getOrCreateValues(rowId)[index];
+  }
+  getPlainSchema(options) {
+    if (this.$ref && options?.skip$Ref !== true) {
+      return addSharedFieldsFromState({ $ref: this.$ref }, this);
+    }
+    return addSharedFieldsFromState(
+      {
+        type: this.type,
+        default: this.default,
+        ...this.readOnly ? { readOnly: this.readOnly } : {}
+      },
+      this
+    );
+  }
+  getOrCreateValues(rowId) {
+    let values = this.valuesMap.get(rowId);
+    if (!values) {
+      values = [];
+      this.valuesMap.set(rowId, values);
+    }
+    return values;
+  }
+};
+var JsonBooleanStore = class extends events.EventEmitter {
+  constructor(nodeId = nanoid.nanoid()) {
+    super();
+    this.nodeId = nodeId;
+  }
+  type = "boolean" /* Boolean */;
+  $ref = "";
+  name = "";
+  parent = null;
+  default = false;
+  readOnly;
+  title;
+  description;
+  deprecated;
+  valuesMap = /* @__PURE__ */ new Map();
+  registerValue(value) {
+    const length = this.getOrCreateValues(value.rowId).push(value);
+    return length - 1;
+  }
+  getValue(rowId, index = 0) {
+    return this.getOrCreateValues(rowId)[index];
+  }
+  getPlainSchema(options) {
+    if (this.$ref && options?.skip$Ref !== true) {
+      return addSharedFieldsFromState({ $ref: this.$ref }, this);
+    }
+    return addSharedFieldsFromState(
+      {
+        type: this.type,
+        default: this.default,
+        ...this.readOnly ? { readOnly: this.readOnly } : {}
+      },
+      this
+    );
+  }
+  getOrCreateValues(rowId) {
+    let values = this.valuesMap.get(rowId);
+    if (!values) {
+      values = [];
+      this.valuesMap.set(rowId, values);
+    }
+    return values;
+  }
+};
+var JsonObjectStore = class {
+  constructor(nodeId = nanoid.nanoid()) {
+    this.nodeId = nodeId;
+  }
+  type = "object" /* Object */;
+  $ref = "";
+  name = "";
+  parent = null;
+  default = {};
+  title;
+  description;
+  deprecated;
+  additionalProperties = false;
+  required = [];
+  properties = {};
+  valuesMap = /* @__PURE__ */ new Map();
+  get empty() {
+    return Object.keys(this.properties).length === 0;
+  }
+  registerValue(value) {
+    const length = this.getOrCreateValues(value.rowId).push(value);
+    return length - 1;
+  }
+  getValue(rowId, index = 0) {
+    return this.getOrCreateValues(rowId)[index];
+  }
+  addPropertyWithStore(name, store) {
+    if (this.properties[name] || this.required.includes(name)) {
+      throw new Error("this name already exists");
+    }
+    store.parent = this;
+    store.name = name;
+    this.required.push(name);
+    this.required.sort((a, b) => a.localeCompare(b));
+    this.properties[name] = store;
+    this.default[name] = store.default;
+    const event = { name, property: store };
+    for (const value of this.iterValues()) {
+      value.addProperty(event);
+    }
+    return store;
+  }
+  migratePropertyWithStore(name, store) {
+    const item = this.properties[name];
+    if (!item) {
+      throw new Error("this name does not exist");
+    }
+    item.parent = null;
+    store.parent = this;
+    store.name = name;
+    this.properties[name] = store;
+    this.default[name] = store.default;
+    const event = {
+      name,
+      property: store,
+      previousProperty: item
+    };
+    for (const value of this.iterValues()) {
+      value.migrateProperty(event);
+    }
+    return store;
+  }
+  changeName(fromName, toName) {
+    const item = this.properties[fromName];
+    if (!item) {
+      throw new Error("this fromName does not exist");
+    }
+    delete this.properties[fromName];
+    delete this.default[fromName];
+    const foundRequiredIndex = this.required.findIndex(
+      (required) => required === fromName
+    );
+    if (foundRequiredIndex !== -1) {
+      this.required.splice(foundRequiredIndex, 1);
+    }
+    if (!this.required.includes(toName)) {
+      this.required.push(toName);
+      this.required.sort((a, b) => a.localeCompare(b));
+    }
+    this.properties[toName] = item;
+    this.default[toName] = item.default;
+    const event = {
+      fromName,
+      toName,
+      property: item
+    };
+    for (const value of this.iterValues()) {
+      value.changeName(event);
+    }
+  }
+  removeProperty(name) {
+    const item = this.properties[name];
+    if (!item) {
+      throw new Error("this name does not exist");
+    }
+    item.parent = null;
+    item.name = "";
+    delete this.properties[name];
+    delete this.default[name];
+    const foundRequiredIndex = this.required.findIndex(
+      (required) => required === name
+    );
+    if (foundRequiredIndex !== -1) {
+      this.required.splice(foundRequiredIndex, 1);
+    }
+    const event = {
+      name,
+      property: item
+    };
+    for (const value of this.iterValues()) {
+      value.removeProperty(event);
+    }
+  }
+  getProperty(name) {
+    return this.properties[name];
+  }
+  getPlainSchema(options) {
+    if (this.$ref && options?.skip$Ref !== true) {
+      return addSharedFieldsFromState({ $ref: this.$ref }, this);
+    }
+    return addSharedFieldsFromState(
+      {
+        type: this.type,
+        additionalProperties: this.additionalProperties,
+        required: this.required,
+        properties: Object.entries(this.properties).reduce((result, [name, store]) => {
+          result[name] = store.getPlainSchema(options);
+          return result;
+        }, {})
+      },
+      this
+    );
+  }
+  getOrCreateValues(rowId) {
+    let values = this.valuesMap.get(rowId);
+    if (!values) {
+      values = [];
+      this.valuesMap.set(rowId, values);
+    }
+    return values;
+  }
+  *iterValues() {
+    for (const values of this.valuesMap.values()) {
+      for (const value of values) {
+        yield value;
+      }
+    }
+  }
+};
+var JsonArrayStore = class {
+  constructor(_items, nodeId = nanoid.nanoid()) {
+    this._items = _items;
+    this.nodeId = nodeId;
+    this.items.parent = this;
+  }
+  type = "array" /* Array */;
+  $ref = "";
+  name = "";
+  parent = null;
+  default = [];
+  title;
+  description;
+  deprecated;
+  valuesMap = /* @__PURE__ */ new Map();
+  get items() {
+    return this._items;
+  }
+  registerValue(value) {
+    const length = this.getOrCreateValues(value.rowId).push(value);
+    return length - 1;
+  }
+  getValue(rowId, index = 0) {
+    return this.getOrCreateValues(rowId)[index];
+  }
+  migrateItems(items) {
+    const previousItems = this._items;
+    previousItems.parent = null;
+    this._items = items;
+    this._items.parent = this;
+    const event = { items, previousItems };
+    for (const value of this.iterValues()) {
+      value.migrateItems(event);
+    }
+  }
+  replaceItems(items) {
+    const previousItems = this._items;
+    previousItems.parent = null;
+    this._items = items;
+    this._items.parent = this;
+    const event = { items, previousItems };
+    for (const value of this.iterValues()) {
+      value.replaceItems(event);
+    }
+  }
+  getPlainSchema(options) {
+    if (this.$ref && options?.skip$Ref !== true) {
+      return addSharedFieldsFromState({ $ref: this.$ref }, this);
+    }
+    return addSharedFieldsFromState(
+      {
+        type: this.type,
+        items: this.items.getPlainSchema(options)
+      },
+      this
+    );
+  }
+  getOrCreateValues(rowId) {
+    let values = this.valuesMap.get(rowId);
+    if (!values) {
+      values = [];
+      this.valuesMap.set(rowId, values);
+    }
+    return values;
+  }
+  *iterValues() {
+    for (const values of this.valuesMap.values()) {
+      for (const value of values) {
+        yield value;
+      }
+    }
+  }
+};
+
+// src/model/value/json-string-value.store.ts
+var JsonStringValueStore = class {
+  constructor(schema, rowId, value = null) {
+    this.schema = schema;
+    this.rowId = rowId;
+    this.value = value;
+    this.index = this.schema.registerValue(this);
+  }
+  type = "string" /* String */;
+  index;
+  parent = null;
+  get foreignKey() {
+    return this.schema.foreignKey;
+  }
+  getPlainValue() {
+    return this.value ?? this.schema.default;
+  }
+};
+
+// src/model/value/json-number-value.store.ts
+var JsonNumberValueStore = class {
+  constructor(schema, rowId, value = null) {
+    this.schema = schema;
+    this.rowId = rowId;
+    this.value = value;
+    this.index = this.schema.registerValue(this);
+  }
+  type = "number" /* Number */;
+  index;
+  parent = null;
+  getPlainValue() {
+    return this.value ?? this.schema.default;
+  }
+};
+
+// src/model/value/json-boolean-value.store.ts
+var JsonBooleanValueStore = class {
+  constructor(schema, rowId, value = null) {
+    this.schema = schema;
+    this.rowId = rowId;
+    this.value = value;
+    this.index = this.schema.registerValue(this);
+  }
+  type = "boolean" /* Boolean */;
+  index;
+  parent = null;
+  getPlainValue() {
+    return this.value ?? this.schema.default;
+  }
+};
+
+// src/model/value/value-transformation.ts
+var equal = (value) => value;
+var fromNumberToString = (value, defaultValue = "") => value.toString() || defaultValue;
+var fromBooleanToString = (value, defaultValue = "") => value.toString() || defaultValue;
+var fromStringToBoolean = (value, defaultValue = false) => {
+  if (!value) {
+    return defaultValue;
+  }
+  if (value.toLowerCase() === "false") {
+    return false;
+  }
+  return true;
+};
+var fromStringToNumber = (value, defaultValue = 0) => {
+  const number = Number.parseFloat(value);
+  if (Number.isNaN(number)) {
+    return defaultValue;
+  }
+  return number;
+};
+var fromBooleanToNumber = (value) => {
+  return Number(value);
+};
+var fromNumberToBoolean = (value) => {
+  return Boolean(value);
+};
+var toArrayTransformation = (transformation) => (value) => {
+  const result = transformation(value);
+  return [result];
+};
+var fromArrayTransformation = (transformation) => (value) => {
+  if (Array.isArray(value) && value.length) {
+    return transformation(value[0]);
+  }
+  return void 0;
+};
+var fromObjectToPrimitive = (_value, defaultValue) => {
+  return defaultValue;
+};
+var fromPrimitiveToObject = (_value, defaultValue) => {
+  return defaultValue;
+};
+var fromObjectToArray = (_value, defaultValue) => {
+  return defaultValue;
+};
+var fromArrayToObject = (_value, defaultValue) => {
+  return defaultValue;
+};
+var replaceTransformationsMapper = [
+  {
+    fromType: "number" /* Number */,
+    toType: "string" /* String */,
+    transformation: fromNumberToString
+  },
+  {
+    fromType: "string" /* String */,
+    toType: "number" /* Number */,
+    transformation: fromStringToNumber
+  },
+  {
+    fromType: "boolean" /* Boolean */,
+    toType: "string" /* String */,
+    transformation: fromBooleanToString
+  },
+  {
+    fromType: "string" /* String */,
+    toType: "boolean" /* Boolean */,
+    transformation: fromStringToBoolean
+  },
+  {
+    fromType: "boolean" /* Boolean */,
+    toType: "number" /* Number */,
+    transformation: fromBooleanToNumber
+  },
+  {
+    fromType: "number" /* Number */,
+    toType: "boolean" /* Boolean */,
+    transformation: fromNumberToBoolean
+  }
+];
+var getTransformation = (from, to) => {
+  if (from instanceof JsonObjectStore && !(to instanceof JsonObjectStore) && !(to instanceof JsonArrayStore)) {
+    return fromObjectToPrimitive;
+  }
+  if (!(from instanceof JsonObjectStore) && !(from instanceof JsonArrayStore) && to instanceof JsonObjectStore) {
+    return fromPrimitiveToObject;
+  }
+  if (from instanceof JsonObjectStore && to instanceof JsonArrayStore) {
+    return fromObjectToArray;
+  }
+  if (from instanceof JsonArrayStore && to instanceof JsonObjectStore) {
+    return fromArrayToObject;
+  }
+  if (from instanceof JsonArrayStore && to instanceof JsonArrayStore) {
+    const itemTransformation = findTransformation(
+      from.items.type,
+      to.items.type
+    );
+    if (itemTransformation && itemTransformation !== equal) {
+      return (value, defaultValue) => {
+        if (!Array.isArray(value)) {
+          return defaultValue;
+        }
+        return value.map((item) => {
+          const result = itemTransformation(item, to.items.default);
+          return result !== void 0 ? result : to.items.default;
+        });
+      };
+    }
+    if (from.items.type !== to.items.type) {
+      return (_value, defaultValue) => defaultValue;
+    }
+    return equal;
+  }
+  if (to instanceof JsonArrayStore) {
+    const transformation = findTransformation(from.type, to.items.type);
+    if (!transformation) {
+      return;
+    }
+    return toArrayTransformation(transformation);
+  }
+  if (from instanceof JsonArrayStore) {
+    const transformation = findTransformation(from.items.type, to.type);
+    if (!transformation) {
+      return;
+    }
+    return fromArrayTransformation(transformation);
+  }
+  return findTransformation(from.type, to.type);
+};
+var findTransformation = (from, to) => {
+  if (from === to) {
+    return equal;
+  }
+  for (const item of replaceTransformationsMapper) {
+    if (item.fromType === from && item.toType === to) {
+      return item.transformation;
+    }
+  }
+  return void 0;
+};
+
+// src/model/value/json-object-value.store.ts
+var JsonObjectValueStore = class {
+  constructor(schema, rowId, value) {
+    this.schema = schema;
+    this.rowId = rowId;
+    this.value = value;
+    this.index = this.schema.registerValue(this);
+    this.init();
+  }
+  type = "object" /* Object */;
+  index;
+  parent = null;
+  getPlainValue() {
+    return Object.entries(this.value).reduce(
+      (result, [name, store]) => {
+        result[name] = store.getPlainValue();
+        return result;
+      },
+      {}
+    );
+  }
+  migrateProperty(event) {
+    const rawValue = this.getMigratedValue(event);
+    this.value[event.name] = createJsonValueStore(
+      event.property,
+      this.rowId,
+      rawValue
+    );
+  }
+  addProperty(event) {
+    const rawValue = this.getAddedValue(event);
+    this.value[event.name] = createJsonValueStore(
+      event.property,
+      this.rowId,
+      rawValue
+    );
+  }
+  removeProperty(event) {
+    delete this.value[event.name];
+  }
+  changeName(event) {
+    const itemValue = this.value[event.fromName];
+    if (itemValue !== void 0) {
+      delete this.value[event.fromName];
+      this.value[event.toName] = itemValue;
+    }
+  }
+  getAddedValue(event) {
+    const ancestorValue = this.findValueAtSchemaLevel(event.property);
+    if (ancestorValue !== void 0) {
+      return ancestorValue;
+    }
+    const previousValue = event.property.getValue(this.rowId, this.index);
+    if (previousValue) {
+      return previousValue.getPlainValue();
+    }
+    return event.property.default;
+  }
+  findValueAtSchemaLevel(targetSchema) {
+    let current = this.parent;
+    while (current) {
+      if (current.type === "object" /* Object */) {
+        for (const [, fieldValue] of Object.entries(current.value)) {
+          if (fieldValue.schema === targetSchema) {
+            return fieldValue.getPlainValue();
+          }
+        }
+      }
+      current = current.parent;
+    }
+    return void 0;
+  }
+  getMigratedValue(event) {
+    const transformation = getTransformation(
+      event.previousProperty,
+      event.property
+    );
+    const valueStore = this.value[event.name];
+    if (transformation && valueStore) {
+      return transformation(
+        valueStore.getPlainValue(),
+        event.property.default
+      );
+    }
+    return event.property.default;
+  }
+  init() {
+    for (const value of Object.values(this.value)) {
+      value.parent = this;
+    }
+  }
+};
+
+// src/lib/createJsonValueStore.ts
+var createJsonValueStore = (schema, rowId, rawValue) => {
+  if (schema.type === "object" /* Object */) {
+    return createJsonObjectValueStore(schema, rowId, rawValue);
+  } else if (schema.type === "array" /* Array */) {
+    return createJsonArrayValueStore(schema, rowId, rawValue);
+  } else {
+    return createPrimitiveValueStore(schema, rowId, rawValue);
+  }
+};
+var createJsonObjectValueStore = (schema, rowId, rawValue) => {
+  const value = Object.entries(rawValue).reduce(
+    (reduceValue, [key, itemValue]) => {
+      const itemSchema = schema.getProperty(key);
+      if (itemSchema === void 0 || itemValue === void 0) {
+        throw new Error("Invalid item");
+      }
+      reduceValue[key] = createJsonValueStore(itemSchema, rowId, itemValue);
+      return reduceValue;
+    },
+    {}
+  );
+  return new JsonObjectValueStore(schema, rowId, value);
+};
+var createJsonArrayValueStore = (schema, rowId, rawValue) => {
+  const value = rawValue.map(
+    (value2) => createJsonValueStore(schema.items, rowId, value2)
+  );
+  return new JsonArrayValueStore(schema, rowId, value);
+};
+var createPrimitiveValueStore = (schema, rowId, rawValue) => {
+  if (schema.type === "string" /* String */) {
+    return new JsonStringValueStore(schema, rowId, rawValue);
+  } else if (schema.type === "number" /* Number */) {
+    return new JsonNumberValueStore(schema, rowId, rawValue);
+  } else if (schema.type === "boolean" /* Boolean */) {
+    return new JsonBooleanValueStore(schema, rowId, rawValue);
+  } else {
+    throw new Error("this type is not allowed");
+  }
+};
+
+// src/model/value/json-array-value.store.ts
+var JsonArrayValueStore = class {
+  constructor(schema, rowId, value) {
+    this.schema = schema;
+    this.rowId = rowId;
+    this.value = value;
+    this.index = this.schema.registerValue(this);
+    this.init();
+  }
+  type = "array" /* Array */;
+  index;
+  parent = null;
+  getPlainValue() {
+    return this.value.map((item) => item.getPlainValue());
+  }
+  migrateItems(event) {
+    const transformation = getTransformation(event.previousItems, event.items);
+    this.value = this.value.map((valueItem) => {
+      const rawValue = transformation ? transformation(
+        valueItem.getPlainValue(),
+        event.items.default
+      ) : event.items.default;
+      return createJsonValueStore(event.items, this.rowId, rawValue);
+    });
+  }
+  replaceItems(event) {
+    this.value = this.value.map(() => {
+      const rawValue = this.getReplacedValue(event);
+      return createJsonValueStore(event.items, this.rowId, rawValue);
+    });
+  }
+  getReplacedValue(event) {
+    const previousValue = event.items.getValue(this.rowId);
+    if (previousValue) {
+      return previousValue.getPlainValue();
+    }
+    return event.items.default;
+  }
+  init() {
+    for (const value of this.value) {
+      value.parent = this;
+    }
+  }
+};
+
+exports.JsonArrayStore = JsonArrayStore;
+exports.JsonArrayValueStore = JsonArrayValueStore;
+exports.JsonBooleanStore = JsonBooleanStore;
+exports.JsonBooleanValueStore = JsonBooleanValueStore;
+exports.JsonNumberStore = JsonNumberStore;
+exports.JsonNumberValueStore = JsonNumberValueStore;
+exports.JsonObjectStore = JsonObjectStore;
+exports.JsonObjectValueStore = JsonObjectValueStore;
+exports.JsonStringStore = JsonStringStore;
+exports.JsonStringValueStore = JsonStringValueStore;
+exports.addSharedFieldsFromState = addSharedFieldsFromState;
+exports.createJsonArrayValueStore = createJsonArrayValueStore;
+exports.createJsonObjectValueStore = createJsonObjectValueStore;
+exports.createJsonValueStore = createJsonValueStore;
+exports.createPrimitiveValueStore = createPrimitiveValueStore;
+exports.equal = equal;
+exports.fromArrayToObject = fromArrayToObject;
+exports.fromArrayTransformation = fromArrayTransformation;
+exports.fromBooleanToNumber = fromBooleanToNumber;
+exports.fromBooleanToString = fromBooleanToString;
+exports.fromNumberToBoolean = fromNumberToBoolean;
+exports.fromNumberToString = fromNumberToString;
+exports.fromObjectToArray = fromObjectToArray;
+exports.fromObjectToPrimitive = fromObjectToPrimitive;
+exports.fromPrimitiveToObject = fromPrimitiveToObject;
+exports.fromStringToBoolean = fromStringToBoolean;
+exports.fromStringToNumber = fromStringToNumber;
+exports.getTransformation = getTransformation;
+exports.toArrayTransformation = toArrayTransformation;
+//# sourceMappingURL=chunk-JLIZ7QT2.cjs.map
+//# sourceMappingURL=chunk-JLIZ7QT2.cjs.map