jc-structure 0.2.5 → 0.2.7

package/index.d.ts

@@ -1,57 +1,63 @@
+/// <reference path="./types/index.d.ts" />
+
 declare module "jc-structure" {
-  export * from "./types";
+  import * as Types from "./types";
+  export = Types;
 
   //#region  data structure
   /**
    * #### 数据结构接口
    */
-  interface DataStructure {
-    /**
-     * 判断数据结构是否为空
-     */
-    isEmpty(): boolean;
-    /**
-     * 数据结构元素长度
-     */
-    size(): number;
-    /**
-     * 清除数据结构元素
-     */
-    clear(): void;
-    /**
-     * 重写 toString 方法
-     */
-    toString(): string;
-  }
+  // interface DataStructure {
+  //   /**
+  //    * 判断数据结构是否为空
+  //    */
+  //   isEmpty(): boolean;
+  //   /**
+  //    * 数据结构元素长度
+  //    */
+  //   size(): number;
+  //   /**
+  //    * 清除数据结构元素
+  //    */
+  //   clear(): void;
+  //   /**
+  //    * 重写 toString 方法
+  //    */
+  //   toString(): string;
+  // }
 
   /**
    * 栈类，采用object实现
    */
-  interface Stack<T> extends DataStructure {
-    /**
-     * #### 移除栈顶元素并返回该元素
-     */
-    pop(): T | undefined;
-
-    /**
-     * #### 向栈顶添加元素
-     * @param args 要添加的元素,key可以是多个或一个元素。
-     */
-    push(item: T): this;
-    push(items: Array<T>): this;
-    push(...items: T[]): this;
-    push(itemOrItems: T | Array<T>): this;
-
-    /**
-     * #### 返回栈顶元素，但不移除
-     */
-    peek(): T | undefined;
-  }
-  interface StackConstructor {
-    new <T>(): Stack<T>;
-    readonly prototype: Stack<T>;
+  export class Stack<T> implements IStack<T> {
+    constructor();
   }
-  var Stack: StackConstructor;
+  // interface Stack<T> extends DataStructure {
+  //   /**
+  //    * #### 移除栈顶元素并返回该元素
+  //    */
+  //   pop(): T | undefined;
+
+  //   /**
+  //    * #### 向栈顶添加元素
+  //    * @param args 要添加的元素,key可以是多个或一个元素。
+  //    */
+  //   push(item: T): this;
+  //   push(items: Array<T>): this;
+  //   push(...items: T[]): this;
+  //   push(itemOrItems: T | Array<T>): this;
+
+  //   /**
+  //    * #### 返回栈顶元素，但不移除
+  //    */
+  //   peek(): T | undefined;
+  // }
+  // interface StackConstructor {
+  //   new <T>(): Stack<T>;
+  //   readonly prototype: Stack<T>;
+  // }
+  // var Stack: StackConstructor;
 
   /**
    * 队列类，采用object实现

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "jc-structure",
   "private": false,
-  "version": "0.2.5",
+  "version": "0.2.7",
   "type": "module",
   "files": [
     "dist",
+    "types",
     "index.d.ts",
     "README.md",
     "LICENSE"

package/types/dictionary.d.ts

@@ -0,0 +1,50 @@
+/**
+ * #### 字典接口
+ */
+interface IDictionary<K, V> extends Structure {
+  /**
+   * #### 设置键值对
+   * @param key 键
+   * @param value 值
+   */
+  set(key: K, value: V): void;
+
+  /**
+   * #### 删除键值对
+   * @param key 键
+   */
+  remove(key: K): ValuePair<K, V> | undefined;
+
+  /**
+   * #### 判断键是否存在
+   * @param key 键
+   */
+  has(key: K): boolean;
+
+  /**
+   * #### 获取键值对
+   * @param key 键
+   */
+  get(key: K): ValuePair<K, V> | undefined;
+
+  /**
+   * #### 获取键数组
+   */
+  keys(): Array<K>;
+
+  /**
+   * #### 获取值数组
+   */
+  values(): Array<V>;
+
+  /**
+   * #### 获取键值对数组
+   */
+  keyValues(): Array<[K, V]>;
+
+  /**
+   * 遍历键值对
+   * @param callbackFunc 回调函数
+   */
+  forEach(callbackFunc: (key: K, value: V) => boolean | void): void;
+}

package/types/global.d.ts

@@ -0,0 +1,75 @@
+interface Structure {
+  /**
+   * 判断数据结构是否为空
+   */
+  isEmpty(): boolean;
+  /**
+   * 数据结构元素长度
+   */
+  size(): number;
+  /**
+   * 清除数据结构元素
+   */
+  clear(): void;
+  /**
+   * 重写 toString 方法
+   */
+  toString(): string;
+}
+
+type CompareResult = -1 | 0 | 1;
+
+/**
+ * #### 比较函数接口
+ */
+interface CompareFn<T> {
+  (a: T, b: T): CompareResult;
+}
+
+/**
+ * #### 对象接口，用于存储数据结构元素，值类型默认为 any
+ */
+interface Obj<V = any> {
+  [key: string]: V;
+}
+
+interface RegExpConstructor {
+  /**
+   * #### 转义正则表达式中的特殊字符
+   * @param str 字符串
+   */
+  escape(str: string): string;
+}
+
+interface Element {
+  /**
+   * #### 获取最深元素集合中的第一个元素
+   */
+  readonly firstElement: Element | null;
+  /**
+   * #### 获取最深元素集合中的最后一个元素
+   */
+  readonly lastElement: Element | null;
+  /**
+   * #### 最祖先的匹配元素
+   * @param this element
+   * @param selector 选择器
+   */
+  farthest<E extends Element = Element>(this: E, selector: string): E | null;
+}
+
+interface Text {
+  /**
+   * #### 将文本节点包裹在指定标签中
+   * @param this Text 该文本节点
+   * @param selector 要包裹的元素标签，默认为：'strong'
+   * @param text 要包裹的文本，默认为：''
+   */
+  surround(this: Text, selector?: string, text?: string): HTMLElement | null;
+}
+
+interface Array<T> {
+  groupBy<K extends string | number | symbol>(
+    generateKey: string | ((item: T, index: number, arr: T[]) => K)
+  ): Record<K, T[]>;
+}

package/types/graph.d.ts

@@ -0,0 +1,24 @@
+/**
+ * #### 图接口
+ */
+interface IGraph<T> {
+  /**
+   * #### 添加顶点的方法
+   * @param v 顶点
+   */
+  addVertex(v: T): void;
+  /**
+   * #### 添加边的方法
+   * @param v 顶点
+   * @param w
+   */
+  addEdge(v: T, w: T): void;
+  /**
+   * #### 获取顶点集合的方法
+   */
+  getVertices(): Array<T>;
+  /**
+   * #### 获取邻接表的方法
+   */
+  getAdjacencyList(): IDictionary<T, Array<T>>;
+}

package/types/heap.d.ts

@@ -0,0 +1,21 @@
+/**
+ * #### 堆
+ */
+interface IHeap<T> extends Structure {
+  /**
+   * #### 插入一个值，返回一个布尔值
+   * @param value 要插入的值
+   */
+  insert(value: T): boolean;
+
+  /**
+   * #### 移除最小值或最大值，返回该值
+   */
+  extract(): T | undefined;
+
+  /**
+   * 查找一个值
+   * @param value 要查找的值
+   */
+  find(): T | undefined;
+}

package/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./global";
+export * from "./linkedList";
+export * from "./stack";
+export * from "./queue";

package/types/linkedList.d.ts

@@ -0,0 +1,28 @@
+class JcNode<T> {
+  value: T;
+  next: JcNode<T> | null;
+  constructor(value: T, next: JcNode<T> | null = null): void;
+}
+
+/**
+ * #### 链表接口
+ */
+interface ILinkedList<T> {
+  indexOf(element: T): number;
+  getElementAt(index: number): JcNode<T> | null;
+  getValueAt(index: number): T | undefined;
+  insert(element: T, index: number): boolean;
+  push(element: T): void;
+  remove(element: T): T | null;
+  removeAt(index: number): T | null;
+  isEmpty(): boolean;
+  size(): number;
+  clear(): void;
+  toString(): string;
+  toArray(): T[];
+  [Symbol.iterator](): Iterator<T>;
+}
+
+class LinkedList<T> implements ILinkedList<T> {
+  constructor(elements?: T[]);
+}

package/types/queue.d.ts

@@ -0,0 +1,20 @@
+/**
+ * #### 队列接口
+ */
+interface IQueue<T> extends Structure {
+  /**
+   * #### 移除队列头部元素并返回该元素
+   */
+  dequeue(): T | undefined;
+
+  /**
+   * #### 向队列末尾添加元素
+   * @param args 要添加的元素
+   */
+  enqueue(...args: (T | T[])[]): this;
+
+  /**
+   * #### 返回队列头部元素，但不移除
+   */
+  front(): T | undefined;
+}

package/types/shape.d.ts

@@ -0,0 +1,11 @@
+interface Point {
+  x: number;
+  y: number;
+}
+type Coord = Point;
+type Coord3D = Point & { z: number };
+
+interface Rect extends Point {
+  w: number;
+  h: number;
+}

package/types/stack.d.ts

@@ -0,0 +1,24 @@
+interface StructureObj<T> {
+  [key: number]: T;
+}
+
+/**
+ * #### 栈接口
+ */
+interface IStack<T> extends Structure {
+  /**
+   * #### 移除栈顶元素并返回该元素
+   */
+  pop(): T | undefined;
+
+  /**
+   * #### 添加一个或多个元素
+   * @param items
+   */
+  push(...items: (T | T[])[]): this;
+
+  /**
+   * #### 返回栈顶元素，但不移除
+   */
+  peek(): T | undefined;
+}

package/types/vector.d.ts

@@ -0,0 +1,20 @@
+interface Vector {
+  get dimension(): number;
+  get norm(): number;
+  getItem(index: number): number;
+  normalize(): Vector;
+  add(vector: Vector): Vector;
+  sub(vector: Vector): Vector;
+  mul(scalar: number): Vector;
+  dot(vector: Vector): number;
+  pos(): Vector;
+  neg(): Vector;
+}
+
+interface VectorConstructor {
+  new (...args: number[]): Vector;
+  readonly prototype: Vector;
+  zero(dimension: number): Vector;
+}
+
+declare var Vector: VectorConstructor;