openloops 0.1.8 → 0.1.10

package/dist/common/core/base.entity.js

@@ -0,0 +1,208 @@
+"use strict";
+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 __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var base_entity_exports = {};
+__export(base_entity_exports, {
+  BaseEntity: () => BaseEntity
+});
+module.exports = __toCommonJS(base_entity_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_bson = require("bson");
+var import_decorators = require("@common/decorators");
+var import_helpers = require("@common/helpers");
+var import_utils = require("./utils");
+const _BaseEntity = class _BaseEntity {
+  _id;
+  __v;
+  ownerId;
+  createdAt;
+  createdBy;
+  updatedAt;
+  updatedBy;
+  deletedAt;
+  deletedBy;
+  deletedReason;
+  archivedAt;
+  archivedBy;
+  sharedWith;
+  toUnset;
+  static toObjectId(id) {
+    if (!id) return void 0;
+    if (id instanceof import_bson.ObjectId) return id;
+    if (!import_bson.ObjectId.isValid(id)) throw new Error(`Invalid ObjectId: ${id}`);
+    return new import_bson.ObjectId(id);
+  }
+  static toDate(value) {
+    if (!value) return void 0;
+    const date = new Date(value);
+    if (isNaN(date.getTime())) throw new Error("{{value_must_be_a_date}}");
+    return date;
+  }
+  static toNumber(value) {
+    if (value === void 0 || value === null) return void 0;
+    if (typeof value !== "number") throw new Error("{{value_must_be_a_number}}");
+    return value;
+  }
+  static clean(json) {
+    return (0, import_utils.deleteEmptyFields)(json);
+  }
+  constructor(props) {
+    this._id = _BaseEntity.toObjectId(props._id);
+    this.__v = _BaseEntity.toNumber(props.__v);
+    this.ownerId = _BaseEntity.toObjectId(props.ownerId);
+    this.createdAt = _BaseEntity.toDate(props.createdAt);
+    this.createdBy = _BaseEntity.toObjectId(props.createdBy);
+    this.updatedAt = _BaseEntity.toDate(props.updatedAt);
+    this.updatedBy = _BaseEntity.toObjectId(props.updatedBy);
+    this.deletedAt = _BaseEntity.toDate(props.deletedAt);
+    this.deletedBy = _BaseEntity.toObjectId(props.deletedBy);
+    this.deletedReason = (0, import_helpers.sanitizeString)(props.deletedReason);
+    this.archivedAt = _BaseEntity.toDate(props.archivedAt);
+    this.archivedBy = _BaseEntity.toObjectId(props.archivedBy);
+    this.sharedWith = props.sharedWith?.length ? props.sharedWith.map((id) => _BaseEntity.toObjectId(id)) : void 0;
+  }
+  toJSON() {
+    return {
+      _id: this._id,
+      __v: this.__v,
+      ownerId: this.ownerId,
+      createdAt: this.createdAt,
+      createdBy: this.createdBy,
+      updatedAt: this.updatedAt,
+      updatedBy: this.updatedBy,
+      deletedAt: this.deletedAt,
+      deletedBy: this.deletedBy,
+      deletedReason: this.deletedReason,
+      archivedAt: this.archivedAt,
+      archivedBy: this.archivedBy,
+      sharedWith: this.sharedWith?.length ? this.sharedWith.map((id) => id.toHexString()) : void 0,
+      toUnset: this.toUnset
+    };
+  }
+  setDefaults() {
+  }
+  setId(id) {
+    this._id = _BaseEntity.toObjectId(id);
+  }
+  setOwner(currentUser) {
+    if (!currentUser) return;
+    this.ownerId = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  setCreatedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.createdAt = /* @__PURE__ */ new Date();
+    this.createdBy = _BaseEntity.toObjectId(currentUser.userId);
+    this.setDefaults();
+  }
+  setUpdatedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.updatedAt = /* @__PURE__ */ new Date();
+    this.updatedBy = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  setDeletedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.deletedAt = /* @__PURE__ */ new Date();
+    this.deletedBy = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  setArchivedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.archivedAt = /* @__PURE__ */ new Date();
+    this.archivedBy = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  toDocument() {
+    return (0, import_utils.deleteEmptyFields)(this.toJSON());
+  }
+  toFlatDocument() {
+    const { toUnset, ...doc } = this.toDocument();
+    return { ...(0, import_utils.flattenObject)(doc), toUnset };
+  }
+  stringify() {
+    return JSON.stringify((0, import_decorators.handleMaskInLogs)(this), null, 2);
+  }
+  unset(fields) {
+    const toUnset = Array.from(new Set(fields.map((field) => String(field))));
+    if (!toUnset || !Array.isArray(toUnset)) return {};
+    this.toUnset = toUnset.reduce((acc, field) => {
+      acc[field] = "";
+      return acc;
+    }, {});
+    fields.forEach((field) => {
+      delete this[field];
+    });
+  }
+  sanitize(currentUser) {
+    if (!currentUser?.isAdmin()) {
+      for (const key in this) {
+        const isAdminOnly = Reflect.getMetadata("adminOnly", this.constructor.prototype, key);
+        if (isAdminOnly) {
+          delete this[key];
+        }
+      }
+    }
+  }
+};
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "__v", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "ownerId", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "createdAt", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "createdBy", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "updatedAt", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "updatedBy", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "deletedAt", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "deletedBy", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "archivedAt", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "archivedBy", 2);
+__decorateClass([
+  import_decorators.OwnerOnly
+], _BaseEntity.prototype, "sharedWith", 2);
+let BaseEntity = _BaseEntity;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseEntity
+});

package/dist/common/core/base.entity.mjs

@@ -0,0 +1,179 @@
+import {
+  __decorateClass
+} from "../../chunk-XRJFNASX.mjs";
+import "reflect-metadata";
+import { ObjectId } from "bson";
+import { AdminOnly, OwnerOnly, handleMaskInLogs } from "@common/decorators";
+import { sanitizeString } from "@common/helpers";
+import { deleteEmptyFields, flattenObject } from "./utils";
+const _BaseEntity = class _BaseEntity {
+  _id;
+  __v;
+  ownerId;
+  createdAt;
+  createdBy;
+  updatedAt;
+  updatedBy;
+  deletedAt;
+  deletedBy;
+  deletedReason;
+  archivedAt;
+  archivedBy;
+  sharedWith;
+  toUnset;
+  static toObjectId(id) {
+    if (!id) return void 0;
+    if (id instanceof ObjectId) return id;
+    if (!ObjectId.isValid(id)) throw new Error(`Invalid ObjectId: ${id}`);
+    return new ObjectId(id);
+  }
+  static toDate(value) {
+    if (!value) return void 0;
+    const date = new Date(value);
+    if (isNaN(date.getTime())) throw new Error("{{value_must_be_a_date}}");
+    return date;
+  }
+  static toNumber(value) {
+    if (value === void 0 || value === null) return void 0;
+    if (typeof value !== "number") throw new Error("{{value_must_be_a_number}}");
+    return value;
+  }
+  static clean(json) {
+    return deleteEmptyFields(json);
+  }
+  constructor(props) {
+    this._id = _BaseEntity.toObjectId(props._id);
+    this.__v = _BaseEntity.toNumber(props.__v);
+    this.ownerId = _BaseEntity.toObjectId(props.ownerId);
+    this.createdAt = _BaseEntity.toDate(props.createdAt);
+    this.createdBy = _BaseEntity.toObjectId(props.createdBy);
+    this.updatedAt = _BaseEntity.toDate(props.updatedAt);
+    this.updatedBy = _BaseEntity.toObjectId(props.updatedBy);
+    this.deletedAt = _BaseEntity.toDate(props.deletedAt);
+    this.deletedBy = _BaseEntity.toObjectId(props.deletedBy);
+    this.deletedReason = sanitizeString(props.deletedReason);
+    this.archivedAt = _BaseEntity.toDate(props.archivedAt);
+    this.archivedBy = _BaseEntity.toObjectId(props.archivedBy);
+    this.sharedWith = props.sharedWith?.length ? props.sharedWith.map((id) => _BaseEntity.toObjectId(id)) : void 0;
+  }
+  toJSON() {
+    return {
+      _id: this._id,
+      __v: this.__v,
+      ownerId: this.ownerId,
+      createdAt: this.createdAt,
+      createdBy: this.createdBy,
+      updatedAt: this.updatedAt,
+      updatedBy: this.updatedBy,
+      deletedAt: this.deletedAt,
+      deletedBy: this.deletedBy,
+      deletedReason: this.deletedReason,
+      archivedAt: this.archivedAt,
+      archivedBy: this.archivedBy,
+      sharedWith: this.sharedWith?.length ? this.sharedWith.map((id) => id.toHexString()) : void 0,
+      toUnset: this.toUnset
+    };
+  }
+  setDefaults() {
+  }
+  setId(id) {
+    this._id = _BaseEntity.toObjectId(id);
+  }
+  setOwner(currentUser) {
+    if (!currentUser) return;
+    this.ownerId = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  setCreatedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.createdAt = /* @__PURE__ */ new Date();
+    this.createdBy = _BaseEntity.toObjectId(currentUser.userId);
+    this.setDefaults();
+  }
+  setUpdatedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.updatedAt = /* @__PURE__ */ new Date();
+    this.updatedBy = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  setDeletedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.deletedAt = /* @__PURE__ */ new Date();
+    this.deletedBy = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  setArchivedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.archivedAt = /* @__PURE__ */ new Date();
+    this.archivedBy = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  toDocument() {
+    return deleteEmptyFields(this.toJSON());
+  }
+  toFlatDocument() {
+    const { toUnset, ...doc } = this.toDocument();
+    return { ...flattenObject(doc), toUnset };
+  }
+  stringify() {
+    return JSON.stringify(handleMaskInLogs(this), null, 2);
+  }
+  unset(fields) {
+    const toUnset = Array.from(new Set(fields.map((field) => String(field))));
+    if (!toUnset || !Array.isArray(toUnset)) return {};
+    this.toUnset = toUnset.reduce((acc, field) => {
+      acc[field] = "";
+      return acc;
+    }, {});
+    fields.forEach((field) => {
+      delete this[field];
+    });
+  }
+  sanitize(currentUser) {
+    if (!currentUser?.isAdmin()) {
+      for (const key in this) {
+        const isAdminOnly = Reflect.getMetadata("adminOnly", this.constructor.prototype, key);
+        if (isAdminOnly) {
+          delete this[key];
+        }
+      }
+    }
+  }
+};
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "__v", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "ownerId", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "createdAt", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "createdBy", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "updatedAt", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "updatedBy", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "deletedAt", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "deletedBy", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "archivedAt", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "archivedBy", 2);
+__decorateClass([
+  OwnerOnly
+], _BaseEntity.prototype, "sharedWith", 2);
+let BaseEntity = _BaseEntity;
+export {
+  BaseEntity
+};

package/dist/common/core/base.use-case.js

@@ -0,0 +1,30 @@
+"use strict";
+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 base_use_case_exports = {};
+__export(base_use_case_exports, {
+  BaseUseCase: () => BaseUseCase
+});
+module.exports = __toCommonJS(base_use_case_exports);
+var import_base = require("./base.app");
+class BaseUseCase extends import_base.BaseApp {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseUseCase
+});

package/dist/common/core/base.use-case.mjs

@@ -0,0 +1,7 @@
+import "../../chunk-XRJFNASX.mjs";
+import { BaseApp } from "./base.app";
+class BaseUseCase extends BaseApp {
+}
+export {
+  BaseUseCase
+};

package/dist/common/core/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/common/core/utils/delete-empty-fields.js

@@ -0,0 +1,66 @@
+"use strict";
+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 delete_empty_fields_exports = {};
+__export(delete_empty_fields_exports, {
+  deleteEmptyFields: () => deleteEmptyFields
+});
+module.exports = __toCommonJS(delete_empty_fields_exports);
+var import_is_plain_object = require("./is-plain-object");
+function safeClone(value) {
+  if (Array.isArray(value)) {
+    return value.map(safeClone);
+  }
+  if ((0, import_is_plain_object.isPlainObject)(value)) {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = safeClone(value[key]);
+    }
+    return result;
+  }
+  return value;
+}
+function deleteEmptyFields(object) {
+  const cleanObject = (obj) => {
+    if (Array.isArray(obj)) {
+      obj.forEach(cleanObject);
+      return;
+    }
+    if (!(0, import_is_plain_object.isPlainObject)(obj)) return;
+    Object.keys(obj).forEach((key) => {
+      const value = obj[key];
+      if (Array.isArray(value)) {
+        cleanObject(value);
+      } else if ((0, import_is_plain_object.isPlainObject)(value)) {
+        cleanObject(value);
+        if (Object.keys(value).length === 0) {
+          delete obj[key];
+        }
+      } else if (value === void 0 || value === null) {
+        delete obj[key];
+      }
+    });
+  };
+  const clonedObject = safeClone(object);
+  cleanObject(clonedObject);
+  return clonedObject;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteEmptyFields
+});

package/dist/common/core/utils/delete-empty-fields.mjs

@@ -0,0 +1,43 @@
+import "../../../chunk-XRJFNASX.mjs";
+import { isPlainObject } from "./is-plain-object";
+function safeClone(value) {
+  if (Array.isArray(value)) {
+    return value.map(safeClone);
+  }
+  if (isPlainObject(value)) {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = safeClone(value[key]);
+    }
+    return result;
+  }
+  return value;
+}
+function deleteEmptyFields(object) {
+  const cleanObject = (obj) => {
+    if (Array.isArray(obj)) {
+      obj.forEach(cleanObject);
+      return;
+    }
+    if (!isPlainObject(obj)) return;
+    Object.keys(obj).forEach((key) => {
+      const value = obj[key];
+      if (Array.isArray(value)) {
+        cleanObject(value);
+      } else if (isPlainObject(value)) {
+        cleanObject(value);
+        if (Object.keys(value).length === 0) {
+          delete obj[key];
+        }
+      } else if (value === void 0 || value === null) {
+        delete obj[key];
+      }
+    });
+  };
+  const clonedObject = safeClone(object);
+  cleanObject(clonedObject);
+  return clonedObject;
+}
+export {
+  deleteEmptyFields
+};

package/dist/common/core/utils/flatten-object.js

@@ -0,0 +1,45 @@
+"use strict";
+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 flatten_object_exports = {};
+__export(flatten_object_exports, {
+  flattenObject: () => flattenObject
+});
+module.exports = __toCommonJS(flatten_object_exports);
+var import_is_plain_object = require("./is-plain-object");
+function flattenObject(obj, parentKey = "", result = {}) {
+  if (!(0, import_is_plain_object.isPlainObject)(obj)) {
+    return {};
+  }
+  for (let key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const newKey = parentKey ? `${parentKey}.${key}` : key;
+      const value = obj[key];
+      if ((0, import_is_plain_object.isPlainObject)(value)) {
+        flattenObject(value, newKey, result);
+      } else {
+        result[newKey] = value;
+      }
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flattenObject
+});

package/dist/common/core/utils/flatten-object.mjs

@@ -0,0 +1,22 @@
+import "../../../chunk-XRJFNASX.mjs";
+import { isPlainObject } from "./is-plain-object";
+function flattenObject(obj, parentKey = "", result = {}) {
+  if (!isPlainObject(obj)) {
+    return {};
+  }
+  for (let key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const newKey = parentKey ? `${parentKey}.${key}` : key;
+      const value = obj[key];
+      if (isPlainObject(value)) {
+        flattenObject(value, newKey, result);
+      } else {
+        result[newKey] = value;
+      }
+    }
+  }
+  return result;
+}
+export {
+  flattenObject
+};

package/dist/common/core/utils/index.js

@@ -0,0 +1,26 @@
+"use strict";
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./delete-empty-fields"), module.exports);
+__reExport(utils_exports, require("./is-plain-object"), module.exports);
+__reExport(utils_exports, require("./flatten-object"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./delete-empty-fields"),
+  ...require("./is-plain-object"),
+  ...require("./flatten-object")
+});

package/dist/common/core/utils/index.mjs

@@ -0,0 +1,3 @@
+export * from "./delete-empty-fields";
+export * from "./is-plain-object";
+export * from "./flatten-object";

package/dist/common/core/utils/is-plain-object.js

@@ -0,0 +1,32 @@
+"use strict";
+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 is_plain_object_exports = {};
+__export(is_plain_object_exports, {
+  isPlainObject: () => isPlainObject
+});
+module.exports = __toCommonJS(is_plain_object_exports);
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPlainObject
+});

package/dist/common/core/utils/is-plain-object.mjs

@@ -0,0 +1,9 @@
+import "../../../chunk-XRJFNASX.mjs";
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+export {
+  isPlainObject
+};