@multiplatform.one/frappe 6.0.0

package/dist/cjs/sync/normalizedCache.cjs

@@ -0,0 +1,140 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var normalizedCache_exports = {};
+__export(normalizedCache_exports, {
+  NormalizedCache: () => NormalizedCache
+});
+module.exports = __toCommonJS(normalizedCache_exports);
+class NormalizedCache {
+  state = {};
+  /** LRU tracking: composite key "doctype:name" -> last access timestamp */
+  accessOrder = /* @__PURE__ */new Map();
+  maxSize;
+  onEvict;
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? Infinity;
+    this.onEvict = options.onEvict;
+  }
+  makeKey(doctype, name) {
+    return `${doctype}:${name}`;
+  }
+  parseKey(key) {
+    const colonIndex = key.indexOf(":");
+    return {
+      doctype: key.slice(0, colonIndex),
+      name: key.slice(colonIndex + 1)
+    };
+  }
+  upsert(doc) {
+    let bucket = this.state[doc.doctype];
+    if (!bucket) {
+      bucket = {
+        byId: {},
+        allIds: []
+      };
+      this.state[doc.doctype] = bucket;
+    }
+    const id = doc?.name;
+    if (!id) return;
+    const isNew = !bucket.byId[id];
+    if (isNew) {
+      bucket.allIds.push(id);
+    }
+    bucket.byId[id] = doc;
+    const key = this.makeKey(doc.doctype, id);
+    this.accessOrder.set(key, Date.now());
+    if (isNew && this.maxSize !== Infinity) {
+      this.evictIfNeeded();
+    }
+  }
+  remove(doc) {
+    const bucket = this.state[doc.doctype];
+    if (!bucket) return;
+    if (bucket.byId[doc.name]) delete bucket.byId[doc.name];
+    bucket.allIds = bucket.allIds.filter(currentId => currentId !== doc.name);
+    const key = this.makeKey(doc.doctype, doc.name);
+    this.accessOrder.delete(key);
+  }
+  get(doc) {
+    const result = this.state[doc.doctype]?.byId[doc.name];
+    if (result) {
+      const key = this.makeKey(doc.doctype, doc.name);
+      this.accessOrder.set(key, Date.now());
+    }
+    return result;
+  }
+  getStats() {
+    let size = 0;
+    const doctypes = [];
+    for (const [doctype, bucket] of Object.entries(this.state)) {
+      const count = bucket.allIds.length;
+      size += count;
+      doctypes.push({
+        doctype,
+        count
+      });
+    }
+    return {
+      size,
+      doctypes
+    };
+  }
+  /**
+   * Evicts least recently used documents if cache exceeds maxSize.
+   */
+  evictIfNeeded() {
+    const stats = this.getStats();
+    if (stats.size <= this.maxSize) return;
+    const sortedEntries = [...this.accessOrder.entries()].sort((a, b) => a[1] - b[1]);
+    const toEvict = stats.size - this.maxSize;
+    for (let i = 0; i < toEvict && i < sortedEntries.length; i++) {
+      const [key] = sortedEntries[i];
+      const {
+        doctype,
+        name
+      } = this.parseKey(key);
+      const bucket = this.state[doctype];
+      if (bucket) {
+        delete bucket.byId[name];
+        bucket.allIds = bucket.allIds.filter(id => id !== name);
+      }
+      this.accessOrder.delete(key);
+      if (this.onEvict) {
+        this.onEvict(doctype, name);
+      }
+    }
+  }
+  /**
+   * Clears the entire cache.
+   */
+  clear() {
+    this.state = {};
+    this.accessOrder.clear();
+  }
+  /**
+   * Gets the current cache size.
+   */
+  get size() {
+    return this.getStats().size;
+  }
+}

package/dist/cjs/sync/normalizedCache.native.js

@@ -0,0 +1,229 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var normalizedCache_exports = {};
+__export(normalizedCache_exports, {
+  NormalizedCache: () => NormalizedCache
+});
+module.exports = __toCommonJS(normalizedCache_exports);
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var NormalizedCache = /* @__PURE__ */function () {
+  "use strict";
+
+  function NormalizedCache2() {
+    var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    _class_call_check(this, NormalizedCache2);
+    var _options_maxSize;
+    _define_property(this, "state", {});
+    _define_property(this, "accessOrder", /* @__PURE__ */new Map());
+    _define_property(this, "maxSize", void 0);
+    _define_property(this, "onEvict", void 0);
+    this.maxSize = (_options_maxSize = options.maxSize) !== null && _options_maxSize !== void 0 ? _options_maxSize : Infinity;
+    this.onEvict = options.onEvict;
+  }
+  _create_class(NormalizedCache2, [{
+    key: "makeKey",
+    value: function makeKey(doctype, name) {
+      return `${doctype}:${name}`;
+    }
+  }, {
+    key: "parseKey",
+    value: function parseKey(key) {
+      var colonIndex = key.indexOf(":");
+      return {
+        doctype: key.slice(0, colonIndex),
+        name: key.slice(colonIndex + 1)
+      };
+    }
+  }, {
+    key: "upsert",
+    value: function upsert(doc) {
+      var bucket = this.state[doc.doctype];
+      if (!bucket) {
+        bucket = {
+          byId: {},
+          allIds: []
+        };
+        this.state[doc.doctype] = bucket;
+      }
+      var id = doc === null || doc === void 0 ? void 0 : doc.name;
+      if (!id) return;
+      var isNew = !bucket.byId[id];
+      if (isNew) {
+        bucket.allIds.push(id);
+      }
+      bucket.byId[id] = doc;
+      var key = this.makeKey(doc.doctype, id);
+      this.accessOrder.set(key, Date.now());
+      if (isNew && this.maxSize !== Infinity) {
+        this.evictIfNeeded();
+      }
+    }
+  }, {
+    key: "remove",
+    value: function remove(doc) {
+      var bucket = this.state[doc.doctype];
+      if (!bucket) return;
+      if (bucket.byId[doc.name]) delete bucket.byId[doc.name];
+      bucket.allIds = bucket.allIds.filter(function (currentId) {
+        return currentId !== doc.name;
+      });
+      var key = this.makeKey(doc.doctype, doc.name);
+      this.accessOrder.delete(key);
+    }
+  }, {
+    key: "get",
+    value: function get(doc) {
+      var _this_state_doc_doctype;
+      var result = (_this_state_doc_doctype = this.state[doc.doctype]) === null || _this_state_doc_doctype === void 0 ? void 0 : _this_state_doc_doctype.byId[doc.name];
+      if (result) {
+        var key = this.makeKey(doc.doctype, doc.name);
+        this.accessOrder.set(key, Date.now());
+      }
+      return result;
+    }
+  }, {
+    key: "getStats",
+    value: function getStats() {
+      var size = 0;
+      var doctypes = [];
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = Object.entries(this.state)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var [doctype, bucket] = _step.value;
+          var count = bucket.allIds.length;
+          size += count;
+          doctypes.push({
+            doctype,
+            count
+          });
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      return {
+        size,
+        doctypes
+      };
+    }
+  }, {
+    key: "evictIfNeeded",
+    value: (
+    /**
+    * Evicts least recently used documents if cache exceeds maxSize.
+    */
+    function evictIfNeeded() {
+      var _this,
+        _loop = function (i2) {
+          var [key] = sortedEntries[i2];
+          var {
+            doctype,
+            name
+          } = _this.parseKey(key);
+          var bucket = _this.state[doctype];
+          if (bucket) {
+            delete bucket.byId[name];
+            bucket.allIds = bucket.allIds.filter(function (id) {
+              return id !== name;
+            });
+          }
+          _this.accessOrder.delete(key);
+          if (_this.onEvict) {
+            _this.onEvict(doctype, name);
+          }
+        };
+      var stats = this.getStats();
+      if (stats.size <= this.maxSize) return;
+      var sortedEntries = [...this.accessOrder.entries()].sort(function (a, b) {
+        return a[1] - b[1];
+      });
+      var toEvict = stats.size - this.maxSize;
+      for (var i = 0; i < toEvict && i < sortedEntries.length; i++) _this = this, _loop(i);
+    })
+  }, {
+    /**
+    * Clears the entire cache.
+    */
+    key: "clear",
+    value: function clear() {
+      this.state = {};
+      this.accessOrder.clear();
+    }
+  }, {
+    key: "size",
+    get: (
+    /**
+    * Gets the current cache size.
+    */
+    function get() {
+      return this.getStats().size;
+    })
+  }]);
+  return NormalizedCache2;
+}();
+//# sourceMappingURL=normalizedCache.native.js.map

package/dist/cjs/sync/normalizedCache.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","normalizedCache_exports","__export","NormalizedCache","module","exports","_class_call_check","instance","Constructor","TypeError","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_create_class","protoProps","staticProps","prototype","_define_property","obj","NormalizedCache2","options","arguments","_options_maxSize","Map","maxSize","Infinity","onEvict","makeKey","doctype","name","parseKey","colonIndex","indexOf","slice","upsert","doc","bucket","state","byId","allIds","id","isNew","push","accessOrder","set","Date","now","evictIfNeeded","remove","filter","currentId","delete"],"sources":["../../../src/sync/normalizedCache.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/sync/normalizedCache.spec.cjs

@@ -0,0 +1,302 @@
+var import_vitest = require("vitest");
+var import_normalizedCache = require("./normalizedCache.cjs");
+(0, import_vitest.describe)("NormalizedCache", () => {
+  let cache;
+  (0, import_vitest.beforeEach)(() => {
+    cache = new import_normalizedCache.NormalizedCache();
+  });
+  (0, import_vitest.describe)("upsert", () => {
+    (0, import_vitest.it)("should insert a new document", () => {
+      const doc = {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Test Task",
+        status: "Open"
+      };
+      cache.upsert(doc);
+      const retrieved = cache.get({
+        doctype: "Task",
+        name: "TASK-001"
+      });
+      (0, import_vitest.expect)(retrieved).toEqual(doc);
+      (0, import_vitest.expect)(cache.state.Task.allIds).toContain("TASK-001");
+    });
+    (0, import_vitest.it)("should update an existing document", () => {
+      const originalDoc = {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Original Task",
+        status: "Open"
+      };
+      const updatedDoc = {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Updated Task",
+        status: "Closed"
+      };
+      cache.upsert(originalDoc);
+      cache.upsert(updatedDoc);
+      const retrieved = cache.get({
+        doctype: "Task",
+        name: "TASK-001"
+      });
+      (0, import_vitest.expect)(retrieved).toEqual(updatedDoc);
+      (0, import_vitest.expect)(cache.state.Task.allIds).toHaveLength(1);
+      (0, import_vitest.expect)(cache.state.Task.allIds).toContain("TASK-001");
+    });
+    (0, import_vitest.it)("should create bucket if it doesn't exist", () => {
+      (0, import_vitest.expect)(cache.state.Task).toBeUndefined();
+      const doc = {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Test Task"
+      };
+      cache.upsert(doc);
+      (0, import_vitest.expect)(cache.state.Task).toBeDefined();
+      (0, import_vitest.expect)(cache.state.Task.byId).toBeDefined();
+      (0, import_vitest.expect)(cache.state.Task.allIds).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle document without name", () => {
+      const doc = {
+        doctype: "Task",
+        title: "Test Task"
+      };
+      cache.upsert(doc);
+      (0, import_vitest.expect)(cache.state.Task).toBeDefined();
+      (0, import_vitest.expect)(cache.state.Task.allIds).toHaveLength(0);
+      (0, import_vitest.expect)(Object.keys(cache.state.Task.byId)).toHaveLength(0);
+    });
+    (0, import_vitest.it)("should handle multiple doctypes", () => {
+      const task = {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Test Task"
+      };
+      const project = {
+        name: "PROJ-001",
+        doctype: "Project",
+        title: "Test Project"
+      };
+      cache.upsert(task);
+      cache.upsert(project);
+      (0, import_vitest.expect)(cache.get({
+        doctype: "Task",
+        name: "TASK-001"
+      })).toEqual(task);
+      (0, import_vitest.expect)(cache.get({
+        doctype: "Project",
+        name: "PROJ-001"
+      })).toEqual(project);
+      (0, import_vitest.expect)(cache.state.Task.allIds).toContain("TASK-001");
+      (0, import_vitest.expect)(cache.state.Project.allIds).toContain("PROJ-001");
+    });
+  });
+  (0, import_vitest.describe)("get", () => {
+    (0, import_vitest.it)("should retrieve an existing document", () => {
+      const doc = {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Test Task"
+      };
+      cache.upsert(doc);
+      const retrieved = cache.get({
+        doctype: "Task",
+        name: "TASK-001"
+      });
+      (0, import_vitest.expect)(retrieved).toEqual(doc);
+    });
+    (0, import_vitest.it)("should return undefined for non-existent document", () => {
+      const retrieved = cache.get({
+        doctype: "Task",
+        name: "TASK-999"
+      });
+      (0, import_vitest.expect)(retrieved).toBeUndefined();
+    });
+    (0, import_vitest.it)("should return undefined for non-existent doctype", () => {
+      const retrieved = cache.get({
+        doctype: "NonExistentDoctype",
+        name: "DOC-001"
+      });
+      (0, import_vitest.expect)(retrieved).toBeUndefined();
+    });
+  });
+  (0, import_vitest.describe)("remove", () => {
+    (0, import_vitest.it)("should remove an existing document", () => {
+      const doc = {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Test Task"
+      };
+      cache.upsert(doc);
+      cache.remove({
+        doctype: "Task",
+        name: "TASK-001"
+      });
+      const retrieved = cache.get({
+        doctype: "Task",
+        name: "TASK-001"
+      });
+      (0, import_vitest.expect)(retrieved).toBeUndefined();
+      (0, import_vitest.expect)(cache.state.Task.allIds).not.toContain("TASK-001");
+    });
+    (0, import_vitest.it)("should handle removing non-existent document gracefully", () => {
+      const doc = {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Test Task"
+      };
+      cache.upsert(doc);
+      (0, import_vitest.expect)(() => cache.remove({
+        doctype: "Task",
+        name: "TASK-999"
+      })).not.toThrow();
+      (0, import_vitest.expect)(cache.get({
+        doctype: "Task",
+        name: "TASK-001"
+      })).toEqual(doc);
+    });
+    (0, import_vitest.it)("should handle removing from non-existent doctype gracefully", () => {
+      (0, import_vitest.expect)(() => cache.remove({
+        doctype: "NonExistentDoctype",
+        name: "DOC-001"
+      })).not.toThrow();
+    });
+    (0, import_vitest.it)("should properly update allIds when removing", () => {
+      const doc1 = {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Task 1"
+      };
+      const doc2 = {
+        name: "TASK-002",
+        doctype: "Task",
+        title: "Task 2"
+      };
+      const doc3 = {
+        name: "TASK-003",
+        doctype: "Task",
+        title: "Task 3"
+      };
+      cache.upsert(doc1);
+      cache.upsert(doc2);
+      cache.upsert(doc3);
+      (0, import_vitest.expect)(cache.state.Task.allIds).toHaveLength(3);
+      cache.remove({
+        doctype: "Task",
+        name: "TASK-002"
+      });
+      (0, import_vitest.expect)(cache.state.Task.allIds).toHaveLength(2);
+      (0, import_vitest.expect)(cache.state.Task.allIds).toContain("TASK-001");
+      (0, import_vitest.expect)(cache.state.Task.allIds).toContain("TASK-003");
+      (0, import_vitest.expect)(cache.state.Task.allIds).not.toContain("TASK-002");
+    });
+  });
+  (0, import_vitest.describe)("state management", () => {
+    (0, import_vitest.it)("should maintain separate buckets for different doctypes", () => {
+      const task1 = {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Task 1"
+      };
+      const task2 = {
+        name: "TASK-002",
+        doctype: "Task",
+        title: "Task 2"
+      };
+      const project = {
+        name: "PROJ-001",
+        doctype: "Project",
+        title: "Project 1"
+      };
+      cache.upsert(task1);
+      cache.upsert(task2);
+      cache.upsert(project);
+      (0, import_vitest.expect)(cache.state.Task.allIds).toHaveLength(2);
+      (0, import_vitest.expect)(cache.state.Project.allIds).toHaveLength(1);
+      (0, import_vitest.expect)(Object.keys(cache.state)).toHaveLength(2);
+    });
+    (0, import_vitest.it)("should maintain insertion order in allIds", () => {
+      const docs = [{
+        name: "TASK-003",
+        doctype: "Task",
+        title: "Task 3"
+      }, {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Task 1"
+      }, {
+        name: "TASK-002",
+        doctype: "Task",
+        title: "Task 2"
+      }];
+      docs.forEach(doc => cache.upsert(doc));
+      (0, import_vitest.expect)(cache.state.Task.allIds).toEqual(["TASK-003", "TASK-001", "TASK-002"]);
+    });
+    (0, import_vitest.it)("should not duplicate IDs when updating", () => {
+      const doc = {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Original"
+      };
+      cache.upsert(doc);
+      cache.upsert({
+        ...doc,
+        title: "Updated 1"
+      });
+      cache.upsert({
+        ...doc,
+        title: "Updated 2"
+      });
+      cache.upsert({
+        ...doc,
+        title: "Updated 3"
+      });
+      (0, import_vitest.expect)(cache.state.Task.allIds).toHaveLength(1);
+      (0, import_vitest.expect)(cache.state.Task.allIds).toContain("TASK-001");
+    });
+  });
+  (0, import_vitest.describe)("edge cases", () => {
+    (0, import_vitest.it)("should handle empty string as document name", () => {
+      const doc = {
+        name: "",
+        doctype: "Task",
+        title: "Test Task"
+      };
+      cache.upsert(doc);
+      (0, import_vitest.expect)(cache.state.Task).toBeDefined();
+      (0, import_vitest.expect)(cache.state.Task.allIds).toHaveLength(0);
+      (0, import_vitest.expect)(Object.keys(cache.state.Task.byId)).toHaveLength(0);
+    });
+    (0, import_vitest.it)("should handle complex document structures", () => {
+      const doc = {
+        name: "TASK-001",
+        doctype: "Task",
+        title: "Complex Task",
+        metadata: {
+          created_by: "user@example.com",
+          tags: ["urgent", "important"],
+          nested: {
+            deeply: {
+              nested: "value"
+            }
+          }
+        },
+        items: [{
+          idx: 1,
+          description: "Item 1"
+        }, {
+          idx: 2,
+          description: "Item 2"
+        }]
+      };
+      cache.upsert(doc);
+      const retrieved = cache.get({
+        doctype: "Task",
+        name: "TASK-001"
+      });
+      (0, import_vitest.expect)(retrieved).toEqual(doc);
+      (0, import_vitest.expect)(retrieved?.metadata).toEqual(doc.metadata);
+      (0, import_vitest.expect)(retrieved?.items).toEqual(doc.items);
+    });
+  });
+});