@alibarbar/common 1.0.9 → 1.1.0

package/dist/data-structure.js

@@ -1,33 +1,482 @@
-'use strict';
+// src/data/data-structure/index.ts
+var Stack = class {
+  constructor() {
+    this.items = [];
+  }
+  /**
+   * 入栈
+   */
+  push(item) {
+    this.items.push(item);
+  }
+  /**
+   * 出栈
+   */
+  pop() {
+    return this.items.pop();
+  }
+  /**
+   * 查看栈顶元素
+   */
+  peek() {
+    return this.items[this.items.length - 1];
+  }
+  /**
+   * 判断栈是否为空
+   */
+  isEmpty() {
+    return this.items.length === 0;
+  }
+  /**
+   * 获取栈的大小
+   */
+  size() {
+    return this.items.length;
+  }
+  /**
+   * 清空栈
+   */
+  clear() {
+    this.items = [];
+  }
+  /**
+   * 转换为数组
+   */
+  toArray() {
+    return [...this.items];
+  }
+};
+var DataQueue = class {
+  constructor() {
+    this.items = [];
+  }
+  /**
+   * 入队
+   */
+  enqueue(item) {
+    this.items.push(item);
+  }
+  /**
+   * 出队
+   */
+  dequeue() {
+    return this.items.shift();
+  }
+  /**
+   * 查看队首元素
+   */
+  front() {
+    return this.items[0];
+  }
+  /**
+   * 判断队列是否为空
+   */
+  isEmpty() {
+    return this.items.length === 0;
+  }
+  /**
+   * 获取队列的大小
+   */
+  size() {
+    return this.items.length;
+  }
+  /**
+   * 清空队列
+   */
+  clear() {
+    this.items = [];
+  }
+  /**
+   * 转换为数组
+   */
+  toArray() {
+    return [...this.items];
+  }
+};
+var ListNode = class {
+  constructor(value) {
+    this.next = null;
+    this.value = value;
+  }
+};
+var LinkedList = class {
+  constructor() {
+    this.head = null;
+    this.length = 0;
+  }
+  /**
+   * 在链表末尾添加元素
+   */
+  append(value) {
+    const newNode = new ListNode(value);
+    if (!this.head) {
+      this.head = newNode;
+    } else {
+      let current = this.head;
+      while (current.next) {
+        current = current.next;
+      }
+      current.next = newNode;
+    }
+    this.length++;
+  }
+  /**
+   * 在指定位置插入元素
+   */
+  insert(index, value) {
+    if (index < 0 || index > this.length) {
+      return false;
+    }
+    const newNode = new ListNode(value);
+    if (index === 0) {
+      newNode.next = this.head;
+      this.head = newNode;
+    } else {
+      let current = this.head;
+      for (let i = 0; i < index - 1; i++) {
+        current = current.next;
+      }
+      newNode.next = current.next;
+      current.next = newNode;
+    }
+    this.length++;
+    return true;
+  }
+  /**
+   * 删除指定位置的元素
+   */
+  removeAt(index) {
+    if (index < 0 || index >= this.length || !this.head) {
+      return null;
+    }
+    let current = this.head;
+    if (index === 0) {
+      this.head = current.next;
+      this.length--;
+      return current.value;
+    }
+    for (let i = 0; i < index - 1; i++) {
+      current = current.next;
+    }
+    const removed = current.next;
+    current.next = removed.next;
+    this.length--;
+    return removed.value;
+  }
+  /**
+   * 查找元素索引
+   */
+  indexOf(value) {
+    let current = this.head;
+    let index = 0;
+    while (current) {
+      if (current.value === value) {
+        return index;
+      }
+      current = current.next;
+      index++;
+    }
+    return -1;
+  }
+  /**
+   * 获取指定位置的元素
+   */
+  get(index) {
+    if (index < 0 || index >= this.length || !this.head) {
+      return null;
+    }
+    let current = this.head;
+    for (let i = 0; i < index; i++) {
+      current = current.next;
+    }
+    return current.value;
+  }
+  /**
+   * 判断链表是否为空
+   */
+  isEmpty() {
+    return this.length === 0;
+  }
+  /**
+   * 获取链表长度
+   */
+  size() {
+    return this.length;
+  }
+  /**
+   * 转换为数组
+   */
+  toArray() {
+    const result = [];
+    let current = this.head;
+    while (current) {
+      result.push(current.value);
+      current = current.next;
+    }
+    return result;
+  }
+};
+var TreeNode = class {
+  constructor(value) {
+    this.left = null;
+    this.right = null;
+    this.value = value;
+  }
+};
+var BinaryTree = class {
+  constructor() {
+    this.root = null;
+  }
+  /**
+   * 插入节点
+   */
+  insert(value) {
+    const newNode = new TreeNode(value);
+    if (!this.root) {
+      this.root = newNode;
+      return;
+    }
+    this.insertNode(this.root, newNode);
+  }
+  insertNode(node, newNode) {
+    if (newNode.value <= node.value) {
+      if (!node.left) {
+        node.left = newNode;
+      } else {
+        this.insertNode(node.left, newNode);
+      }
+    } else {
+      if (!node.right) {
+        node.right = newNode;
+      } else {
+        this.insertNode(node.right, newNode);
+      }
+    }
+  }
+  /**
+   * 查找节点
+   */
+  search(value) {
+    return this.searchNode(this.root, value);
+  }
+  searchNode(node, value) {
+    if (!node) {
+      return false;
+    }
+    if (value === node.value) {
+      return true;
+    }
+    if (value < node.value) {
+      return this.searchNode(node.left, value);
+    }
+    return this.searchNode(node.right, value);
+  }
+  /**
+   * 中序遍历
+   */
+  inOrder() {
+    const result = [];
+    this.inOrderTraverse(this.root, result);
+    return result;
+  }
+  inOrderTraverse(node, result) {
+    if (node) {
+      this.inOrderTraverse(node.left, result);
+      result.push(node.value);
+      this.inOrderTraverse(node.right, result);
+    }
+  }
+  /**
+   * 前序遍历
+   */
+  preOrder() {
+    const result = [];
+    this.preOrderTraverse(this.root, result);
+    return result;
+  }
+  preOrderTraverse(node, result) {
+    if (node) {
+      result.push(node.value);
+      this.preOrderTraverse(node.left, result);
+      this.preOrderTraverse(node.right, result);
+    }
+  }
+  /**
+   * 后序遍历
+   */
+  postOrder() {
+    const result = [];
+    this.postOrderTraverse(this.root, result);
+    return result;
+  }
+  postOrderTraverse(node, result) {
+    if (node) {
+      this.postOrderTraverse(node.left, result);
+      this.postOrderTraverse(node.right, result);
+      result.push(node.value);
+    }
+  }
+};
+var Graph = class {
+  constructor() {
+    this.vertices = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 添加顶点
+   */
+  addVertex(vertex) {
+    if (!this.vertices.has(vertex)) {
+      this.vertices.set(vertex, []);
+    }
+  }
+  /**
+   * 添加边（无向图）
+   */
+  addEdge(vertex1, vertex2) {
+    if (!this.vertices.has(vertex1)) {
+      this.addVertex(vertex1);
+    }
+    if (!this.vertices.has(vertex2)) {
+      this.addVertex(vertex2);
+    }
+    const neighbors1 = this.vertices.get(vertex1);
+    const neighbors2 = this.vertices.get(vertex2);
+    if (!neighbors1.includes(vertex2)) {
+      neighbors1.push(vertex2);
+    }
+    if (!neighbors2.includes(vertex1)) {
+      neighbors2.push(vertex1);
+    }
+  }
+  /**
+   * 获取顶点的邻居
+   */
+  getNeighbors(vertex) {
+    return this.vertices.get(vertex) || [];
+  }
+  /**
+   * 深度优先搜索
+   */
+  dfs(start, callback) {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const dfsVisit = (vertex) => {
+      visited.add(vertex);
+      result.push(vertex);
+      if (callback) {
+        callback(vertex);
+      }
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          dfsVisit(neighbor);
+        }
+      }
+    };
+    dfsVisit(start);
+    return result;
+  }
+  /**
+   * 广度优先搜索
+   */
+  bfs(start, callback) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [start];
+    const result = [];
+    visited.add(start);
+    while (queue.length > 0) {
+      const vertex = queue.shift();
+      result.push(vertex);
+      if (callback) {
+        callback(vertex);
+      }
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          queue.push(neighbor);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 获取所有顶点
+   */
+  getVertices() {
+    return Array.from(this.vertices.keys());
+  }
+};
+var LRUCache = class {
+  constructor(capacity) {
+    if (capacity <= 0) {
+      throw new Error("Capacity must be greater than 0");
+    }
+    this.capacity = capacity;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 获取值
+   */
+  get(key) {
+    if (!this.cache.has(key)) {
+      return void 0;
+    }
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  /**
+   * 设置值
+   */
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.capacity) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  /**
+   * 删除键
+   */
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * 清空缓存
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * 判断是否包含键
+   */
+  has(key) {
+    return this.cache.has(key);
+  }
+  /**
+   * 获取缓存大小
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * 获取所有键
+   */
+  keys() {
+    return Array.from(this.cache.keys()).filter((key) => key !== void 0);
+  }
+  /**
+   * 获取所有值
+   */
+  values() {
+    return Array.from(this.cache.values());
+  }
+};
 
-var chunkBHCRFURU_js = require('./chunk-BHCRFURU.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "BinaryTree", {
-  enumerable: true,
-  get: function () { return chunkBHCRFURU_js.BinaryTree; }
-});
-Object.defineProperty(exports, "DataQueue", {
-  enumerable: true,
-  get: function () { return chunkBHCRFURU_js.DataQueue; }
-});
-Object.defineProperty(exports, "Graph", {
-  enumerable: true,
-  get: function () { return chunkBHCRFURU_js.Graph; }
-});
-Object.defineProperty(exports, "LRUCache", {
-  enumerable: true,
-  get: function () { return chunkBHCRFURU_js.LRUCache; }
-});
-Object.defineProperty(exports, "LinkedList", {
-  enumerable: true,
-  get: function () { return chunkBHCRFURU_js.LinkedList; }
-});
-Object.defineProperty(exports, "Stack", {
-  enumerable: true,
-  get: function () { return chunkBHCRFURU_js.Stack; }
-});
-//# sourceMappingURL=data-structure.js.map
-//# sourceMappingURL=data-structure.js.map
+export { BinaryTree, DataQueue, Graph, LRUCache, LinkedList, Stack };

package/dist/{chunk-I3L42475.js → date.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-// src/core/date.ts
+// src/core/date/index.ts
 function formatDate(date, format = "YYYY-MM-DD HH:mm:ss") {
   const d = typeof date === "number" ? new Date(date) : date;
   const year = d.getFullYear();
@@ -141,5 +141,3 @@ exports.isWeekday = isWeekday;
 exports.isWeekend = isWeekend;
 exports.isYesterday = isYesterday;
 exports.startOfDay = startOfDay;
-//# sourceMappingURL=chunk-I3L42475.js.map
-//# sourceMappingURL=chunk-I3L42475.js.map

package/dist/date.js

@@ -1,73 +1,126 @@
-'use strict';
+// src/core/date/index.ts
+function formatDate(date, format = "YYYY-MM-DD HH:mm:ss") {
+  const d = typeof date === "number" ? new Date(date) : date;
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const hours = String(d.getHours()).padStart(2, "0");
+  const minutes = String(d.getMinutes()).padStart(2, "0");
+  const seconds = String(d.getSeconds()).padStart(2, "0");
+  return format.replace("YYYY", String(year)).replace("MM", month).replace("DD", day).replace("HH", hours).replace("mm", minutes).replace("ss", seconds);
+}
+function getRelativeTime(date) {
+  const now = /* @__PURE__ */ new Date();
+  const target = typeof date === "number" ? new Date(date) : date;
+  const diff = now.getTime() - target.getTime();
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const months = Math.floor(days / 30);
+  const years = Math.floor(days / 365);
+  if (years > 0) return `${years}\u5E74\u524D`;
+  if (months > 0) return `${months}\u4E2A\u6708\u524D`;
+  if (days > 0) return `${days}\u5929\u524D`;
+  if (hours > 0) return `${hours}\u5C0F\u65F6\u524D`;
+  if (minutes > 0) return `${minutes}\u5206\u949F\u524D`;
+  if (seconds > 0) return `${seconds}\u79D2\u524D`;
+  return "\u521A\u521A";
+}
+function isToday(date) {
+  const d = typeof date === "number" ? new Date(date) : date;
+  const today = /* @__PURE__ */ new Date();
+  return d.getDate() === today.getDate() && d.getMonth() === today.getMonth() && d.getFullYear() === today.getFullYear();
+}
+function isYesterday(date) {
+  const d = typeof date === "number" ? new Date(date) : date;
+  const yesterday = /* @__PURE__ */ new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  return d.getDate() === yesterday.getDate() && d.getMonth() === yesterday.getMonth() && d.getFullYear() === yesterday.getFullYear();
+}
+function getTimeFromGMT(gmt) {
+  const now = /* @__PURE__ */ new Date();
+  const localOffset = now.getTimezoneOffset();
+  const gmtOffsetMinutes = gmt * 60;
+  const targetTime = new Date(now.getTime() + localOffset * 6e4 + gmtOffsetMinutes * 6e4);
+  const format = getDateFormatByGMT(gmt);
+  return formatDate(targetTime, format);
+}
+function getDateFormatByGMT(gmt) {
+  switch (gmt) {
+    case 0:
+      return "YYYY-MM-DD HH:mm:ss";
+    case 1:
+    case 2:
+    case 3:
+      return "YYYY-MM-DD HH:mm:ss";
+    case 8:
+      return "YYYY-MM-DD HH:mm:ss";
+    case 9:
+      return "YYYY-MM-DD HH:mm:ss";
+    case -5:
+    case -6:
+    case -7:
+    case -8:
+      return "MM/DD/YYYY HH:mm:ss";
+    default:
+      return "YYYY-MM-DD HH:mm:ss";
+  }
+}
+function addDays(date, days) {
+  const d = typeof date === "number" ? new Date(date) : new Date(date);
+  d.setDate(d.getDate() + days);
+  return d;
+}
+function addMonths(date, months) {
+  const d = typeof date === "number" ? new Date(date) : new Date(date);
+  d.setMonth(d.getMonth() + months);
+  return d;
+}
+function addYears(date, years) {
+  const d = typeof date === "number" ? new Date(date) : new Date(date);
+  d.setFullYear(d.getFullYear() + years);
+  return d;
+}
+function diffDays(date1, date2) {
+  const d1 = typeof date1 === "number" ? new Date(date1) : date1;
+  const d2 = typeof date2 === "number" ? new Date(date2) : date2;
+  const diff = d1.getTime() - d2.getTime();
+  return Math.floor(diff / (1e3 * 60 * 60 * 24));
+}
+function startOfDay(date) {
+  const d = typeof date === "number" ? new Date(date) : new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function endOfDay(date) {
+  const d = typeof date === "number" ? new Date(date) : new Date(date);
+  d.setHours(23, 59, 59, 999);
+  return d;
+}
+function isWeekend(date) {
+  const d = typeof date === "number" ? new Date(date) : date;
+  const day = d.getDay();
+  return day === 0 || day === 6;
+}
+function isWeekday(date) {
+  return !isWeekend(date);
+}
+function getWeekNumber(date) {
+  const d = typeof date === "number" ? new Date(date) : new Date(date);
+  const target = new Date(d.valueOf());
+  const dayNr = (d.getDay() + 6) % 7;
+  target.setDate(target.getDate() - dayNr + 3);
+  const firstThursday = target.valueOf();
+  target.setMonth(0, 1);
+  if (target.getDay() !== 4) {
+    target.setMonth(0, 1 + (4 - target.getDay() + 7) % 7);
+  }
+  return 1 + Math.ceil((firstThursday - target.valueOf()) / 6048e5);
+}
+function getQuarter(date) {
+  const d = typeof date === "number" ? new Date(date) : date;
+  return Math.floor(d.getMonth() / 3) + 1;
+}
 
-var chunkI3L42475_js = require('./chunk-I3L42475.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "addDays", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.addDays; }
-});
-Object.defineProperty(exports, "addMonths", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.addMonths; }
-});
-Object.defineProperty(exports, "addYears", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.addYears; }
-});
-Object.defineProperty(exports, "diffDays", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.diffDays; }
-});
-Object.defineProperty(exports, "endOfDay", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.endOfDay; }
-});
-Object.defineProperty(exports, "formatDate", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.formatDate; }
-});
-Object.defineProperty(exports, "getDateFormatByGMT", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.getDateFormatByGMT; }
-});
-Object.defineProperty(exports, "getQuarter", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.getQuarter; }
-});
-Object.defineProperty(exports, "getRelativeTime", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.getRelativeTime; }
-});
-Object.defineProperty(exports, "getTimeFromGMT", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.getTimeFromGMT; }
-});
-Object.defineProperty(exports, "getWeekNumber", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.getWeekNumber; }
-});
-Object.defineProperty(exports, "isToday", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.isToday; }
-});
-Object.defineProperty(exports, "isWeekday", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.isWeekday; }
-});
-Object.defineProperty(exports, "isWeekend", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.isWeekend; }
-});
-Object.defineProperty(exports, "isYesterday", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.isYesterday; }
-});
-Object.defineProperty(exports, "startOfDay", {
-  enumerable: true,
-  get: function () { return chunkI3L42475_js.startOfDay; }
-});
-//# sourceMappingURL=date.js.map
-//# sourceMappingURL=date.js.map
+export { addDays, addMonths, addYears, diffDays, endOfDay, formatDate, getDateFormatByGMT, getQuarter, getRelativeTime, getTimeFromGMT, getWeekNumber, isToday, isWeekday, isWeekend, isYesterday, startOfDay };