@fluixi/utils 1.0.0-alpha.83 → 1.0.0-alpha.85

package/dist/lib/object/sort.mjs

@@ -1 +1,186 @@
-function b(e){if(typeof e!="object"||e===null)return!1;let n=Object.getPrototypeOf(e);return n===Object.prototype||n===null}function S(e,n){if(e==null)return;let t=e;for(let r of n.split(".")){if(t==null)return;t=t[r]}return t}function A(e,n,t,r){let s=e==null,o=n==null;if(s&&o)return 0;if(s)return 1;if(o)return-1;let u=typeof e=="number"&&Number.isNaN(e),i=typeof n=="number"&&Number.isNaN(n);return u&&i?0:u?1:i?-1:e instanceof Date&&n instanceof Date?e.getTime()-n.getTime():typeof e=="boolean"&&typeof n=="boolean"?e===n?0:e?1:-1:typeof e=="number"&&typeof n=="number"?e-n:typeof e=="string"&&typeof n=="string"?e.localeCompare(n,t,r):String(e).localeCompare(String(n),t,r)}function y(e,n){return(Array.isArray(e)?e[n]??"asc":e??"asc")==="desc"?-1:1}function x(e,n){let{order:t,locale:r,localeOptions:s,nullsLast:o=!0}=n,u=y(t,0);return e.slice().sort((i,c)=>{let l=i==null,a=c==null;return l&&a?0:l?o?1:-1:a?o?-1:1:A(i,c,r,s)*u})}function h(e,n,t){let{order:r,locale:s,localeOptions:o,nullsLast:u=!0,comparator:i}=t;return i?e.slice().sort(i):e.slice().sort((c,l)=>{for(let a=0;a<n.length;a++){let d=S(c,n[a]),f=S(l,n[a]),p=d==null,m=f==null;if(p&&m)continue;if(p)return u?1:-1;if(m)return u?-1:1;let O=A(d,f,s,o);if(O!==0)return O*y(r,a)}return 0})}function R(e,n){let{order:t,priorityKeys:r=[],locale:s,localeOptions:o,deep:u}=n,i=y(t,0),c=new Set(r),l=Object.keys(e).filter(f=>!c.has(f));l.sort((f,p)=>f.localeCompare(p,s,o)*i);let a=[...r.filter(f=>f in e),...l],d={};for(let f of a)d[f]=u?T(e[f],n):e[f];return d}function T(e,n){if(Array.isArray(e)){let t=e.map(r=>T(r,n));return j(t,n)}return b(e)?R(e,n):e}function w(e,n){let t=e.length,r=new Set,s=[];for(let o of n)o>=0&&o<t&&!r.has(o)&&(s.push(e[o]),r.add(o));for(let o=0;o<t;o++)r.has(o)||s.push(e[o]);return s}function j(e,n){let{by:t,comparator:r,indices:s,order:o}=n;if(s){let i=w(e,s);return y(o,0)===-1?i.reverse():i}if(r)return e.slice().sort(r);if(t){let i=Array.isArray(t)?t:[t];return h(e,i,n)}let u=e.find(i=>i!=null);return u!=null&&b(u)?y(o,0)===-1?e.slice().reverse():e.slice():x(e,n)}function g(e,n={}){let{deep:t}=n;if(Array.isArray(e)){let r=t?e.map(s=>T(s,n)):e;return j(r,n)}return b(e)?R(e,n):e}function $(e,n,t="asc",r={}){return g(e,{...r,by:n,order:t})}function C(e,n={}){return g(e,n)}function F(e,n,t){let r=e.length;if(r===0)return e.slice();let s=Math.max(0,Math.min(r-1,n)),o=Math.max(0,Math.min(r-1,t));if(s===o)return e.slice();let u=e.slice(),[i]=u.splice(s,1);return u.splice(o,0,i),u}function E(e,n,t){let r=e.length;if(n<0||n>=r)throw new RangeError(`swap: index ${n} out of range`);if(t<0||t>=r)throw new RangeError(`swap: index ${t} out of range`);if(n===t)return e.slice();let s=e.slice();return s[n]=e[t],s[t]=e[n],s}function P(e,n,t="asc"){return g(e,{indices:n,order:t})}export{F as move,P as reorder,g as sort,$ as sortBy,C as sortKeys,E as swap};
+// src/lib/object/utils.ts
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+
+// src/lib/object/sort.ts
+function getAtPath(obj, path) {
+  if (obj == null) return void 0;
+  let cur = obj;
+  for (const segment of path.split(".")) {
+    if (cur == null) return void 0;
+    cur = cur[segment];
+  }
+  return cur;
+}
+function compareValues(a, b, locale, localeOptions) {
+  const aN = a == null;
+  const bN = b == null;
+  if (aN && bN) return 0;
+  if (aN) return 1;
+  if (bN) return -1;
+  const aNaN = typeof a === "number" && Number.isNaN(a);
+  const bNaN = typeof b === "number" && Number.isNaN(b);
+  if (aNaN && bNaN) return 0;
+  if (aNaN) return 1;
+  if (bNaN) return -1;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() - b.getTime();
+  }
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return a === b ? 0 : a ? 1 : -1;
+  }
+  if (typeof a === "number" && typeof b === "number") {
+    return a - b;
+  }
+  if (typeof a === "string" && typeof b === "string") {
+    return a.localeCompare(b, locale, localeOptions);
+  }
+  return String(a).localeCompare(String(b), locale, localeOptions);
+}
+function dirFor(order, i) {
+  const o = Array.isArray(order) ? order[i] ?? "asc" : order ?? "asc";
+  return o === "desc" ? -1 : 1;
+}
+function sortPrimitiveArray(arr, options) {
+  const { order, locale, localeOptions, nullsLast = true } = options;
+  const dir = dirFor(order, 0);
+  return arr.slice().sort((a, b) => {
+    const aN = a == null;
+    const bN = b == null;
+    if (aN && bN) return 0;
+    if (aN) return nullsLast ? 1 : -1;
+    if (bN) return nullsLast ? -1 : 1;
+    return compareValues(a, b, locale, localeOptions) * dir;
+  });
+}
+function sortObjectArray(arr, keys, options) {
+  const { order, locale, localeOptions, nullsLast = true, comparator } = options;
+  if (comparator) {
+    return arr.slice().sort(comparator);
+  }
+  return arr.slice().sort((a, b) => {
+    for (let i = 0; i < keys.length; i++) {
+      const aVal = getAtPath(a, keys[i]);
+      const bVal = getAtPath(b, keys[i]);
+      const aN = aVal == null;
+      const bN = bVal == null;
+      if (aN && bN) continue;
+      if (aN) return nullsLast ? 1 : -1;
+      if (bN) return nullsLast ? -1 : 1;
+      const cmp = compareValues(aVal, bVal, locale, localeOptions);
+      if (cmp !== 0) return cmp * dirFor(order, i);
+    }
+    return 0;
+  });
+}
+function sortRecord(record, options) {
+  const { order, priorityKeys = [], locale, localeOptions, deep } = options;
+  const dir = dirFor(order, 0);
+  const prioritySet = new Set(priorityKeys);
+  const rest = Object.keys(record).filter((k) => !prioritySet.has(k));
+  rest.sort(
+    (a, b) => a.localeCompare(b, locale, localeOptions) * dir
+  );
+  const ordered = [...priorityKeys.filter((k) => k in record), ...rest];
+  const result = {};
+  for (const key of ordered) {
+    result[key] = deep ? sortDeep(record[key], options) : record[key];
+  }
+  return result;
+}
+function sortDeep(value, options) {
+  if (Array.isArray(value)) {
+    const deepSorted = value.map((item) => sortDeep(item, options));
+    return sortArrayValue(deepSorted, options);
+  }
+  if (isPlainObject(value)) {
+    return sortRecord(value, options);
+  }
+  return value;
+}
+function applyIndices(arr, indices) {
+  const len = arr.length;
+  const used = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const idx of indices) {
+    if (idx >= 0 && idx < len && !used.has(idx)) {
+      result.push(arr[idx]);
+      used.add(idx);
+    }
+  }
+  for (let i = 0; i < len; i++) {
+    if (!used.has(i)) result.push(arr[i]);
+  }
+  return result;
+}
+function sortArrayValue(arr, options) {
+  const { by, comparator, indices, order } = options;
+  if (indices) {
+    const permuted = applyIndices(arr, indices);
+    return dirFor(order, 0) === -1 ? permuted.reverse() : permuted;
+  }
+  if (comparator) {
+    return arr.slice().sort(comparator);
+  }
+  if (by) {
+    const keys = Array.isArray(by) ? by : [by];
+    return sortObjectArray(arr, keys, options);
+  }
+  const firstReal = arr.find((x) => x != null);
+  if (firstReal != null && isPlainObject(firstReal)) {
+    return dirFor(order, 0) === -1 ? arr.slice().reverse() : arr.slice();
+  }
+  return sortPrimitiveArray(arr, options);
+}
+function sort(input, options = {}) {
+  const { deep } = options;
+  if (Array.isArray(input)) {
+    const items = deep ? input.map((item) => sortDeep(item, options)) : input;
+    return sortArrayValue(items, options);
+  }
+  if (isPlainObject(input)) {
+    return sortRecord(input, options);
+  }
+  return input;
+}
+function sortBy(arr, by, order = "asc", options = {}) {
+  return sort(arr, { ...options, by, order });
+}
+function sortKeys(record, options = {}) {
+  return sort(record, options);
+}
+function move(arr, from, to) {
+  const len = arr.length;
+  if (len === 0) return arr.slice();
+  const f = Math.max(0, Math.min(len - 1, from));
+  const t = Math.max(0, Math.min(len - 1, to));
+  if (f === t) return arr.slice();
+  const result = arr.slice();
+  const [item] = result.splice(f, 1);
+  result.splice(t, 0, item);
+  return result;
+}
+function swap(arr, i, j) {
+  const len = arr.length;
+  if (i < 0 || i >= len) throw new RangeError(`swap: index ${i} out of range`);
+  if (j < 0 || j >= len) throw new RangeError(`swap: index ${j} out of range`);
+  if (i === j) return arr.slice();
+  const result = arr.slice();
+  result[i] = arr[j];
+  result[j] = arr[i];
+  return result;
+}
+function reorder(arr, indices, order = "asc") {
+  return sort(arr, { indices, order });
+}
+export {
+  move,
+  reorder,
+  sort,
+  sortBy,
+  sortKeys,
+  swap
+};