@croct/sdk 0.17.9 → 0.17.11

package/utilityTypes.cjs

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utilityTypes_exports = {};
+module.exports = __toCommonJS(utilityTypes_exports);
+//# sourceMappingURL=utilityTypes.cjs.map

package/uuid.cjs

@@ -0,0 +1,55 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var uuid_exports = {};
+__export(uuid_exports, {
+  uuid4: () => uuid4
+});
+module.exports = __toCommonJS(uuid_exports);
+function uuid4(sortable = false) {
+  let uuid = "";
+  if (sortable) {
+    const prefix = Date.now().toString(16).padStart(12, "0").substring(0, 12);
+    uuid = `${prefix.substring(0, 8)}-${prefix.substring(8, 12)}`;
+  }
+  for (let index = uuid.length; index < 36; index++) {
+    switch (index) {
+      case 8:
+      case 13:
+      case 18:
+      case 23:
+        uuid += "-";
+        break;
+      case 14:
+        uuid += "4";
+        break;
+      default: {
+        let random = Math.random() * 16 | 0;
+        if (index === 19) {
+          random = random & 3 | 8;
+        }
+        uuid += random.toString(16);
+      }
+    }
+  }
+  return uuid;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uuid4
+});
+//# sourceMappingURL=uuid.cjs.map

package/validation/arrayType.cjs

@@ -0,0 +1,75 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var arrayType_exports = {};
+__export(arrayType_exports, {
+  ArrayType: () => ArrayType
+});
+module.exports = __toCommonJS(arrayType_exports);
+var import_schema = require("./schema");
+var import_violation = require("./violation");
+class ArrayType {
+  constructor(definition = {}) {
+    this.definition = {
+      ...definition,
+      minItems: definition.minItems ?? -1,
+      maxItems: definition.maxItems ?? -1
+    };
+  }
+  getTypes() {
+    return ["array"];
+  }
+  isValidType(value) {
+    return Array.isArray(value);
+  }
+  validate(value, path = []) {
+    if (!this.isValidType(value)) {
+      throw new import_schema.Violation(
+        `Expected value of type array at path '${(0, import_violation.formatPath)(path)}', actual ${(0, import_violation.describe)(value)}.`,
+        path,
+        { type: "string" }
+      );
+    }
+    const { minItems, maxItems } = this.definition;
+    const { length } = value;
+    if (minItems >= 0 && minItems > length) {
+      throw new import_schema.Violation(
+        `Expected ${minItems === maxItems ? "exactly" : "at least"} ${minItems} ${minItems === 1 ? "item" : "items"} at path '${(0, import_violation.formatPath)(path)}', actual ${length}.`,
+        path,
+        { limit: minItems }
+      );
+    }
+    if (maxItems >= 0 && maxItems < length) {
+      throw new import_schema.Violation(
+        `Expected ${minItems === maxItems ? "exactly" : "at most"} ${maxItems} ${maxItems === 1 ? "item" : "items"} at path '${(0, import_violation.formatPath)(path)}', actual ${length}.`,
+        path,
+        { limit: maxItems }
+      );
+    }
+    if (this.definition.items === void 0) {
+      return;
+    }
+    for (let index = 0; index < length; index++) {
+      this.definition.items.validate(value[index], path.concat([index.toString()]));
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayType
+});
+//# sourceMappingURL=arrayType.cjs.map

package/validation/booleanType.cjs

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var booleanType_exports = {};
+__export(booleanType_exports, {
+  BooleanType: () => BooleanType
+});
+module.exports = __toCommonJS(booleanType_exports);
+var import_schema = require("./schema");
+var import_violation = require("./violation");
+class BooleanType {
+  getTypes() {
+    return ["boolean"];
+  }
+  isValidType(value) {
+    return typeof value === "boolean";
+  }
+  validate(value, path = []) {
+    if (!this.isValidType(value)) {
+      throw new import_schema.Violation(
+        `Expected value of type boolean at path '${(0, import_violation.formatPath)(path)}', actual ${(0, import_violation.describe)(value)}.`,
+        path,
+        { type: "boolean" }
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BooleanType
+});
+//# sourceMappingURL=booleanType.cjs.map

package/validation/functionType.cjs

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var functionType_exports = {};
+__export(functionType_exports, {
+  FunctionType: () => FunctionType
+});
+module.exports = __toCommonJS(functionType_exports);
+var import_schema = require("./schema");
+var import_violation = require("./violation");
+class FunctionType {
+  getTypes() {
+    return ["function"];
+  }
+  isValidType(value) {
+    return typeof value === "function";
+  }
+  validate(value, path = []) {
+    if (!this.isValidType(value)) {
+      throw new import_schema.Violation(
+        `Expected value of type function at path '${(0, import_violation.formatPath)(path)}', actual ${(0, import_violation.describe)(value)}.`,
+        path,
+        { type: "function" }
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FunctionType
+});
+//# sourceMappingURL=functionType.cjs.map

package/validation/index.cjs

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validation_exports = {};
+__export(validation_exports, {
+  ArrayType: () => import_arrayType.ArrayType,
+  BooleanType: () => import_booleanType.BooleanType,
+  FunctionType: () => import_functionType.FunctionType,
+  JsonArrayType: () => import_jsonType.JsonArrayType,
+  JsonObjectType: () => import_jsonType.JsonObjectType,
+  JsonPrimitiveType: () => import_jsonType.JsonPrimitiveType,
+  JsonType: () => import_jsonType.JsonType,
+  MixedSchema: () => import_mixedSchema.MixedSchema,
+  NullType: () => import_nullType.NullType,
+  NumberType: () => import_numberType.NumberType,
+  ObjectType: () => import_objectType.ObjectType,
+  StringType: () => import_stringType.StringType,
+  UnionType: () => import_unionType.UnionType
+});
+module.exports = __toCommonJS(validation_exports);
+__reExport(validation_exports, require("./schema"), module.exports);
+__reExport(validation_exports, require("./violation"), module.exports);
+var import_arrayType = require("./arrayType");
+var import_booleanType = require("./booleanType");
+var import_functionType = require("./functionType");
+var import_jsonType = require("./jsonType");
+var import_mixedSchema = require("./mixedSchema");
+var import_nullType = require("./nullType");
+var import_numberType = require("./numberType");
+var import_objectType = require("./objectType");
+var import_stringType = require("./stringType");
+var import_unionType = require("./unionType");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayType,
+  BooleanType,
+  FunctionType,
+  JsonArrayType,
+  JsonObjectType,
+  JsonPrimitiveType,
+  JsonType,
+  MixedSchema,
+  NullType,
+  NumberType,
+  ObjectType,
+  StringType,
+  UnionType,
+  ...require("./schema"),
+  ...require("./violation")
+});
+//# sourceMappingURL=index.cjs.map

package/validation/jsonType.cjs

@@ -0,0 +1,142 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsonType_exports = {};
+__export(jsonType_exports, {
+  JsonArrayType: () => JsonArrayType,
+  JsonObjectType: () => JsonObjectType,
+  JsonPrimitiveType: () => JsonPrimitiveType,
+  JsonType: () => JsonType
+});
+module.exports = __toCommonJS(jsonType_exports);
+var import_schema = require("./schema");
+var import_violation = require("./violation");
+function isJsonPrimitive(value) {
+  return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number";
+}
+function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function isJsonArray(value) {
+  return Array.isArray(value) && value.every(isJsonValue);
+}
+function isJsonObject(value) {
+  return isPlainObject(value) && Object.values(value).every(isJsonValue);
+}
+function isJsonValue(value) {
+  return isJsonPrimitive(value) || isJsonArray(value) || isJsonObject(value);
+}
+class JsonObjectType {
+  constructor(definition = {}) {
+    this.definition = definition;
+  }
+  getTypes() {
+    return ["object"];
+  }
+  isValidType(value) {
+    return isPlainObject(value);
+  }
+  validate(value, path = []) {
+    if (!isJsonObject(value)) {
+      throw new import_schema.Violation(
+        `Expected a JSON object at path '${(0, import_violation.formatPath)(path)}', actual ${(0, import_violation.describe)(value)}.`,
+        path,
+        { type: "object" }
+      );
+    }
+    if (this.definition.properties === void 0 && this.definition.propertyNames === void 0) {
+      return;
+    }
+    for (const [entryName, entryValue] of Object.entries(value)) {
+      const propertyPath = path.concat([entryName]);
+      if (this.definition.propertyNames !== void 0) {
+        this.definition.propertyNames.validate(entryName, propertyPath);
+      }
+      if (this.definition.properties !== void 0) {
+        this.definition.properties.validate(entryValue, path.concat([entryName]));
+      }
+    }
+  }
+}
+class JsonArrayType {
+  constructor(definition = {}) {
+    this.definition = definition;
+  }
+  getTypes() {
+    return ["array"];
+  }
+  isValidType(value) {
+    return Array.isArray(value);
+  }
+  validate(value, path = []) {
+    if (!isJsonArray(value)) {
+      throw new import_schema.Violation(
+        `Expected a JSON array at path '${(0, import_violation.formatPath)(path)}', actual ${(0, import_violation.describe)(value)}.`,
+        path,
+        { type: "array" }
+      );
+    }
+    if (this.definition.items === void 0) {
+      return;
+    }
+    for (let index = 0; index < value.length; index++) {
+      this.definition.items.validate(value[index], path.concat([index.toString()]));
+    }
+  }
+}
+class JsonPrimitiveType {
+  getTypes() {
+    return ["null", "number", "string", "boolean"];
+  }
+  isValidType(value) {
+    return isJsonPrimitive(value);
+  }
+  validate(value, path = []) {
+    if (!this.isValidType(value)) {
+      throw new import_schema.Violation(
+        `Expected a JSON primitive at path '${(0, import_violation.formatPath)(path)}', actual ${(0, import_violation.describe)(value)}.`,
+        path,
+        { type: this.getTypes().join("|") }
+      );
+    }
+  }
+}
+class JsonType {
+  getTypes() {
+    return ["null", "number", "string", "boolean", "array", "object"];
+  }
+  isValidType(value) {
+    return isJsonPrimitive(value) || Array.isArray(value) || isPlainObject(value);
+  }
+  validate(value, path = []) {
+    if (!isJsonValue(value)) {
+      throw new import_schema.Violation(
+        `Expected a JSON value at path '${(0, import_violation.formatPath)(path)}', actual ${(0, import_violation.describe)(value)}.`,
+        path,
+        { type: this.getTypes().join("|") }
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonArrayType,
+  JsonObjectType,
+  JsonPrimitiveType,
+  JsonType
+});
+//# sourceMappingURL=jsonType.cjs.map

package/validation/mixedSchema.cjs

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mixedSchema_exports = {};
+__export(mixedSchema_exports, {
+  MixedSchema: () => MixedSchema
+});
+module.exports = __toCommonJS(mixedSchema_exports);
+class MixedSchema {
+  validate() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MixedSchema
+});
+//# sourceMappingURL=mixedSchema.cjs.map

package/validation/nullType.cjs

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var nullType_exports = {};
+__export(nullType_exports, {
+  NullType: () => NullType
+});
+module.exports = __toCommonJS(nullType_exports);
+var import_schema = require("./schema");
+var import_violation = require("./violation");
+class NullType {
+  getTypes() {
+    return ["null"];
+  }
+  isValidType(value) {
+    return value === null;
+  }
+  validate(value, path = []) {
+    if (!this.isValidType(value)) {
+      throw new import_schema.Violation(
+        `Expected value of type null at path '${(0, import_violation.formatPath)(path)}', actual ${(0, import_violation.describe)(value)}.`,
+        path,
+        { type: "null" }
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NullType
+});
+//# sourceMappingURL=nullType.cjs.map

package/validation/numberType.cjs

@@ -0,0 +1,69 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var numberType_exports = {};
+__export(numberType_exports, {
+  NumberType: () => NumberType
+});
+module.exports = __toCommonJS(numberType_exports);
+var import_schema = require("./schema");
+var import_violation = require("./violation");
+class NumberType {
+  constructor(definition = {}) {
+    this.definition = {
+      ...definition,
+      integer: definition.integer ?? false,
+      minimum: definition.minimum ?? Number.NEGATIVE_INFINITY,
+      maximum: definition.maximum ?? Number.POSITIVE_INFINITY
+    };
+  }
+  getTypes() {
+    return [this.definition.integer ? "integer" : "number"];
+  }
+  isValidType(value) {
+    return typeof value === "number" && (!this.definition.integer || Number.isInteger(value));
+  }
+  validate(value, path = []) {
+    if (!this.isValidType(value)) {
+      const type = this.getTypes()[0];
+      throw new import_schema.Violation(
+        `Expected value of type ${type} at path '${(0, import_violation.formatPath)(path)}', actual ${(0, import_violation.describe)(value)}.`,
+        path,
+        { type }
+      );
+    }
+    if (value < this.definition.minimum) {
+      throw new import_schema.Violation(
+        `Expected a value greater than or equal to ${this.definition.minimum} at path '${(0, import_violation.formatPath)(path)}', actual ${value}.`,
+        path,
+        { limit: this.definition.minimum }
+      );
+    }
+    if (value > this.definition.maximum) {
+      throw new import_schema.Violation(
+        `Expected a value less than or equal to ${this.definition.maximum} at path '${(0, import_violation.formatPath)(path)}', actual ${value}.`,
+        path,
+        { limit: this.definition.maximum }
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NumberType
+});
+//# sourceMappingURL=numberType.cjs.map