@prototypevip/baileys 0.0.1

package/lib/Store/make-ordered-dictionary.js

@@ -0,0 +1,203 @@
+export function makeOrderedDictionary(idGetter) {
+  const map = new Map();
+
+  let head = null;
+  let tail = null;
+
+  let cached = [];
+  let dirty = true;
+
+  const hooks = {
+    add: new Set(),
+    update: new Set(),
+    remove: new Set(),
+    batch: new Set(),
+  };
+
+  const emit = (type, payload) => {
+    const set = hooks[type];
+    if (!set) return;
+    for (const fn of set) {
+      try {
+        fn(payload);
+      } catch {}
+    }
+  };
+
+  const rebuild = () => {
+    const arr = [];
+    let curr = head;
+    while (curr) {
+      arr.push(curr.item);
+      curr = curr.next;
+    }
+    cached = arr;
+    dirty = false;
+  };
+
+  const get = (id) => map.get(id)?.item;
+
+  const upsert = (item, mode = "append") => {
+    const id = idGetter(item);
+
+    const existing = map.get(id);
+
+    if (existing) {
+      existing.item = item;
+      dirty = true;
+      emit("update", item);
+      return;
+    }
+
+    const node = { id, item, prev: null, next: null };
+
+    map.set(id, node);
+
+    if (!head) {
+      head = tail = node;
+    } else if (mode === "append") {
+      tail.next = node;
+      node.prev = tail;
+      tail = node;
+    } else {
+      node.next = head;
+      head.prev = node;
+      head = node;
+    }
+
+    dirty = true;
+    emit("add", item);
+  };
+
+  const update = (item) => {
+    const id = idGetter(item);
+    const node = map.get(id);
+    if (!node) return false;
+
+    node.item = item;
+    dirty = true;
+
+    emit("update", item);
+    return true;
+  };
+
+  const remove = (item) => {
+    const id = idGetter(item);
+    const node = map.get(id);
+    if (!node) return false;
+
+    if (node.prev) node.prev.next = node.next;
+    else head = node.next;
+
+    if (node.next) node.next.prev = node.prev;
+    else tail = node.prev;
+
+    map.delete(id);
+
+    node.prev = node.next = null;
+
+    dirty = true;
+    emit("remove", item);
+
+    return true;
+  };
+
+  const updateAssign = (id, patch) => {
+    const node = map.get(id);
+    if (!node) return false;
+
+    const data = typeof patch === "function" ? patch(node.item) : patch;
+
+    Object.assign(node.item, data);
+
+    const newId = idGetter(node.item);
+
+    if (newId !== id) {
+      map.delete(id);
+      map.set(newId, node);
+      node.id = newId;
+    }
+
+    dirty = true;
+    emit("update", node.item);
+
+    return true;
+  };
+
+  const clear = () => {
+    map.clear();
+    head = tail = null;
+    cached = [];
+    dirty = false;
+  };
+
+  const filter = (fn) => {
+    let curr = head;
+
+    while (curr) {
+      const next = curr.next;
+
+      if (!fn(curr.item)) {
+        map.delete(curr.id);
+
+        if (curr.prev) curr.prev.next = curr.next;
+        else head = curr.next;
+
+        if (curr.next) curr.next.prev = curr.prev;
+        else tail = curr.prev;
+
+        curr.prev = curr.next = null;
+
+        dirty = true;
+        emit("remove", curr.item);
+      }
+
+      curr = next;
+    }
+  };
+
+  const snapshot = () => {
+    return {
+      data: dirty ? (rebuild(), cached) : cached,
+      size: map.size,
+    };
+  };
+
+  const iterator = function* () {
+    let curr = head;
+    while (curr) {
+      yield curr.item;
+      curr = curr.next;
+    }
+  };
+
+  const on = (type, fn) => {
+    if (hooks[type]) hooks[type].add(fn);
+  };
+
+  const off = (type, fn) => {
+    hooks[type]?.delete(fn);
+  };
+
+  const array = () => {
+    if (dirty) rebuild();
+    return cached;
+  };
+
+  return {
+    get,
+    upsert,
+    update,
+    remove,
+    updateAssign,
+    clear,
+    filter,
+
+    array,
+    snapshot,
+    iterator,
+
+    on,
+    off,
+  };
+}

package/lib/Store/object-repository.js

@@ -0,0 +1,23 @@
+export class ObjectRepository {
+  constructor(entities = {}) {
+    this.entityMap = new Map(Object.entries(entities));
+  }
+  findById(id) {
+    return this.entityMap.get(id);
+  }
+  findAll() {
+    return Array.from(this.entityMap.values());
+  }
+  upsertById(id, entity) {
+    return this.entityMap.set(id, { ...entity });
+  }
+  deleteById(id) {
+    return this.entityMap.delete(id);
+  }
+  count() {
+    return this.entityMap.size;
+  }
+  toJSON() {
+    return this.findAll();
+  }
+}