@h3ravel/arquebus 0.1.4

package/dist/browser/index.js

@@ -0,0 +1,1341 @@
+// src/casts/attribute.js
+var Attribute = class _Attribute {
+  get;
+  set;
+  withCaching = false;
+  withObjectCaching = true;
+  constructor({ get = null, set = null }) {
+    this.get = get;
+    this.set = set;
+  }
+  static make(get = null, set = null) {
+    return new _Attribute(get, set);
+  }
+  static get(get) {
+    return new _Attribute(get);
+  }
+  static set(set) {
+    return new _Attribute(null, set);
+  }
+  withoutObjectCaching() {
+    this.withObjectCaching = false;
+    return this;
+  }
+  shouldCache() {
+    this.withCaching = true;
+    return this;
+  }
+};
+var attribute_default = Attribute;
+
+// src/casts-attributes.js
+var CastsAttributes = class _CastsAttributes {
+  constructor() {
+    if (this.constructor === _CastsAttributes) {
+      throw new Error("CastsAttributes cannot be instantiated");
+    }
+  }
+  static get() {
+    throw new Error("get not implemented");
+  }
+  static set() {
+    throw new Error("set not implemented");
+  }
+};
+var casts_attributes_default = CastsAttributes;
+
+// src/browser/collection.js
+import { Collection as BaseCollection, collect as collect2 } from "collect.js";
+import { isArray as isArray2, isEmpty, omit as omit3, pick } from "radashi";
+
+// src/utils.js
+import { camel, dash, snake, trim } from "radashi";
+import advancedFormat from "dayjs/plugin/advancedFormat";
+import dayjs from "dayjs";
+dayjs.extend(advancedFormat);
+var now = (format = "YYYY-MM-DD HH:mm:ss") => dayjs().format(format);
+var getRelationName = (relationMethod) => {
+  return snake(relationMethod.substring(8));
+};
+var getScopeName = (scopeMethod) => {
+  return snake(scopeMethod.substring(5));
+};
+var getRelationMethod = (relation) => {
+  return camel(`relation_${relation}`);
+};
+var getScopeMethod = (scope) => {
+  return camel(`scope_${scope}`);
+};
+var getAttrMethod = (attr) => {
+  return camel(`attribute_${attr}`);
+};
+var getGetterMethod = (attr) => {
+  return camel(`get_${attr}_attribute`);
+};
+var getSetterMethod = (attr) => {
+  return camel(`set_${attr}_attribute`);
+};
+var getAttrName = (attrMethod) => {
+  return attrMethod.substring(3, attrMethod.length - 9).toLowerCase();
+};
+var tap = (instance, callback) => {
+  const result = callback(instance);
+  return result instanceof Promise ? result.then(() => instance) : instance;
+};
+function compose(Base, ...mixins) {
+  return mixins.reduce(
+    (cls, mixin) => mixin(cls),
+    Base
+  );
+}
+var flattenDeep = (arr) => Array.isArray(arr) ? arr.reduce((a, b) => a.concat(flattenDeep(b)), []) : [arr];
+var kebabCase = (str) => trim(dash(str.replace(/[^a-zA-Z0-9_-]/g, "-")), "_-");
+var snakeCase = (str) => trim(snake(str.replace(/[^a-zA-Z0-9_-]/g, "-")), "_-");
+
+// src/browser/relations/relation.js
+var Relation = class {
+  parent;
+  related;
+  eagerKeysWereEmpty = false;
+  static constraints = true;
+  constructor(related, parent) {
+    this.parent = parent;
+    this.related = related;
+  }
+  asProxy() {
+    const handler = {
+      get: function(target, prop) {
+        if (typeof target[prop] !== "undefined") {
+          return target[prop];
+        }
+        if (typeof prop === "string") {
+          return () => target.asProxy();
+        }
+      }
+    };
+    return new Proxy(this, handler);
+  }
+  getRelated() {
+    return this.related;
+  }
+};
+var relation_default = Relation;
+
+// src/browser/relations/belongs-to.js
+var BelongsTo = class extends relation_default {
+  foreignKey;
+  ownerKey;
+  child;
+  relationName;
+  constructor(related, child, foreignKey, ownerKey, relationName) {
+    super(related, child);
+    this.foreignKey = foreignKey;
+    this.ownerKey = ownerKey;
+    this.child = child;
+    this.relationName = relationName;
+    return this.asProxy();
+  }
+};
+var belongs_to_default = BelongsTo;
+
+// src/browser/relations/belongs-to-many.js
+var BelongsToMany = class extends relation_default {
+  table;
+  foreignPivotKey;
+  relatedPivotKey;
+  parentKey;
+  relatedKey;
+  pivotColumns = [];
+  pivotValues = [];
+  pivotWheres = [];
+  pivotWhereIns = [];
+  pivotWhereNulls = [];
+  accessor = "pivot";
+  // withTimestamps = false;
+  using;
+  pivotCreatedAt;
+  pivotUpdatedAt;
+  constructor(related, parent, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
+    super(related, parent);
+    this.table = table;
+    this.foreignPivotKey = foreignPivotKey;
+    this.relatedPivotKey = relatedPivotKey;
+    this.parentKey = parentKey;
+    this.relatedKey = relatedKey;
+    return this.asProxy();
+  }
+};
+var belongs_to_many_default = BelongsToMany;
+
+// src/concerns/has-attributes.js
+import { flat as flatten, omit } from "radashi";
+import collect from "collect.js";
+import dayjs2 from "dayjs";
+var HasAttributes = (Model2) => {
+  return class extends Model2 {
+    static castTypeCache = {};
+    attributes = {};
+    original = {};
+    casts = {};
+    changes = {};
+    appends = [];
+    setAppends(appends) {
+      this.appends = appends;
+      return this;
+    }
+    append(...keys) {
+      const appends = flattenDeep(keys);
+      this.appends = [...this.appends, ...appends];
+      return this;
+    }
+    normalizeCastClassResponse(key, value) {
+      return value?.constructor?.name === "Object" ? value : {
+        [key]: value
+      };
+    }
+    syncOriginal() {
+      this.original = this.getAttributes();
+      return this;
+    }
+    syncChanges() {
+      this.changes = this.getDirty();
+      return this;
+    }
+    syncOriginalAttribute(attribute) {
+      this.syncOriginalAttributes(attribute);
+    }
+    syncOriginalAttributes(...attributes) {
+      attributes = flattenDeep(attributes);
+      const modelAttributes = this.getAttributes();
+      for (const attribute of attributes) {
+        this.original[attribute] = modelAttributes[attribute];
+      }
+      return this;
+    }
+    isDirty(...attributes) {
+      const changes = this.getDirty();
+      attributes = flattenDeep(attributes);
+      if (attributes.length === 0) {
+        return Object.keys(changes).length > 0;
+      }
+      for (const attribute of attributes) {
+        if (attribute in changes) {
+          return true;
+        }
+      }
+      return false;
+    }
+    getDirty() {
+      const dirty = {};
+      const attributes = this.getAttributes();
+      for (const key in attributes) {
+        const value = attributes[key];
+        if (!this.originalIsEquivalent(key)) {
+          dirty[key] = value;
+        }
+      }
+      return dirty;
+    }
+    originalIsEquivalent(key) {
+      if (this.original[key] === void 0) {
+        return false;
+      }
+      const attribute = this.attributes[key];
+      const original = this.original[key];
+      if (attribute === original) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+    setAttributes(attributes) {
+      this.attributes = { ...attributes };
+    }
+    setRawAttributes(attributes, sync = false) {
+      this.attributes = attributes;
+      if (sync) {
+        this.syncOriginal();
+      }
+      return this;
+    }
+    getAttributes() {
+      return { ...this.attributes };
+    }
+    setAttribute(key, value) {
+      const setterMethod = getSetterMethod(key);
+      if (typeof this[setterMethod] === "function") {
+        this[setterMethod](value);
+        return this;
+      }
+      const attrMethod = getAttrMethod(key);
+      if (typeof this[attrMethod] === "function") {
+        const attribute = this[attrMethod]();
+        const callback = attribute.set || ((value2) => {
+          this.attributes[key] = value2;
+        });
+        this.attributes = {
+          ...this.attributes,
+          ...this.normalizeCastClassResponse(key, callback(value, this.attributes))
+        };
+        return this;
+      }
+      const casts = this.getCasts();
+      const castType = casts[key];
+      if (this.isCustomCast(castType)) {
+        value = castType.set(this, key, value, this.attributes);
+      }
+      if (castType === "json") {
+        value = JSON.stringify(value);
+      }
+      if (castType === "collection") {
+        value = JSON.stringify(value);
+      }
+      if (value !== null && this.isDateAttribute(key)) {
+        value = this.fromDateTime(value);
+      }
+      this.attributes[key] = value;
+      return this;
+    }
+    getAttribute(key) {
+      if (!key) {
+        return;
+      }
+      const getterMethod = getGetterMethod(key);
+      if (typeof this[getterMethod] === "function") {
+        return this[getterMethod](this.attributes[key], this.attributes);
+      }
+      const attrMethod = getAttrMethod(key);
+      if (typeof this[attrMethod] === "function") {
+        const caster = this[attrMethod]();
+        return caster.get(this.attributes[key], this.attributes);
+      }
+      if (key in this.attributes) {
+        if (this.hasCast(key)) {
+          return this.castAttribute(key, this.attributes[key]);
+        }
+        if (this.getDates().includes(key)) {
+          return this.asDateTime(this.attributes[key]);
+        }
+        return this.attributes[key];
+      }
+      if (key in this.relations) {
+        return this.relations[key];
+      }
+      return;
+    }
+    castAttribute(key, value) {
+      const castType = this.getCastType(key);
+      if (!castType) {
+        return value;
+      }
+      if (value === null) {
+        return value;
+      }
+      switch (castType) {
+        case "int":
+        case "integer":
+          return parseInt(value);
+        case "real":
+        case "float":
+        case "double":
+          return parseFloat(value);
+        case "decimal":
+          return this.asDecimal(value, castType.split(":")[1]);
+        case "string":
+          return String(value);
+        case "bool":
+        case "boolean":
+          return Boolean(value);
+        case "object":
+        case "json":
+          try {
+            return JSON.parse(value);
+          } catch (e) {
+            return null;
+          }
+        case "collection":
+          try {
+            return collect(JSON.parse(value));
+          } catch (e) {
+            return collect([]);
+          }
+        case "date":
+          return this.asDate(value);
+        case "datetime":
+        case "custom_datetime":
+          return this.asDateTime(value);
+        case "timestamp":
+          return this.asTimestamp(value);
+      }
+      if (this.isCustomCast(castType)) {
+        return castType.get(this, key, value, this.attributes);
+      }
+      return value;
+    }
+    attributesToData() {
+      let attributes = { ...this.attributes };
+      for (const key in attributes) {
+        if (this.hidden.includes(key)) {
+          attributes = omit(attributes, [key]);
+        }
+        if (this.visible.length > 0 && this.visible.includes(key) === false) {
+          attributes = omit(attributes, [key]);
+        }
+      }
+      for (const key of this.getDates()) {
+        if (attributes[key] === void 0) {
+          continue;
+        }
+        attributes[key] = this.serializeDate(this.asDateTime(attributes[key]));
+      }
+      const casts = this.getCasts();
+      for (const key in casts) {
+        const value = casts[key];
+        if (key in attributes === false) {
+          continue;
+        }
+        attributes[key] = this.castAttribute(key, attributes[key]);
+        if (key in attributes && ["date", "datetime"].includes(value)) {
+          attributes[key] = this.serializeDate(attributes[key]);
+        }
+        if (key in attributes && this.isCustomDateTimeCast(value)) {
+          attributes[key] = dayjs2(attributes[key]).format(value.split(":")[1]);
+        }
+      }
+      for (const key of this.appends) {
+        attributes[key] = this.mutateAttribute(key, null);
+      }
+      return attributes;
+    }
+    mutateAttribute(key, value) {
+      if (typeof this[getGetterMethod(key)] === "function") {
+        return this[getGetterMethod(key)](value);
+      } else if (typeof this[getAttrMethod(key)] === "function") {
+        const caster = this[getAttrMethod(key)]();
+        return caster.get(key, this.attributes);
+      } else if (key in this) {
+        return this[key];
+      }
+      return value;
+    }
+    mutateAttributeForArray(key, value) {
+    }
+    isDateAttribute(key) {
+      return this.getDates().includes(key) || this.isDateCastable(key);
+    }
+    serializeDate(date) {
+      return date ? dayjs2(date).toISOString() : null;
+    }
+    getDates() {
+      return this.usesTimestamps() ? [
+        this.getCreatedAtColumn(),
+        this.getUpdatedAtColumn()
+      ] : [];
+    }
+    getCasts() {
+      if (this.getIncrementing()) {
+        return {
+          [this.getKeyName()]: this.getKeyType(),
+          ...this.casts
+        };
+      }
+      return this.casts;
+    }
+    getCastType(key) {
+      const castType = this.getCasts()[key];
+      let castTypeCacheKey;
+      if (typeof castType === "string") {
+        castTypeCacheKey = castType;
+      } else if (new castType() instanceof casts_attributes_default) {
+        castTypeCacheKey = castType.name;
+      }
+      if (castTypeCacheKey && this.constructor.castTypeCache[castTypeCacheKey] !== void 0) {
+        return this.constructor.castTypeCache[castTypeCacheKey];
+      }
+      let convertedCastType;
+      if (this.isCustomDateTimeCast(castType)) {
+        convertedCastType = "custom_datetime";
+      } else if (this.isDecimalCast(castType)) {
+        convertedCastType = "decimal";
+      } else if (this.isCustomCast(castType)) {
+        convertedCastType = castType;
+      } else {
+        convertedCastType = castType.toLocaleLowerCase().trim();
+      }
+      return this.constructor.castTypeCache[castTypeCacheKey] = convertedCastType;
+    }
+    hasCast(key, types = []) {
+      if (key in this.casts) {
+        types = flatten(types);
+        return types.length > 0 ? types.includes(this.getCastType(key)) : true;
+      }
+      return false;
+    }
+    withDayjs(date) {
+      return dayjs2(date);
+    }
+    isCustomCast(cast) {
+      return typeof cast === "function" && new cast() instanceof casts_attributes_default;
+    }
+    isCustomDateTimeCast(cast) {
+      if (typeof cast !== "string") {
+        return false;
+      }
+      return cast.startsWith("date:") || cast.startsWith("datetime:");
+    }
+    isDecimalCast(cast) {
+      if (typeof cast !== "string") {
+        return false;
+      }
+      return cast.startsWith("decimal:");
+    }
+    isDateCastable(key) {
+      return this.hasCast(key, ["date", "datetime"]);
+    }
+    fromDateTime(value) {
+      return dayjs2(this.asDateTime(value)).format(this.getDateFormat());
+    }
+    getDateFormat() {
+      return this.dateFormat || "YYYY-MM-DD HH:mm:ss";
+    }
+    asDecimal(value, decimals) {
+      return parseFloat(value).toFixed(decimals);
+    }
+    asDateTime(value) {
+      if (value === null) {
+        return null;
+      }
+      if (value instanceof Date) {
+        return value;
+      }
+      if (typeof value === "number") {
+        return new Date(value * 1e3);
+      }
+      return new Date(value);
+    }
+    asDate(value) {
+      const date = this.asDateTime(value);
+      return dayjs2(date).startOf("day").toDate();
+    }
+  };
+};
+var has_attributes_default = HasAttributes;
+
+// src/browser/relations/has-many.js
+var HasMany = class extends relation_default {
+  foreignKey;
+  localKey;
+  constructor(related, parent, foreignKey, localKey) {
+    super(related, parent);
+    this.foreignKey = foreignKey;
+    this.localKey = localKey;
+    return this.asProxy();
+  }
+};
+var has_many_default = HasMany;
+
+// src/browser/relations/has-one.js
+var HasOne = class extends relation_default {
+  foreignKey;
+  localKey;
+  constructor(related, parent, foreignKey, localKey) {
+    super(related, parent);
+    this.foreignKey = foreignKey;
+    this.localKey = localKey;
+    return this.asProxy();
+  }
+};
+var has_one_default = HasOne;
+
+// src/browser/relations/has-many-through.js
+var HasManyThrough = class extends relation_default {
+  throughParent;
+  farParent;
+  firstKey;
+  secondKey;
+  localKey;
+  secondLocalKey;
+  constructor(query, farParent, throughParent, firstKey, secondKey, localKey, secondLocalKey) {
+    super(query, throughParent);
+    this.localKey = localKey;
+    this.firstKey = firstKey;
+    this.secondKey = secondKey;
+    this.farParent = farParent;
+    this.throughParent = throughParent;
+    this.secondLocalKey = secondLocalKey;
+    return this.asProxy();
+  }
+};
+var has_many_through_default = HasManyThrough;
+
+// src/browser/relations/has-one-through.js
+var HasOneThrough = class extends has_many_through_default {
+};
+var has_one_through_default = HasOneThrough;
+
+// src/errors.js
+import { isArray } from "radashi";
+var BaseError = class extends Error {
+  constructor(message, entity) {
+    super(message);
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+    this.message = message;
+  }
+};
+var ModelNotFoundError = class extends BaseError {
+  model;
+  ids;
+  setModel(model, ids = []) {
+    this.model = model;
+    this.ids = isArray(ids) ? ids : [ids];
+    this.message = `No query results for model [${model}]`;
+    if (this.ids.length > 0) {
+      this.message += " " + this.ids.join(", ");
+    } else {
+      this.message += ".";
+    }
+    return this;
+  }
+  getModel() {
+    return this.model;
+  }
+  getIds() {
+    return this.ids;
+  }
+};
+var RelationNotFoundError = class extends BaseError {
+};
+var InvalidArgumentError = class extends BaseError {
+};
+
+// src/browser/concerns/has-relations.js
+import { omit as omit2 } from "radashi";
+var HasRelations = (Model2) => {
+  return class extends Model2 {
+    relations = {};
+    getRelation(relation) {
+      return this.relations[relation];
+    }
+    setRelation(relation, value) {
+      this.relations[relation] = value;
+      return this;
+    }
+    unsetRelation(relation) {
+      this.relations = omit2(this.relations, [relation]);
+      return this;
+    }
+    relationLoaded(relation) {
+      return this.relations[relation] !== void 0;
+    }
+    related(relation) {
+      if (typeof this[getRelationMethod(relation)] !== "function") {
+        const message = `Model [${this.constructor.name}]'s relation [${relation}] doesn't exist.`;
+        throw new RelationNotFoundError(message);
+      }
+      return this[getRelationMethod(relation)]();
+    }
+    async getRelated(relation) {
+      return await this.related(relation).getResults();
+    }
+    relationsToData() {
+      const data = {};
+      for (const key in this.relations) {
+        if (this.hidden.includes(key)) {
+          continue;
+        }
+        if (this.visible.length > 0 && this.visible.includes(key) === false) {
+          continue;
+        }
+        data[key] = this.relations[key] instanceof Array ? this.relations[key].map((item) => item.toData()) : this.relations[key] === null ? null : this.relations[key].toData();
+      }
+      return data;
+    }
+    guessBelongsToRelation() {
+      let e = new Error();
+      let frame = e.stack.split("\n")[2];
+      let functionName = frame.split(" ")[5];
+      return getRelationName(functionName);
+    }
+    joiningTable(related, instance = null) {
+      const segments = [
+        instance ? instance.joiningTableSegment() : snakeCase(related.name),
+        this.joiningTableSegment()
+      ];
+      return segments.sort().join("_").toLocaleLowerCase();
+    }
+    joiningTableSegment() {
+      return snakeCase(this.constructor.name);
+    }
+    hasOne(related, foreignKey = null, localKey = null) {
+      const instance = new related();
+      foreignKey = foreignKey || this.getForeignKey();
+      localKey = localKey || this.getKeyName();
+      return new has_one_default(related, this, instance.getTable() + "." + foreignKey, localKey);
+    }
+    hasMany(related, foreignKey = null, localKey = null) {
+      const instance = new related();
+      foreignKey = foreignKey || this.getForeignKey();
+      localKey = localKey || this.getKeyName();
+      return new has_many_default(related, this, instance.getTable() + "." + foreignKey, localKey);
+    }
+    belongsTo(related, foreignKey = null, ownerKey = null, relation = null) {
+      const instance = new related();
+      foreignKey = foreignKey || instance.getForeignKey();
+      ownerKey = ownerKey || instance.getKeyName();
+      relation = relation || this.guessBelongsToRelation();
+      return new belongs_to_default(related, this, foreignKey, ownerKey, relation);
+    }
+    belongsToMany(related, table = null, foreignPivotKey = null, relatedPivotKey = null, parentKey = null, relatedKey = null) {
+      const instance = new related();
+      const query = related.query();
+      table = table || this.joiningTable(related, instance);
+      foreignPivotKey = foreignPivotKey || this.getForeignKey();
+      relatedPivotKey = relatedPivotKey || instance.getForeignKey();
+      parentKey = parentKey || this.getKeyName();
+      relatedKey = relatedKey || instance.getKeyName();
+      return new belongs_to_many_default(query, this, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey);
+    }
+    hasOneThrough(related, through, firstKey = null, secondKey = null, localKey = null, secondLocalKey = null) {
+      through = new through();
+      const query = related.query();
+      firstKey = firstKey || this.getForeignKey();
+      secondKey = secondKey || through.getForeignKey();
+      return new has_one_through_default(query, this, through, firstKey, secondKey, localKey || this.getKeyName(), secondLocalKey || through.getKeyName());
+    }
+    hasManyThrough(related, through, firstKey = null, secondKey = null, localKey = null, secondLocalKey = null) {
+      through = new through();
+      const query = related.query();
+      firstKey = firstKey || this.getForeignKey();
+      secondKey = secondKey || through.getForeignKey();
+      return new has_many_through_default(query, this, through, firstKey, secondKey, localKey || this.getKeyName(), secondLocalKey || through.getKeyName());
+    }
+  };
+};
+var has_relations_default = HasRelations;
+
+// src/concerns/has-timestamps.js
+var HasTimestamps = (Model2) => {
+  return class extends Model2 {
+    static CREATED_AT = "created_at";
+    static UPDATED_AT = "updated_at";
+    static DELETED_AT = "deleted_at";
+    timestamps = true;
+    dateFormat = "YYYY-MM-DD HH:mm:ss";
+    usesTimestamps() {
+      return this.timestamps;
+    }
+    updateTimestamps() {
+      const time = this.freshTimestampString();
+      const updatedAtColumn = this.getUpdatedAtColumn();
+      if (updatedAtColumn && !this.isDirty(updatedAtColumn)) {
+        this.setUpdatedAt(time);
+      }
+      const createdAtColumn = this.getCreatedAtColumn();
+      if (!this.exists && createdAtColumn && !this.isDirty(createdAtColumn)) {
+        this.setCreatedAt(time);
+      }
+      return this;
+    }
+    getCreatedAtColumn() {
+      return this.constructor.CREATED_AT;
+    }
+    getUpdatedAtColumn() {
+      return this.constructor.UPDATED_AT;
+    }
+    setCreatedAt(value) {
+      this.attributes[this.getCreatedAtColumn()] = value;
+      return this;
+    }
+    setUpdatedAt(value) {
+      this.attributes[this.getUpdatedAtColumn()] = value;
+      return this;
+    }
+    freshTimestamp() {
+      const time = /* @__PURE__ */ new Date();
+      time.setMilliseconds(0);
+      return time;
+    }
+    freshTimestampString() {
+      return this.fromDateTime(this.freshTimestamp());
+    }
+  };
+};
+var has_timestamps_default = HasTimestamps;
+
+// src/concerns/hides-attributes.js
+import { diff as difference } from "radashi";
+var HidesAttributes = (Model2) => {
+  return class extends Model2 {
+    hidden = [];
+    visible = [];
+    makeVisible(...keys) {
+      const visible = flattenDeep(keys);
+      if (this.visible.length > 0) {
+        this.visible = [...this.visible, ...visible];
+      }
+      this.hidden = difference(this.hidden, visible);
+      return this;
+    }
+    makeHidden(...keys) {
+      const hidden = flattenDeep(keys);
+      if (this.hidden.length > 0) {
+        this.hidden = [...this.hidden, ...hidden];
+      }
+      return this;
+    }
+    getHidden() {
+      return this.hidden;
+    }
+    getVisible() {
+      return this.visible;
+    }
+    setHidden(hidden) {
+      this.hidden = hidden;
+      return this;
+    }
+    setVisible(visible) {
+      this.visible = visible;
+      return this;
+    }
+  };
+};
+var hides_attributes_default = HidesAttributes;
+
+// src/browser/model.js
+import { assign as merge } from "radashi";
+import pluralize from "pluralize";
+var BaseModel = compose(class {
+}, has_attributes_default, hides_attributes_default, has_relations_default, has_timestamps_default);
+var Model = class _Model extends BaseModel {
+  primaryKey = "id";
+  // protected
+  table = null;
+  // protected
+  keyType = "int";
+  // protected
+  perPage = 15;
+  // protected
+  static globalScopes = {};
+  static pluginInitializers = {};
+  static _booted = {};
+  static resolver = null;
+  static browser = true;
+  static init(attributes = {}) {
+    return new this(attributes);
+  }
+  static extend(plugin, options) {
+    plugin(this, options);
+  }
+  static make(attributes = {}) {
+    const instance = new this();
+    for (let attribute in attributes) {
+      if (typeof instance[getRelationMethod(attribute)] !== "function") {
+        instance.setAttribute(attribute, attributes[attribute]);
+      } else {
+        const relation = instance[getRelationMethod(attribute)]();
+        if (relation instanceof has_one_default || relation instanceof belongs_to_default) {
+          instance.setRelation(attribute, relation.related.make(attributes[attribute]));
+        } else if ((relation instanceof has_many_default || relation instanceof belongs_to_many_default) && Array.isArray(attributes[attribute])) {
+          instance.setRelation(attribute, new collection_default(attributes[attribute].map((item) => relation.related.make(item))));
+        }
+      }
+    }
+    return instance;
+  }
+  constructor(attributes = {}) {
+    super();
+    this.bootIfNotBooted();
+    this.initializePlugins();
+    this.syncOriginal();
+    this.fill(attributes);
+    return this.asProxy();
+  }
+  bootIfNotBooted() {
+    if (this.constructor._booted[this.constructor.name] === void 0) {
+      this.constructor._booted[this.constructor.name] = true;
+      this.constructor.booting();
+      this.initialize();
+      this.constructor.boot();
+      this.constructor.booted();
+    }
+  }
+  static booting() {
+  }
+  static boot() {
+  }
+  static booted() {
+  }
+  static setConnectionResolver(resolver) {
+    this.resolver = resolver;
+  }
+  initialize() {
+  }
+  initializePlugins() {
+    if (typeof this.constructor.pluginInitializers[this.constructor.name] === "undefined") {
+      return;
+    }
+    for (const method of this.constructor.pluginInitializers[this.constructor.name]) {
+      this[method]();
+    }
+  }
+  addPluginInitializer(method) {
+    if (!this.constructor.pluginInitializers[this.constructor.name]) {
+      this.constructor.pluginInitializers[this.constructor.name] = [];
+    }
+    this.constructor.pluginInitializers[this.constructor.name].push(method);
+  }
+  newInstance(attributes = {}, exists = false) {
+    const model = new this.constructor();
+    model.exists = exists;
+    model.setTable(this.getTable());
+    model.fill(attributes);
+    return model;
+  }
+  asProxy() {
+    const handler = {
+      get: function(target, prop) {
+        if (target[prop] !== void 0) {
+          return target[prop];
+        }
+        if (typeof prop === "string") {
+          return target.getAttribute(prop);
+        }
+      },
+      set: function(target, prop, value) {
+        if (target[prop] !== void 0 && typeof target !== "function") {
+          target[prop] = value;
+          return target;
+        }
+        if (typeof prop === "string") {
+          return target.setAttribute(prop, value);
+        }
+        return target;
+      }
+    };
+    return new Proxy(this, handler);
+  }
+  getKey() {
+    return this.getAttribute(this.getKeyName());
+  }
+  getKeyName() {
+    return this.primaryKey;
+  }
+  getForeignKey() {
+    return snakeCase(this.constructor.name) + "_" + this.getKeyName();
+  }
+  getConnectionName() {
+    return this.connection;
+  }
+  getTable() {
+    return this.table || pluralize(snakeCase(this.constructor.name));
+  }
+  setConnection(connection) {
+    this.connection = connection;
+    return this;
+  }
+  getKeyType() {
+    return this.keyType;
+  }
+  hasNamedScope(name) {
+    const scope = getScopeMethod(name);
+    return typeof this[scope] === "function";
+  }
+  callNamedScope(scope, parameters) {
+    const scopeMethod = getScopeMethod(scope);
+    return this[scopeMethod](...parameters);
+  }
+  setTable(table) {
+    this.table = table;
+    return this;
+  }
+  newCollection(models = []) {
+    return new collection_default(models);
+  }
+  getIncrementing() {
+    return this.incrementing;
+  }
+  setIncrementing(value) {
+    this.incrementing = value;
+    return this;
+  }
+  toData() {
+    return merge(this.attributesToData(), this.relationsToData());
+  }
+  toJSON() {
+    return this.toData();
+  }
+  toJson(...args) {
+    return JSON.stringify(this.toData(), ...args);
+  }
+  toString() {
+    return this.toJson();
+  }
+  fill(attributes) {
+    for (const key in attributes) {
+      this.setAttribute(key, attributes[key]);
+    }
+    return this;
+  }
+  transacting(trx) {
+    this.trx = trx;
+    return this;
+  }
+  trashed() {
+    return this[this.getDeletedAtColumn()] !== null;
+  }
+  newPivot(parent, attributes, table, exists, using = null) {
+    return using ? using.fromRawAttributes(parent, attributes, table, exists) : Pivot.fromAttributes(parent, attributes, table, exists);
+  }
+  qualifyColumn(column) {
+    if (column.includes(".")) {
+      return column;
+    }
+    return `${this.getTable()}.${column}`;
+  }
+  getQualifiedKeyName() {
+    return this.qualifyColumn(this.getKeyName());
+  }
+  is(model) {
+    return model && model instanceof _Model && this.getKey() === model.getKey() && this.getTable() === model.getTable();
+  }
+  isNot(model) {
+    return !this.is(model);
+  }
+};
+var Pivot = class extends Model {
+  incrementing = false;
+  guarded = [];
+  pivotParent = null;
+  foreignKey = null;
+  relatedKey = null;
+  setPivotKeys(foreignKey, relatedKey) {
+    this.foreignKey = foreignKey;
+    this.relatedKey = relatedKey;
+    return this;
+  }
+  static fromRawAttributes(parent, attributes, table, exists = false) {
+    const instance = this.fromAttributes(parent, {}, table, exists);
+    instance.timestamps = instance.hasTimestampAttributes(attributes);
+    instance.attributes = attributes;
+    instance.exists = exists;
+    return instance;
+  }
+  static fromAttributes(parent, attributes, table, exists = false) {
+    const instance = new this();
+    instance.timestamps = instance.hasTimestampAttributes(attributes);
+    instance.setConnection(parent.connection).setTable(table).fill(attributes).syncOriginal();
+    instance.pivotParent = parent;
+    instance.exists = exists;
+    return instance;
+  }
+  hasTimestampAttributes(attributes = null) {
+    return (attributes || this.attributes)[this.constructor.CREATED_AT] !== void 0;
+  }
+};
+var model_default = Model;
+
+// src/browser/collection.js
+var Collection = class _Collection extends BaseCollection {
+  mapThen(callback) {
+    return Promise.all(this.map(callback));
+  }
+  modelKeys() {
+    return this.all().map((item) => item.getKey());
+  }
+  contains(key, operator = null, value = null) {
+    if (arguments.length > 1) {
+      return super.contains(key, operator, value);
+    }
+    if (key instanceof model_default) {
+      return super.contains((model) => {
+        return model.is(key);
+      });
+    }
+    return super.contains((model) => {
+      return model.getKey() == key;
+    });
+  }
+  diff(items) {
+    const diff = new this.constructor();
+    const dictionary = this.getDictionary(items);
+    this.items.map((item) => {
+      if (dictionary[item.getKey()] === void 0) {
+        diff.add(item);
+      }
+    });
+    return diff;
+  }
+  except(keys) {
+    const dictionary = omit3(this.getDictionary(), keys);
+    return new this.constructor(Object.values(dictionary));
+  }
+  intersect(items) {
+    const intersect = new this.constructor();
+    if (isEmpty(items)) {
+      return intersect;
+    }
+    const dictionary = this.getDictionary(items);
+    for (let item of this.items) {
+      if (dictionary[item.getKey()] !== void 0) {
+        intersect.add(item);
+      }
+    }
+    return intersect;
+  }
+  unique(key = null, strict = false) {
+    if (key !== null) {
+      return super.unique(key, strict);
+    }
+    return new this.constructor(Object.values(this.getDictionary()));
+  }
+  find(key, defaultValue = null) {
+    const Model2 = Model2;
+    if (key instanceof Model2) {
+      key = key.getKey();
+    }
+    if (isArray2(key)) {
+      if (this.isEmpty()) {
+        return new this.constructor();
+      }
+      return this.whereIn(this.first().getKeyName(), key);
+    }
+    collect2(this.items).first((model) => {
+      return model.getKey() == key;
+    });
+    return this.items.filter((model) => {
+      return model.getKey() == key;
+    })[0] || defaultValue;
+  }
+  makeVisible(attributes) {
+    return this.each((item) => {
+      item.makeVisible(attributes);
+    });
+  }
+  makeHidden(attributes) {
+    return this.each((item) => {
+      item.makeHidden(attributes);
+    });
+  }
+  append(attributes) {
+    return this.each((item) => {
+      item.append(attributes);
+    });
+  }
+  only(keys) {
+    if (keys === null) {
+      return new _Collection(this.items);
+    }
+    const dictionary = pick(this.getDictionary(), keys);
+    return new this.constructor(Object.values(dictionary));
+  }
+  getDictionary(items = null) {
+    items = items === null ? this.items : items;
+    const dictionary = {};
+    items.map((value) => {
+      dictionary[value.getKey()] = value;
+    });
+    return dictionary;
+  }
+  toData() {
+    return this.all().map((item) => typeof item.toData == "function" ? item.toData() : item);
+  }
+  toJSON() {
+    return this.toData();
+  }
+  toJson(...args) {
+    return JSON.stringify(this.toData(), ...args);
+  }
+  [Symbol.iterator]() {
+    const items = this.items;
+    let length = this.items.length;
+    let n = 0;
+    return {
+      next() {
+        return n < length ? {
+          value: items[n++],
+          done: false
+        } : {
+          done: true
+        };
+      }
+    };
+  }
+};
+var collection_default = Collection;
+
+// src/concerns/has-unique-ids.js
+var HasUniqueIds = (Model2) => {
+  return class extends Model2 {
+    useUniqueIds = true;
+    uniqueIds() {
+      return [this.getKeyName()];
+    }
+    getKeyType() {
+      if (this.uniqueIds().includes(this.getKeyName())) {
+        return "string";
+      }
+      return this.keyType;
+    }
+    getIncrementing() {
+      if (this.uniqueIds().includes(this.getKeyName())) {
+        return false;
+      }
+      return this.incrementing;
+    }
+  };
+};
+var has_unique_ids_default = HasUniqueIds;
+
+// src/browser/paginator.js
+var Paginator = class {
+  static formatter = null;
+  _items;
+  _total;
+  _perPage;
+  _lastPage;
+  _currentPage;
+  static setFormatter(formatter) {
+    if (typeof formatter !== "function" && formatter !== null && formatter !== void 0) {
+      throw new Error("Paginator formatter must be a function or null");
+    }
+    this.formatter = formatter;
+  }
+  constructor(items, total, perPage, currentPage = null, options = {}) {
+    this.options = options;
+    for (const key in options) {
+      const value = options[key];
+      this[key] = value;
+    }
+    this._total = total;
+    this._perPage = parseInt(perPage);
+    this._lastPage = Math.max(Math.ceil(total / perPage), 1);
+    this._currentPage = currentPage;
+    this.setItems(items);
+  }
+  setItems(items) {
+    this._items = items instanceof collection_default ? items : new collection_default(items);
+    this.hasMore = this._items.count() > this._perPage;
+    this._items = this._items.slice(0, this._perPage);
+  }
+  firstItem() {
+    return this.count() > 0 ? (this._currentPage - 1) * this._perPage + 1 : null;
+  }
+  lastItem() {
+    return this.count() > 0 ? this.firstItem() + this.count() - 1 : null;
+  }
+  hasMorePages() {
+    return this._currentPage < this._lastPage;
+  }
+  get(index) {
+    return this._items.get(index);
+  }
+  count() {
+    return this._items.count();
+  }
+  items() {
+    return this._items;
+  }
+  map(callback) {
+    return this._items.map(callback);
+  }
+  currentPage() {
+    return this._currentPage;
+  }
+  onFirstPage() {
+    return this._currentPage === 1;
+  }
+  perPage() {
+    return this._perPage;
+  }
+  lastPage() {
+    return this._lastPage;
+  }
+  total() {
+    return this._total;
+  }
+  toData() {
+    if (this.constructor.formatter && typeof this.constructor.formatter === "function") {
+      return this.constructor.formatter(this);
+    }
+    return {
+      current_page: this._currentPage,
+      data: this._items.toData(),
+      per_page: this._perPage,
+      total: this._total,
+      last_page: this._lastPage,
+      count: this.count()
+    };
+  }
+  toJSON() {
+    return this.toData();
+  }
+  toJson(...args) {
+    return JSON.stringify(this.toData(), ...args);
+  }
+};
+var paginator_default = Paginator;
+
+// src/browser/pivot.js
+var pivot_default = Pivot;
+
+// src/browser/index.js
+import { isArray as isArray3 } from "radashi";
+var make = (model, data, options = {}) => {
+  const { paginated } = options;
+  if (paginated) {
+    return new paginator_default(data.data.map((item) => model.make(item)), data.total, data.per_page, data.current_page);
+  }
+  if (isArray3(data)) {
+    return new collection_default(data.map((item) => model.make(item)));
+  }
+  return model.make(data);
+};
+var makeCollection = (model, data) => new collection_default(data.map((item) => model.make(item)));
+var makePaginator = (model, data) => new paginator_default(data.data.map((item) => model.make(item)), data.total, data.per_page, data.current_page);
+var isBrowser = true;
+var index_default = {
+  isBrowser,
+  Paginator: paginator_default,
+  Collection: collection_default,
+  Model: model_default,
+  Pivot: pivot_default,
+  Attribute: attribute_default,
+  CastsAttributes: casts_attributes_default,
+  HasUniqueIds: has_unique_ids_default,
+  make,
+  makeCollection,
+  makePaginator
+};
+export {
+  attribute_default as Attribute,
+  casts_attributes_default as CastsAttributes,
+  collection_default as Collection,
+  has_unique_ids_default as HasUniqueIds,
+  InvalidArgumentError,
+  model_default as Model,
+  ModelNotFoundError,
+  paginator_default as Paginator,
+  pivot_default as Pivot,
+  RelationNotFoundError,
+  compose,
+  index_default as default,
+  flattenDeep,
+  getAttrMethod,
+  getAttrName,
+  getGetterMethod,
+  getRelationMethod,
+  getRelationName,
+  getScopeMethod,
+  getScopeName,
+  getSetterMethod,
+  isBrowser,
+  kebabCase,
+  make,
+  makeCollection,
+  makePaginator,
+  now,
+  snakeCase,
+  tap
+};
+//# sourceMappingURL=index.js.map