oto-storage 0.4.2 → 0.4.3

package/dist/index.d.mts

@@ -0,0 +1,16 @@
+interface StorageOptions {
+    prefix?: string;
+    type?: "local" | "session";
+    defaults?: Record<string, any>;
+    ttl?: number;
+    encryption?: StorageEncryptionOptions;
+}
+interface StorageEncryptionOptions {
+    encrypt: (plainText: string) => string;
+    decrypt: (cipherText: string) => string;
+    migrate?: boolean;
+}
+declare function oto<T extends object>(options?: StorageOptions): T;
+declare const version = "0.4.2";
+
+export { type StorageEncryptionOptions, type StorageOptions, oto, version };

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+interface StorageOptions {
+    prefix?: string;
+    type?: "local" | "session";
+    defaults?: Record<string, any>;
+    ttl?: number;
+    encryption?: StorageEncryptionOptions;
+}
+interface StorageEncryptionOptions {
+    encrypt: (plainText: string) => string;
+    decrypt: (cipherText: string) => string;
+    migrate?: boolean;
+}
+declare function oto<T extends object>(options?: StorageOptions): T;
+declare const version = "0.4.2";
+
+export { type StorageEncryptionOptions, type StorageOptions, oto, version };

package/dist/index.js

@@ -0,0 +1,450 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  oto: () => oto,
+  version: () => version
+});
+module.exports = __toCommonJS(index_exports);
+function deepMerge(target, source) {
+  if (source === null || source === void 0) return target;
+  if (target === null || target === void 0) return source;
+  if (typeof target !== "object" || typeof source !== "object") return source;
+  if (Array.isArray(target) || Array.isArray(source)) return source;
+  const result = { ...target };
+  for (const key in source) {
+    if (source.hasOwnProperty(key)) {
+      result[key] = deepMerge(target[key], source[key]);
+    }
+  }
+  return result;
+}
+function wrapWithTTL(value, ttl) {
+  return {
+    __oto_value: value,
+    __oto_expires: Date.now() + ttl
+  };
+}
+function unwrapWithTTL(wrapped) {
+  if (wrapped && typeof wrapped === "object" && "__oto_expires" in wrapped && "__oto_value" in wrapped && typeof wrapped.__oto_expires === "number") {
+    const expired = Date.now() > wrapped.__oto_expires;
+    return { value: wrapped.__oto_value, expired };
+  }
+  return { value: wrapped, expired: false };
+}
+function isEncryptedWrapper(value) {
+  return value && typeof value === "object" && value.__oto_encrypted === true && typeof value.__oto_payload === "string";
+}
+function serializeForStorage(value, ttl, encryption) {
+  let valueToStore = value;
+  if (ttl && ttl > 0) {
+    valueToStore = wrapWithTTL(valueToStore, ttl);
+  }
+  if (!encryption) {
+    return JSON.stringify(valueToStore);
+  }
+  const plainText = JSON.stringify(valueToStore);
+  const cipherText = encryption.encrypt(plainText);
+  return JSON.stringify({
+    __oto_encrypted: true,
+    __oto_payload: cipherText
+  });
+}
+function migrateStoredValueToEncrypted(safeStorage, fullKey, rawParsed, encryption) {
+  if (!encryption?.migrate || isEncryptedWrapper(rawParsed)) {
+    return;
+  }
+  try {
+    const cipherText = encryption.encrypt(JSON.stringify(rawParsed));
+    const wrapped = {
+      __oto_encrypted: true,
+      __oto_payload: cipherText
+    };
+    safeStorage.setItem(fullKey, JSON.stringify(wrapped));
+  } catch (error) {
+    console.error(`TypedProxy: Failed to migrate ${fullKey} to encrypted format`, error);
+  }
+}
+function maybeMigrate(safeStorage, fullKey, readResult, encryption) {
+  if (encryption?.migrate && !readResult.parseError && !readResult.wasEncrypted && readResult.rawParsed !== void 0) {
+    migrateStoredValueToEncrypted(safeStorage, fullKey, readResult.rawParsed, encryption);
+  }
+}
+function readStoredValue(storedValue, ttl, encryption) {
+  let parsed;
+  try {
+    parsed = JSON.parse(storedValue);
+  } catch {
+    return {
+      value: storedValue,
+      parseError: true,
+      decryptionError: false,
+      expired: false,
+      wasEncrypted: false
+    };
+  }
+  let payload = parsed;
+  let wasEncrypted = false;
+  if (encryption && isEncryptedWrapper(parsed)) {
+    wasEncrypted = true;
+    try {
+      const plainText = encryption.decrypt(parsed.__oto_payload);
+      payload = JSON.parse(plainText);
+    } catch {
+      return {
+        value: void 0,
+        rawParsed: parsed,
+        parseError: false,
+        decryptionError: true,
+        expired: false,
+        wasEncrypted
+      };
+    }
+  }
+  if (ttl && ttl > 0) {
+    const unwrapped = unwrapWithTTL(payload);
+    if (unwrapped.expired) {
+      return {
+        value: void 0,
+        rawParsed: parsed,
+        parseError: false,
+        decryptionError: false,
+        expired: true,
+        wasEncrypted
+      };
+    }
+    payload = unwrapped.value;
+  }
+  return {
+    value: payload,
+    rawParsed: parsed,
+    parseError: false,
+    decryptionError: false,
+    expired: false,
+    wasEncrypted
+  };
+}
+function getValueAtPath(safeStorage, prefix, rootKey, path = [], ttl, encryption) {
+  const fullKey = `${prefix}${rootKey}`;
+  const storedValue = safeStorage.getItem(fullKey);
+  if (storedValue === null) return void 0;
+  const readResult = readStoredValue(storedValue, ttl, encryption);
+  if (readResult.expired || readResult.decryptionError) {
+    safeStorage.removeItem(fullKey);
+    return void 0;
+  }
+  maybeMigrate(safeStorage, fullKey, readResult, encryption);
+  let current = readResult.value;
+  for (const key of path) {
+    if (current === null || current === void 0) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function createNestedProxy(safeStorage, prefix, rootKey, path = [], defaultsAtRoot, ttl, encryption) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop === "symbol") {
+        return getValueAtPath(safeStorage, prefix, rootKey, path, ttl, encryption)?.[prop];
+      }
+      const current = getValueAtPath(
+        safeStorage,
+        prefix,
+        rootKey,
+        path,
+        ttl,
+        encryption
+      );
+      let defaultsAtPath;
+      if (defaultsAtRoot !== void 0) {
+        defaultsAtPath = defaultsAtRoot;
+        for (const key of path) {
+          if (defaultsAtPath && typeof defaultsAtPath === "object") {
+            defaultsAtPath = defaultsAtPath[key];
+          } else {
+            defaultsAtPath = void 0;
+            break;
+          }
+        }
+      }
+      if ((current === null || current === void 0) && !defaultsAtPath) {
+        return void 0;
+      }
+      let value = current?.[prop];
+      if (defaultsAtPath && defaultsAtPath[prop] !== void 0) {
+        value = deepMerge(defaultsAtPath[prop], value);
+      }
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        return createNestedProxy(
+          safeStorage,
+          prefix,
+          rootKey,
+          [...path, prop],
+          defaultsAtRoot,
+          ttl,
+          encryption
+        );
+      }
+      return value;
+    },
+    set(_target, prop, value) {
+      const fullKey = `${prefix}${rootKey}`;
+      const storedValue = safeStorage.getItem(fullKey);
+      let rootObj = {};
+      if (storedValue !== null) {
+        const readResult = readStoredValue(storedValue, ttl, encryption);
+        if (readResult.expired || readResult.decryptionError) {
+          safeStorage.removeItem(fullKey);
+          rootObj = {};
+        } else {
+          rootObj = readResult.value;
+        }
+      }
+      if (rootObj === null || typeof rootObj !== "object" || Array.isArray(rootObj)) {
+        rootObj = {};
+      }
+      let current = rootObj;
+      for (const key of path) {
+        if (current[key] === null || typeof current[key] !== "object") {
+          current[key] = {};
+        }
+        current = current[key];
+      }
+      current[prop] = value;
+      try {
+        safeStorage.setItem(fullKey, serializeForStorage(rootObj, ttl, encryption));
+        return true;
+      } catch (error) {
+        console.error(`TypedProxy: Failed to save ${rootKey}`, error);
+        return true;
+      }
+    },
+    ownKeys() {
+      const current = getValueAtPath(
+        safeStorage,
+        prefix,
+        rootKey,
+        path,
+        ttl,
+        encryption
+      );
+      const keys = current ? Object.keys(current) : [];
+      if (defaultsAtRoot !== void 0) {
+        let defaultsAtPath = defaultsAtRoot;
+        for (const key of path) {
+          if (defaultsAtPath && typeof defaultsAtPath === "object") {
+            defaultsAtPath = defaultsAtPath[key];
+          } else {
+            defaultsAtPath = void 0;
+            break;
+          }
+        }
+        if (defaultsAtPath && typeof defaultsAtPath === "object") {
+          const defaultKeys = Object.keys(defaultsAtPath);
+          for (const key of defaultKeys) {
+            if (!keys.includes(key)) {
+              keys.push(key);
+            }
+          }
+        }
+      }
+      return keys;
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      if (typeof prop === "symbol") return void 0;
+      const current = getValueAtPath(
+        safeStorage,
+        prefix,
+        rootKey,
+        path,
+        ttl,
+        encryption
+      );
+      let defaultsAtPath;
+      if (defaultsAtRoot !== void 0) {
+        defaultsAtPath = defaultsAtRoot;
+        for (const key of path) {
+          if (defaultsAtPath && typeof defaultsAtPath === "object") {
+            defaultsAtPath = defaultsAtPath[key];
+          } else {
+            defaultsAtPath = void 0;
+            break;
+          }
+        }
+      }
+      const inCurrent = current && typeof current === "object" && prop in current;
+      const inDefaults = defaultsAtPath && typeof defaultsAtPath === "object" && prop in defaultsAtPath;
+      if (!inCurrent && !inDefaults) return void 0;
+      let value = current?.[prop];
+      if (defaultsAtPath && defaultsAtPath[prop] !== void 0) {
+        value = deepMerge(defaultsAtPath[prop], value);
+      }
+      const descriptorValue = value !== null && typeof value === "object" && !Array.isArray(value) ? createNestedProxy(
+        safeStorage,
+        prefix,
+        rootKey,
+        [...path, prop],
+        defaultsAtRoot,
+        ttl,
+        encryption
+      ) : value;
+      return {
+        value: descriptorValue,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      };
+    },
+    has(_target, prop) {
+      if (typeof prop === "symbol") return false;
+      const current = getValueAtPath(
+        safeStorage,
+        prefix,
+        rootKey,
+        path,
+        ttl,
+        encryption
+      );
+      if (current && typeof current === "object" && prop in current) {
+        return true;
+      }
+      if (defaultsAtRoot !== void 0) {
+        let defaultsAtPath = defaultsAtRoot;
+        for (const key of path) {
+          if (defaultsAtPath && typeof defaultsAtPath === "object") {
+            defaultsAtPath = defaultsAtPath[key];
+          } else {
+            defaultsAtPath = void 0;
+            break;
+          }
+        }
+        if (defaultsAtPath && typeof defaultsAtPath === "object" && prop in defaultsAtPath) {
+          return true;
+        }
+      }
+      return false;
+    }
+  });
+}
+function oto(options = {}) {
+  const { prefix = "", type = "local", defaults = {}, ttl, encryption } = options;
+  const storage = typeof window !== "undefined" ? type === "session" ? window.sessionStorage : window.localStorage : null;
+  const safeStorage = storage || {
+    getItem: () => null,
+    setItem: () => {
+    },
+    removeItem: () => {
+    },
+    clear: () => {
+    },
+    key: () => null,
+    get length() {
+      return 0;
+    }
+  };
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (prop === "clearAll") {
+        return () => {
+          const keys = [];
+          for (let i = 0; i < safeStorage.length; i++) {
+            const key = safeStorage.key(i);
+            if (key) keys.push(key);
+          }
+          keys.forEach((key) => {
+            if (key.startsWith(prefix)) safeStorage.removeItem(key);
+          });
+        };
+      }
+      const fullKey = `${prefix}${prop}`;
+      const storedValue = safeStorage.getItem(fullKey);
+      let parsed;
+      if (storedValue === null) {
+        parsed = void 0;
+      } else {
+        const readResult = readStoredValue(storedValue, ttl, encryption);
+        if (readResult.expired || readResult.decryptionError) {
+          safeStorage.removeItem(fullKey);
+          parsed = void 0;
+        } else {
+          maybeMigrate(safeStorage, fullKey, readResult, encryption);
+          parsed = readResult.value;
+        }
+      }
+      if (defaults && defaults[prop] !== void 0) {
+        parsed = deepMerge(defaults[prop], parsed);
+      }
+      if (parsed === void 0) return void 0;
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return createNestedProxy(
+          safeStorage,
+          prefix,
+          prop,
+          [],
+          defaults[prop],
+          ttl,
+          encryption
+        );
+      }
+      return parsed;
+    },
+    set(_target, prop, value) {
+      try {
+        safeStorage.setItem(`${prefix}${prop}`, serializeForStorage(value, ttl, encryption));
+        return true;
+      } catch (error) {
+        console.error(`TypedProxy: Failed to save ${prop}`, error);
+        return true;
+      }
+    },
+    has(_target, prop) {
+      if (defaults && prop in defaults) {
+        return true;
+      }
+      const fullKey = `${prefix}${prop}`;
+      const storedValue = safeStorage.getItem(fullKey);
+      if (storedValue === null) {
+        return false;
+      }
+      try {
+        const readResult = readStoredValue(storedValue, ttl, encryption);
+        if (readResult.expired || readResult.decryptionError) {
+          safeStorage.removeItem(fullKey);
+          return false;
+        }
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    deleteProperty(_target, prop) {
+      const key = `${prefix}${String(prop)}`;
+      safeStorage.removeItem(key);
+      return true;
+    }
+  });
+}
+var version = "0.4.2";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  oto,
+  version
+});

package/dist/index.mjs

@@ -0,0 +1,424 @@
+// src/index.ts
+function deepMerge(target, source) {
+  if (source === null || source === void 0) return target;
+  if (target === null || target === void 0) return source;
+  if (typeof target !== "object" || typeof source !== "object") return source;
+  if (Array.isArray(target) || Array.isArray(source)) return source;
+  const result = { ...target };
+  for (const key in source) {
+    if (source.hasOwnProperty(key)) {
+      result[key] = deepMerge(target[key], source[key]);
+    }
+  }
+  return result;
+}
+function wrapWithTTL(value, ttl) {
+  return {
+    __oto_value: value,
+    __oto_expires: Date.now() + ttl
+  };
+}
+function unwrapWithTTL(wrapped) {
+  if (wrapped && typeof wrapped === "object" && "__oto_expires" in wrapped && "__oto_value" in wrapped && typeof wrapped.__oto_expires === "number") {
+    const expired = Date.now() > wrapped.__oto_expires;
+    return { value: wrapped.__oto_value, expired };
+  }
+  return { value: wrapped, expired: false };
+}
+function isEncryptedWrapper(value) {
+  return value && typeof value === "object" && value.__oto_encrypted === true && typeof value.__oto_payload === "string";
+}
+function serializeForStorage(value, ttl, encryption) {
+  let valueToStore = value;
+  if (ttl && ttl > 0) {
+    valueToStore = wrapWithTTL(valueToStore, ttl);
+  }
+  if (!encryption) {
+    return JSON.stringify(valueToStore);
+  }
+  const plainText = JSON.stringify(valueToStore);
+  const cipherText = encryption.encrypt(plainText);
+  return JSON.stringify({
+    __oto_encrypted: true,
+    __oto_payload: cipherText
+  });
+}
+function migrateStoredValueToEncrypted(safeStorage, fullKey, rawParsed, encryption) {
+  if (!encryption?.migrate || isEncryptedWrapper(rawParsed)) {
+    return;
+  }
+  try {
+    const cipherText = encryption.encrypt(JSON.stringify(rawParsed));
+    const wrapped = {
+      __oto_encrypted: true,
+      __oto_payload: cipherText
+    };
+    safeStorage.setItem(fullKey, JSON.stringify(wrapped));
+  } catch (error) {
+    console.error(`TypedProxy: Failed to migrate ${fullKey} to encrypted format`, error);
+  }
+}
+function maybeMigrate(safeStorage, fullKey, readResult, encryption) {
+  if (encryption?.migrate && !readResult.parseError && !readResult.wasEncrypted && readResult.rawParsed !== void 0) {
+    migrateStoredValueToEncrypted(safeStorage, fullKey, readResult.rawParsed, encryption);
+  }
+}
+function readStoredValue(storedValue, ttl, encryption) {
+  let parsed;
+  try {
+    parsed = JSON.parse(storedValue);
+  } catch {
+    return {
+      value: storedValue,
+      parseError: true,
+      decryptionError: false,
+      expired: false,
+      wasEncrypted: false
+    };
+  }
+  let payload = parsed;
+  let wasEncrypted = false;
+  if (encryption && isEncryptedWrapper(parsed)) {
+    wasEncrypted = true;
+    try {
+      const plainText = encryption.decrypt(parsed.__oto_payload);
+      payload = JSON.parse(plainText);
+    } catch {
+      return {
+        value: void 0,
+        rawParsed: parsed,
+        parseError: false,
+        decryptionError: true,
+        expired: false,
+        wasEncrypted
+      };
+    }
+  }
+  if (ttl && ttl > 0) {
+    const unwrapped = unwrapWithTTL(payload);
+    if (unwrapped.expired) {
+      return {
+        value: void 0,
+        rawParsed: parsed,
+        parseError: false,
+        decryptionError: false,
+        expired: true,
+        wasEncrypted
+      };
+    }
+    payload = unwrapped.value;
+  }
+  return {
+    value: payload,
+    rawParsed: parsed,
+    parseError: false,
+    decryptionError: false,
+    expired: false,
+    wasEncrypted
+  };
+}
+function getValueAtPath(safeStorage, prefix, rootKey, path = [], ttl, encryption) {
+  const fullKey = `${prefix}${rootKey}`;
+  const storedValue = safeStorage.getItem(fullKey);
+  if (storedValue === null) return void 0;
+  const readResult = readStoredValue(storedValue, ttl, encryption);
+  if (readResult.expired || readResult.decryptionError) {
+    safeStorage.removeItem(fullKey);
+    return void 0;
+  }
+  maybeMigrate(safeStorage, fullKey, readResult, encryption);
+  let current = readResult.value;
+  for (const key of path) {
+    if (current === null || current === void 0) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function createNestedProxy(safeStorage, prefix, rootKey, path = [], defaultsAtRoot, ttl, encryption) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop === "symbol") {
+        return getValueAtPath(safeStorage, prefix, rootKey, path, ttl, encryption)?.[prop];
+      }
+      const current = getValueAtPath(
+        safeStorage,
+        prefix,
+        rootKey,
+        path,
+        ttl,
+        encryption
+      );
+      let defaultsAtPath;
+      if (defaultsAtRoot !== void 0) {
+        defaultsAtPath = defaultsAtRoot;
+        for (const key of path) {
+          if (defaultsAtPath && typeof defaultsAtPath === "object") {
+            defaultsAtPath = defaultsAtPath[key];
+          } else {
+            defaultsAtPath = void 0;
+            break;
+          }
+        }
+      }
+      if ((current === null || current === void 0) && !defaultsAtPath) {
+        return void 0;
+      }
+      let value = current?.[prop];
+      if (defaultsAtPath && defaultsAtPath[prop] !== void 0) {
+        value = deepMerge(defaultsAtPath[prop], value);
+      }
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        return createNestedProxy(
+          safeStorage,
+          prefix,
+          rootKey,
+          [...path, prop],
+          defaultsAtRoot,
+          ttl,
+          encryption
+        );
+      }
+      return value;
+    },
+    set(_target, prop, value) {
+      const fullKey = `${prefix}${rootKey}`;
+      const storedValue = safeStorage.getItem(fullKey);
+      let rootObj = {};
+      if (storedValue !== null) {
+        const readResult = readStoredValue(storedValue, ttl, encryption);
+        if (readResult.expired || readResult.decryptionError) {
+          safeStorage.removeItem(fullKey);
+          rootObj = {};
+        } else {
+          rootObj = readResult.value;
+        }
+      }
+      if (rootObj === null || typeof rootObj !== "object" || Array.isArray(rootObj)) {
+        rootObj = {};
+      }
+      let current = rootObj;
+      for (const key of path) {
+        if (current[key] === null || typeof current[key] !== "object") {
+          current[key] = {};
+        }
+        current = current[key];
+      }
+      current[prop] = value;
+      try {
+        safeStorage.setItem(fullKey, serializeForStorage(rootObj, ttl, encryption));
+        return true;
+      } catch (error) {
+        console.error(`TypedProxy: Failed to save ${rootKey}`, error);
+        return true;
+      }
+    },
+    ownKeys() {
+      const current = getValueAtPath(
+        safeStorage,
+        prefix,
+        rootKey,
+        path,
+        ttl,
+        encryption
+      );
+      const keys = current ? Object.keys(current) : [];
+      if (defaultsAtRoot !== void 0) {
+        let defaultsAtPath = defaultsAtRoot;
+        for (const key of path) {
+          if (defaultsAtPath && typeof defaultsAtPath === "object") {
+            defaultsAtPath = defaultsAtPath[key];
+          } else {
+            defaultsAtPath = void 0;
+            break;
+          }
+        }
+        if (defaultsAtPath && typeof defaultsAtPath === "object") {
+          const defaultKeys = Object.keys(defaultsAtPath);
+          for (const key of defaultKeys) {
+            if (!keys.includes(key)) {
+              keys.push(key);
+            }
+          }
+        }
+      }
+      return keys;
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      if (typeof prop === "symbol") return void 0;
+      const current = getValueAtPath(
+        safeStorage,
+        prefix,
+        rootKey,
+        path,
+        ttl,
+        encryption
+      );
+      let defaultsAtPath;
+      if (defaultsAtRoot !== void 0) {
+        defaultsAtPath = defaultsAtRoot;
+        for (const key of path) {
+          if (defaultsAtPath && typeof defaultsAtPath === "object") {
+            defaultsAtPath = defaultsAtPath[key];
+          } else {
+            defaultsAtPath = void 0;
+            break;
+          }
+        }
+      }
+      const inCurrent = current && typeof current === "object" && prop in current;
+      const inDefaults = defaultsAtPath && typeof defaultsAtPath === "object" && prop in defaultsAtPath;
+      if (!inCurrent && !inDefaults) return void 0;
+      let value = current?.[prop];
+      if (defaultsAtPath && defaultsAtPath[prop] !== void 0) {
+        value = deepMerge(defaultsAtPath[prop], value);
+      }
+      const descriptorValue = value !== null && typeof value === "object" && !Array.isArray(value) ? createNestedProxy(
+        safeStorage,
+        prefix,
+        rootKey,
+        [...path, prop],
+        defaultsAtRoot,
+        ttl,
+        encryption
+      ) : value;
+      return {
+        value: descriptorValue,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      };
+    },
+    has(_target, prop) {
+      if (typeof prop === "symbol") return false;
+      const current = getValueAtPath(
+        safeStorage,
+        prefix,
+        rootKey,
+        path,
+        ttl,
+        encryption
+      );
+      if (current && typeof current === "object" && prop in current) {
+        return true;
+      }
+      if (defaultsAtRoot !== void 0) {
+        let defaultsAtPath = defaultsAtRoot;
+        for (const key of path) {
+          if (defaultsAtPath && typeof defaultsAtPath === "object") {
+            defaultsAtPath = defaultsAtPath[key];
+          } else {
+            defaultsAtPath = void 0;
+            break;
+          }
+        }
+        if (defaultsAtPath && typeof defaultsAtPath === "object" && prop in defaultsAtPath) {
+          return true;
+        }
+      }
+      return false;
+    }
+  });
+}
+function oto(options = {}) {
+  const { prefix = "", type = "local", defaults = {}, ttl, encryption } = options;
+  const storage = typeof window !== "undefined" ? type === "session" ? window.sessionStorage : window.localStorage : null;
+  const safeStorage = storage || {
+    getItem: () => null,
+    setItem: () => {
+    },
+    removeItem: () => {
+    },
+    clear: () => {
+    },
+    key: () => null,
+    get length() {
+      return 0;
+    }
+  };
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (prop === "clearAll") {
+        return () => {
+          const keys = [];
+          for (let i = 0; i < safeStorage.length; i++) {
+            const key = safeStorage.key(i);
+            if (key) keys.push(key);
+          }
+          keys.forEach((key) => {
+            if (key.startsWith(prefix)) safeStorage.removeItem(key);
+          });
+        };
+      }
+      const fullKey = `${prefix}${prop}`;
+      const storedValue = safeStorage.getItem(fullKey);
+      let parsed;
+      if (storedValue === null) {
+        parsed = void 0;
+      } else {
+        const readResult = readStoredValue(storedValue, ttl, encryption);
+        if (readResult.expired || readResult.decryptionError) {
+          safeStorage.removeItem(fullKey);
+          parsed = void 0;
+        } else {
+          maybeMigrate(safeStorage, fullKey, readResult, encryption);
+          parsed = readResult.value;
+        }
+      }
+      if (defaults && defaults[prop] !== void 0) {
+        parsed = deepMerge(defaults[prop], parsed);
+      }
+      if (parsed === void 0) return void 0;
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return createNestedProxy(
+          safeStorage,
+          prefix,
+          prop,
+          [],
+          defaults[prop],
+          ttl,
+          encryption
+        );
+      }
+      return parsed;
+    },
+    set(_target, prop, value) {
+      try {
+        safeStorage.setItem(`${prefix}${prop}`, serializeForStorage(value, ttl, encryption));
+        return true;
+      } catch (error) {
+        console.error(`TypedProxy: Failed to save ${prop}`, error);
+        return true;
+      }
+    },
+    has(_target, prop) {
+      if (defaults && prop in defaults) {
+        return true;
+      }
+      const fullKey = `${prefix}${prop}`;
+      const storedValue = safeStorage.getItem(fullKey);
+      if (storedValue === null) {
+        return false;
+      }
+      try {
+        const readResult = readStoredValue(storedValue, ttl, encryption);
+        if (readResult.expired || readResult.decryptionError) {
+          safeStorage.removeItem(fullKey);
+          return false;
+        }
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    deleteProperty(_target, prop) {
+      const key = `${prefix}${String(prop)}`;
+      safeStorage.removeItem(key);
+      return true;
+    }
+  });
+}
+var version = "0.4.2";
+export {
+  oto,
+  version
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oto-storage",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "A lightweight, type-safe wrapper for localStorage and sessionStorage using the Proxy API.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",