@pol-studios/utils 1.0.0

package/dist/object/index.d.ts

@@ -0,0 +1 @@
+export { e as deepEquals, d as diff, g as getPath, b as getValueByPath, a as includeOnly, f as isDeepEqual, o as omit, p as pick, s as setPath, c as setValueByPath } from '../index-CZbs1QQN.js';

package/dist/object/index.js

@@ -0,0 +1,115 @@
+// src/object/omit.ts
+function omit(obj, keys) {
+  const keysArray = Array.isArray(keys) ? keys : [keys];
+  const newObj = { ...obj };
+  keysArray.forEach((key) => {
+    if (key in newObj) {
+      delete newObj[key];
+    }
+  });
+  return newObj;
+}
+
+// src/object/pick.ts
+function pick(obj, keys) {
+  const newValue = {};
+  keys.forEach((key) => {
+    if (key in obj) {
+      newValue[key] = obj[key];
+    }
+  });
+  return newValue;
+}
+var includeOnly = pick;
+
+// src/internal/isUsable.ts
+function isUsable(value) {
+  return value !== void 0 && value !== null && (typeof value !== "number" || isNaN(value) === false);
+}
+
+// src/object/diff.ts
+function diff(oldValue, newValue) {
+  if (isUsable(oldValue) === false) {
+    return { ...newValue };
+  }
+  const result = {};
+  function compare(o1, o2, res) {
+    for (const key in o1) {
+      if (o1.hasOwnProperty(key)) {
+        if (typeof o1[key] === "object" && o1[key] !== null && typeof o2[key] === "object" && o2[key] !== null) {
+          const nestedDiff = diff(o1[key], o2[key]);
+          if (Object.keys(nestedDiff).length > 0) {
+            res[key] = nestedDiff;
+          }
+        } else if (o1[key] !== o2[key]) {
+          res[key] = o2[key];
+        }
+      }
+    }
+    for (const key in o2) {
+      if (o2.hasOwnProperty(key) && !o1.hasOwnProperty(key)) {
+        res[key] = o2[key];
+      }
+    }
+  }
+  compare(oldValue, newValue, result);
+  return result;
+}
+
+// src/object/getPath.ts
+function getPath(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current[key] === void 0) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+var getValueByPath = getPath;
+
+// src/object/setPath.ts
+function setPath(obj, path, value) {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current[key] === void 0) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  current[lastKey] = value;
+}
+var setValueByPath = setPath;
+
+// src/object/deepEqual.ts
+function deepEquals(obj1, obj2) {
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    if (obj1[key] !== obj2[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+var isDeepEqual = deepEquals;
+export {
+  deepEquals,
+  diff,
+  getPath,
+  getValueByPath,
+  includeOnly,
+  isDeepEqual,
+  omit,
+  pick,
+  setPath,
+  setValueByPath
+};

package/dist/state/index.d.ts

@@ -0,0 +1 @@
+export { g as getObjectChanges, w as withUpdate } from '../index-C8CxeaqZ.js';

package/dist/state/index.js

@@ -0,0 +1,17 @@
+// src/state/index.ts
+function withUpdate(item, updates) {
+  return { ...item, ...updates };
+}
+function getObjectChanges(oldObj, newObj) {
+  const changes = {};
+  for (const key of Object.keys(newObj)) {
+    if (newObj[key] !== oldObj[key]) {
+      changes[key] = newObj[key];
+    }
+  }
+  return changes;
+}
+export {
+  getObjectChanges,
+  withUpdate
+};

package/dist/string/index.d.ts

@@ -0,0 +1 @@
+export { c as camelize, g as generateSlug, d as isBlank, e as isNullOrWhitespace, p as pascalize, a as pascalizeWithSpaces, b as sanitizeInput, s as slugify } from '../index-D_IvPWYI.js';

package/dist/string/index.js

@@ -0,0 +1,55 @@
+// src/string/camelize.ts
+function camelize(str) {
+  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) {
+    return index === 0 ? word.toLowerCase() : word.toUpperCase();
+  }).replace(/\s+/g, "");
+}
+
+// src/internal/isUsable.ts
+function isUsable(value) {
+  return value !== void 0 && value !== null && (typeof value !== "number" || isNaN(value) === false);
+}
+
+// src/string/pascalize.ts
+function pascalize(str) {
+  return str.replace(/(\w)(\w*)/g, function(g0, g1, g2) {
+    return g1.toUpperCase() + g2.toLowerCase();
+  });
+}
+function pascalizeWithSpaces(input) {
+  if (isUsable(input) === false) return input;
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+}
+
+// src/string/slugify.ts
+function slugify(text) {
+  return text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+var generateSlug = slugify;
+
+// src/string/sanitize.ts
+function sanitizeInput(value) {
+  return value.replace(/"/g, '""').replace(/'/g, "''");
+}
+
+// src/string/isBlank.ts
+function isBlank(value) {
+  if (value === null || value === void 0) {
+    return true;
+  }
+  if (typeof value === "string" && value.trim().length === 0) {
+    return true;
+  }
+  return false;
+}
+var isNullOrWhitespace = isBlank;
+export {
+  camelize,
+  generateSlug,
+  isBlank,
+  isNullOrWhitespace,
+  pascalize,
+  pascalizeWithSpaces,
+  sanitizeInput,
+  slugify
+};

package/dist/tailwind/index.d.ts

@@ -0,0 +1,2 @@
+export { ClassValue } from 'clsx';
+export { c as cn } from '../index-BSNY-QEc.js';

package/dist/tailwind/index.js

@@ -0,0 +1,9 @@
+// src/tailwind/index.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+export {
+  cn
+};

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { d as EntityAccessRecord, b as EntityAction, c as EntityPermissionCheck, a as EntityPermissionLevel, E as EntityType, I as ItemType, K as KeyOfStringOrNumber, P as PermissionEffect, S as StorageObjectMetadata, g as getContentType, e as isImageType, h as isPdfType, j as isRenderableType, k as isUsable, f as isVideoType } from '../index-BaA8cg0E.js';

package/dist/types/index.js

@@ -0,0 +1,37 @@
+// src/types/guards.ts
+function isUsable(value) {
+  return value !== void 0 && value !== null && (typeof value !== "number" || isNaN(value) === false);
+}
+
+// src/types/StorageObjectMetadata.ts
+function getContentType(metadata, path) {
+  if (metadata?.contentType) {
+    return metadata.contentType;
+  }
+  const ext = path.split(".").pop()?.toUpperCase();
+  return ext || "Unknown";
+}
+function isImageType(contentType) {
+  return ["JPEG", "JPG", "PNG", "GIF", "WEBP", "SVG", "HEIC", "HEIF"].includes(
+    contentType.toUpperCase()
+  );
+}
+function isVideoType(contentType) {
+  return ["MP4", "QUICKTIME", "MOV", "WEBM", "AVI", "MKV"].includes(
+    contentType.toUpperCase()
+  );
+}
+function isPdfType(contentType) {
+  return contentType.toUpperCase() === "PDF";
+}
+function isRenderableType(contentType) {
+  return isImageType(contentType) || isVideoType(contentType) || isPdfType(contentType);
+}
+export {
+  getContentType,
+  isImageType,
+  isPdfType,
+  isRenderableType,
+  isUsable,
+  isVideoType
+};

package/dist/uuid/index.d.ts

@@ -0,0 +1 @@
+export { n as newUuid } from '../index-Btn_GVfm.js';

package/dist/uuid/index.js

@@ -0,0 +1,10 @@
+// src/uuid/index.ts
+function newUuid() {
+  return "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".replace(/[x]/g, () => {
+    const r = Math.random() * 16 | 0;
+    return r.toString(16);
+  });
+}
+export {
+  newUuid
+};

package/dist/validation/index.d.ts

@@ -0,0 +1 @@
+export { P as PasswordStrength, g as PasswordStrengthResult, a as ValidationResult, V as ValidationRule, h as calculatePasswordStrength, b as validateEmail, e as validateMaxLength, d as validateMinLength, f as validatePattern, c as validateRequired, v as validateValue } from '../index-BxUoIlv_.js';

package/dist/validation/index.js

@@ -0,0 +1,123 @@
+// src/validation/validators.ts
+function validateValue(value, rules) {
+  for (const rule of rules) {
+    if (!rule.validate(value)) {
+      return { isValid: false, error: rule.message };
+    }
+  }
+  return { isValid: true };
+}
+function validateEmail(email) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!email || email.trim().length === 0) {
+    return { isValid: false, error: "Email is required" };
+  }
+  if (!emailRegex.test(email)) {
+    return { isValid: false, error: "Please enter a valid email address" };
+  }
+  return { isValid: true };
+}
+function validateRequired(value) {
+  if (value === null || value === void 0 || value === "") {
+    return { isValid: false, error: "This field is required" };
+  }
+  if (typeof value === "string" && value.trim().length === 0) {
+    return { isValid: false, error: "This field is required" };
+  }
+  return { isValid: true };
+}
+function validateMinLength(min) {
+  return (value) => {
+    if (!value || value.length < min) {
+      return {
+        isValid: false,
+        error: `Must be at least ${min} characters`
+      };
+    }
+    return { isValid: true };
+  };
+}
+function validateMaxLength(max) {
+  return (value) => {
+    if (value && value.length > max) {
+      return {
+        isValid: false,
+        error: `Must be no more than ${max} characters`
+      };
+    }
+    return { isValid: true };
+  };
+}
+function validatePattern(pattern, message) {
+  return (value) => {
+    if (value && !pattern.test(value)) {
+      return { isValid: false, error: message };
+    }
+    return { isValid: true };
+  };
+}
+
+// src/validation/password.ts
+function calculatePasswordStrength(password) {
+  if (!password || password.length === 0) {
+    return {
+      strength: "weak",
+      score: 0,
+      feedback: []
+    };
+  }
+  let score = 0;
+  const feedback = [];
+  if (password.length >= 8) {
+    score += 1;
+  } else {
+    feedback.push("Use at least 8 characters");
+  }
+  if (password.length >= 12) {
+    score += 1;
+  }
+  if (/[a-z]/.test(password)) {
+    score += 1;
+  } else {
+    feedback.push("Add lowercase letters");
+  }
+  if (/[A-Z]/.test(password)) {
+    score += 1;
+  } else {
+    feedback.push("Add uppercase letters");
+  }
+  if (/[0-9]/.test(password)) {
+    score += 1;
+  } else {
+    feedback.push("Add numbers");
+  }
+  if (/[^a-zA-Z0-9]/.test(password)) {
+    score += 1;
+  } else {
+    feedback.push("Add special characters");
+  }
+  let strength;
+  if (score <= 2) {
+    strength = "weak";
+  } else if (score <= 3) {
+    strength = "fair";
+  } else if (score <= 4) {
+    strength = "good";
+  } else {
+    strength = "strong";
+  }
+  return {
+    strength,
+    score,
+    feedback: feedback.length > 0 ? feedback : []
+  };
+}
+export {
+  calculatePasswordStrength,
+  validateEmail,
+  validateMaxLength,
+  validateMinLength,
+  validatePattern,
+  validateRequired,
+  validateValue
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@pol-studios/utils",
+  "version": "1.0.0",
+  "description": "Utility functions for POL applications",
+  "license": "UNLICENSED",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "keywords": ["utils", "utilities", "helpers"],
+  "exports": {
+    ".": { "import": "./dist/index.js", "types": "./dist/index.d.ts" },
+    "./string": { "import": "./dist/string/index.js", "types": "./dist/string/index.d.ts" },
+    "./array": { "import": "./dist/array/index.js", "types": "./dist/array/index.d.ts" },
+    "./object": { "import": "./dist/object/index.js", "types": "./dist/object/index.d.ts" },
+    "./date": { "import": "./dist/date/index.js", "types": "./dist/date/index.d.ts" },
+    "./async": { "import": "./dist/async/index.js", "types": "./dist/async/index.d.ts" },
+    "./format": { "import": "./dist/format/index.js", "types": "./dist/format/index.d.ts" },
+    "./tailwind": { "import": "./dist/tailwind/index.js", "types": "./dist/tailwind/index.d.ts" },
+    "./cache": { "import": "./dist/cache/index.js", "types": "./dist/cache/index.d.ts" },
+    "./types": { "import": "./dist/types/index.js", "types": "./dist/types/index.d.ts" },
+    "./color": { "import": "./dist/color/index.js", "types": "./dist/color/index.d.ts" },
+    "./validation": { "import": "./dist/validation/index.js", "types": "./dist/validation/index.d.ts" },
+    "./error": { "import": "./dist/error/index.js", "types": "./dist/error/index.d.ts" },
+    "./device": { "import": "./dist/device/index.js", "types": "./dist/device/index.d.ts" },
+    "./uuid": { "import": "./dist/uuid/index.js", "types": "./dist/uuid/index.d.ts" },
+    "./state": { "import": "./dist/state/index.js", "types": "./dist/state/index.d.ts" },
+    "./enum": { "import": "./dist/enum/index.js", "types": "./dist/enum/index.d.ts" },
+    "./dev": { "import": "./dist/dev/index.js", "types": "./dist/dev/index.d.ts" }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "pnpm build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "clsx": "^2.0.0",
+    "tailwind-merge": "^2.0.0"
+  },
+  "peerDependencies": {
+    "moment": "^2.29.4"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}