@vercube/storage 0.0.3 → 0.0.4

package/dist/index.d.mts

@@ -0,0 +1,275 @@
+import { IOC } from "@vercube/di";
+
+//#region src/Service/Storage.d.ts
+
+/**
+ * Abstract base class for storage implementations
+ * Provides a common interface for different storage providers
+ *
+ * @abstract
+ * @class Storage
+ * @description
+ * The Storage class defines a standard interface for storing and retrieving data.
+ * It supports basic operations like get, set, delete, and querying storage state.
+ * Concrete implementations must provide the actual storage mechanism.
+ */
+declare abstract class Storage {
+  /**
+   * Initializes the storage implementation
+   * Must be called before using any other storage operations
+   * @param {unknown} [options] - Optional initialization parameters
+   * @returns {Promise<void>} A promise that resolves when initialization is complete
+   */
+  abstract initialize(options?: unknown): void | Promise<void>;
+  /**
+   * Retrieves a value from storage by its key
+   * @template T - The type of the stored value
+   * @param {string} key - The key to retrieve the value for
+   * @returns {Promise<T>} A promise that resolves with the stored value
+   */
+  abstract getItem<T = unknown>(key: string): T | Promise<T>;
+  /**
+   * Stores a value in storage with the specified key
+   * @template T - The type of the value to store
+   * @template U - The type of the optional options object
+   * @param {string} key - The key under which to store the value
+   * @param {T} value - The value to store
+   * @returns {Promise<void>} A promise that resolves when the value is stored
+   */
+  abstract setItem<T = unknown, U = unknown>(key: string, value: T, options?: U): void | Promise<void>;
+  /**
+   * Removes a value from storage by its key
+   * @param {string} key - The key of the value to delete
+   * @returns {Promise<void>} A promise that resolves when the value is deleted
+   */
+  abstract deleteItem(key: string): void | Promise<void>;
+  /**
+   * Checks if a value exists in storage for the given key
+   * @param {string} key - The key to check
+   * @returns {Promise<boolean>} A promise that resolves to true if the key exists, false otherwise
+   */
+  abstract hasItem(key: string): boolean | Promise<boolean>;
+  /**
+   * Retrieves all keys currently stored in storage
+   * @returns {Promise<string[]>} A promise that resolves with an array of all stored keys
+   */
+  abstract getKeys(): string[] | Promise<string[]>;
+  /**
+   * Removes all stored values from storage
+   * @returns {Promise<void>} A promise that resolves when all values are cleared
+   */
+  abstract clear(): void | Promise<void>;
+  /**
+   * Gets the number of key-value pairs stored in storage
+   * @returns {Promise<number>} A promise that resolves with the number of stored items
+   */
+  abstract size(): number | Promise<number>;
+}
+//#endregion
+//#region src/Types/StorageTypes.d.ts
+declare namespace StorageTypes {
+  interface BaseOptions {
+    storage?: string;
+  }
+  interface Mount {
+    name?: string;
+    storage: IOC.Newable<Storage>;
+    initOptions?: unknown;
+  }
+  interface Storages<T = unknown> {
+    storage: Storage;
+    initOptions?: T;
+  }
+  interface GetItem extends BaseOptions {
+    key: string;
+  }
+  interface SetItem<T = unknown, U = unknown> extends BaseOptions {
+    key: string;
+    value: T;
+    options?: U;
+  }
+  interface DeleteItem extends BaseOptions {
+    key: string;
+  }
+  interface HasItem extends BaseOptions {
+    key: string;
+  }
+  interface GetKeys extends BaseOptions {}
+  interface Clear extends BaseOptions {}
+  interface Size extends BaseOptions {}
+}
+//#endregion
+//#region src/Service/StorageManager.d.ts
+/**
+ * Manages multiple storage instances and provides a unified interface for storage operations.
+ * Each storage instance is identified by a unique name and implements the Storage interface.
+ * This class handles initialization, registration, and delegation of storage operations.
+ */
+declare class StorageManager {
+  private gContainer;
+  private gLogger;
+  /**
+   * Map of registered storage instances indexed by their names
+   */
+  private fStorages;
+  /**
+   * Mounts a new storage instance with the specified name
+   * @param {StorageTypes.Mount} params - Mount parameters containing name and storage implementation
+   * @param {string} [params.name] - Optional name for the storage instance, defaults to 'default'
+   * @param {IOC.Newable<Storage>} params.storage - Storage implementation to mount
+   * @returns {Promise<void>} A promise that resolves when mounting is complete
+   */
+  mount({
+    name,
+    storage,
+    initOptions
+  }: StorageTypes.Mount): Promise<void>;
+  /**
+   * Retrieves a registered storage instance by name
+   * @param {string} name - Name of the storage instance to retrieve
+   * @returns {Storage | undefined} The storage instance if found, undefined otherwise
+   */
+  getStorage(name?: string): Storage | undefined;
+  /**
+   * Retrieves an item from the specified storage
+   * @template T - Type of the stored value
+   * @param {StorageTypes.GetItem} params - Parameters for retrieving an item
+   * @param {string} [params.storage] - Name of the storage to retrieve from, defaults to 'default'
+   * @param {string} params.key - Key of the item to retrieve
+   * @returns {Promise<T | null>} A promise that resolves with the stored value or null if not found
+   */
+  getItem<T = unknown>({
+    storage,
+    key
+  }: StorageTypes.GetItem): Promise<T | null>;
+  /**
+   * Stores an item in the specified storage
+   * @template T - Type of the value to store
+   * @param {StorageTypes.SetItem<T>} params - Parameters for storing an item
+   * @param {string} [params.storage] - Name of the storage to store in, defaults to 'default'
+   * @param {string} params.key - Key under which to store the value
+   * @param {T} params.value - Value to store
+   * @returns {Promise<void>} A promise that resolves when the value is stored
+   */
+  setItem<T = unknown, U = unknown>({
+    storage,
+    key,
+    value,
+    options
+  }: StorageTypes.SetItem<T, U>): Promise<void>;
+  /**
+   * Deletes an item from the specified storage
+   * @param {StorageTypes.DeleteItem} params - Parameters for deleting an item
+   * @param {string} [params.storage] - Name of the storage to delete from, defaults to 'default'
+   * @param {string} params.key - Key of the item to delete
+   * @returns {Promise<void>} A promise that resolves when the item is deleted
+   */
+  deleteItem({
+    storage,
+    key
+  }: StorageTypes.DeleteItem): Promise<void>;
+  /**
+   * Checks if an item exists in the specified storage
+   * @param {StorageTypes.HasItem} params - Parameters for checking item existence
+   * @param {string} [params.storage] - Name of the storage to check, defaults to 'default'
+   * @param {string} params.key - Key to check for
+   * @returns {Promise<boolean>} A promise that resolves to true if the item exists, false otherwise
+   */
+  hasItem({
+    storage,
+    key
+  }: StorageTypes.HasItem): Promise<boolean>;
+  /**
+   * Retrieves all keys from the specified storage
+   * @param {StorageTypes.GetKeys} params - Parameters for retrieving keys
+   * @param {string} [params.storage] - Name of the storage to get keys from, defaults to 'default'
+   * @returns {Promise<string[]>} A promise that resolves with an array of all keys
+   */
+  getKeys({
+    storage
+  }: StorageTypes.GetKeys): Promise<string[]>;
+  /**
+   * Clears all items from the specified storage
+   * @param {StorageTypes.Clear} params - Parameters for clearing storage
+   * @param {string} [params.storage] - Name of the storage to clear, defaults to 'default'
+   * @returns {Promise<void>} A promise that resolves when the storage is cleared
+   */
+  clear({
+    storage
+  }: StorageTypes.Clear): Promise<void>;
+  /**
+   * Gets the number of items in the specified storage
+   * @param {StorageTypes.Size} params - Parameters for getting storage size
+   * @param {string} [params.storage] - Name of the storage to get size of, defaults to 'default'
+   * @returns {Promise<number>} A promise that resolves with the number of items
+   */
+  size({
+    storage
+  }: StorageTypes.Size): Promise<number>;
+  /**
+   * Initializes all registered storage instances
+   * Called automatically with @Init() decorator
+   * @returns {Promise<void>} A promise that resolves when all storages are initialized
+   */
+  private init;
+}
+//#endregion
+//#region src/Storages/MemoryStorage.d.ts
+/**
+ * In-memory storage implementation of the Storage interface
+ * Provides a simple key-value store that persists only for the duration of the application runtime
+ * Useful for testing, caching, and scenarios where temporary storage is needed
+ *
+ * @implements {Storage}
+ */
+declare class MemoryStorage implements Storage {
+  /** Internal storage map to hold key-value pairs */
+  private storage;
+  /**
+   * Initializes the memory storage
+   * No initialization is needed for in-memory storage as the Map is created on instantiation
+   */
+  initialize(): void;
+  /**
+   * Retrieves a value from memory storage by its key
+   * @template T - Type of the stored value
+   * @param {string} key - The key to retrieve the value for
+   * @returns {T} The stored value cast to type T
+   */
+  getItem<T = unknown>(key: string): T;
+  /**
+   * Stores a value in memory storage with the specified key
+   * @template T - Type of the value to store
+   * @template U - Type of the options object
+   * @param {string} key - The key under which to store the value
+   * @param {T} value - The value to store
+   */
+  setItem<T = unknown, U = unknown>(key: string, value: T, options?: U): void;
+  /**
+   * Removes a value from memory storage by its key
+   * @param {string} key - The key of the value to delete
+   */
+  deleteItem(key: string): void;
+  /**
+   * Checks if a value exists in memory storage for the given key
+   * @param {string} key - The key to check
+   * @returns {boolean} True if the key exists, false otherwise
+   */
+  hasItem(key: string): boolean;
+  /**
+   * Retrieves all keys currently stored in memory storage
+   * @returns {string[]} Array of all stored keys
+   */
+  getKeys(): string[];
+  /**
+   * Removes all stored values from memory storage
+   */
+  clear(): void;
+  /**
+   * Gets the number of key-value pairs stored in memory storage
+   * @returns {number} The number of stored items
+   */
+  size(): number;
+}
+//#endregion
+export { MemoryStorage, Storage, StorageManager, StorageTypes };

package/dist/index.mjs

@@ -1,16 +1,47 @@
+import "node:module";
 import { Container, Init, Inject, InjectOptional } from "@vercube/di";
 import { Logger } from "@vercube/logger";
 
-//#region node_modules/.pnpm/@oxc-project+runtime@0.67.0/node_modules/@oxc-project/runtime/src/helpers/esm/decorate.js
-function __decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.72.1/node_modules/@oxc-project/runtime/src/helpers/decorate.js
+var require_decorate = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.1/node_modules/@oxc-project/runtime/src/helpers/decorate.js"(exports, module) {
+	function __decorate(decorators, target, key, desc) {
+		var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+		if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+		else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+		return c > 3 && r && Object.defineProperty(target, key, r), r;
+	}
+	module.exports = __decorate, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
 
 //#endregion
-//#region packages/storage/src/Service/StorageManager.ts
+//#region src/Service/StorageManager.ts
+var import_decorate = __toESM(require_decorate());
 /**
 * Manages multiple storage instances and provides a unified interface for storage operations.
 * Each storage instance is identified by a unique name and implements the Storage interface.
@@ -22,7 +53,7 @@ var StorageManager = class {
 	/**
 	* Map of registered storage instances indexed by their names
 	*/
-	fStorages = new Map();
+	fStorages = /* @__PURE__ */ new Map();
 	/**
 	* Mounts a new storage instance with the specified name
 	* @param {StorageTypes.Mount} params - Mount parameters containing name and storage implementation
@@ -134,12 +165,12 @@ var StorageManager = class {
 		}
 	}
 };
-__decorate([Inject(Container)], StorageManager.prototype, "gContainer", void 0);
-__decorate([InjectOptional(Logger)], StorageManager.prototype, "gLogger", void 0);
-__decorate([Init()], StorageManager.prototype, "init", null);
+(0, import_decorate.default)([Inject(Container)], StorageManager.prototype, "gContainer", void 0);
+(0, import_decorate.default)([InjectOptional(Logger)], StorageManager.prototype, "gLogger", void 0);
+(0, import_decorate.default)([Init()], StorageManager.prototype, "init", null);
 
 //#endregion
-//#region packages/storage/src/Service/Storage.ts
+//#region src/Service/Storage.ts
 /**
 * Abstract base class for storage implementations
 * Provides a common interface for different storage providers
@@ -154,7 +185,7 @@ __decorate([Init()], StorageManager.prototype, "init", null);
 var Storage = class {};
 
 //#endregion
-//#region packages/storage/src/Storages/MemoryStorage.ts
+//#region src/Storages/MemoryStorage.ts
 /**
 * In-memory storage implementation of the Storage interface
 * Provides a simple key-value store that persists only for the duration of the application runtime
@@ -164,7 +195,7 @@ var Storage = class {};
 */
 var MemoryStorage = class {
 	/** Internal storage map to hold key-value pairs */
-	storage = new Map();
+	storage = /* @__PURE__ */ new Map();
 	/**
 	* Initializes the memory storage
 	* No initialization is needed for in-memory storage as the Map is created on instantiation

package/package.json

@@ -1,28 +1,22 @@
 {
   "name": "@vercube/storage",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Storage module for Vercube framework",
   "repository": "@vercube/storage",
   "license": "MIT",
   "sideEffects": false,
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
-    }
+    ".": "./dist/index.mjs"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/index.d.mts",
   "files": [
     "dist",
     "README.md"
   ],
   "dependencies": {
-    "@vercube/logger": "0.0.3",
-    "@vercube/di": "0.0.3"
+    "@vercube/di": "0.0.4",
+    "@vercube/logger": "0.0.4"
   },
   "publishConfig": {
     "access": "public"

package/dist/Service/Storage.d.ts

@@ -1,66 +0,0 @@
-/**
-* Abstract base class for storage implementations
-* Provides a common interface for different storage providers
-* 
-* @abstract
-* @class Storage
-* @description
-* The Storage class defines a standard interface for storing and retrieving data.
-* It supports basic operations like get, set, delete, and querying storage state.
-* Concrete implementations must provide the actual storage mechanism.
-*/
-export declare abstract class Storage {
-	/**
-	* Initializes the storage implementation
-	* Must be called before using any other storage operations
-	* @param {unknown} [options] - Optional initialization parameters
-	* @returns {Promise<void>} A promise that resolves when initialization is complete
-	*/
-	abstract initialize(options?: unknown): void | Promise<void>;
-	/**
-	* Retrieves a value from storage by its key
-	* @template T - The type of the stored value
-	* @param {string} key - The key to retrieve the value for
-	* @returns {Promise<T>} A promise that resolves with the stored value
-	*/
-	abstract getItem<T = unknown>(key: string): T | Promise<T>;
-	/**
-	* Stores a value in storage with the specified key
-	* @template T - The type of the value to store
-	* @template U - The type of the optional options object
-	* @param {string} key - The key under which to store the value
-	* @param {T} value - The value to store
-	* @returns {Promise<void>} A promise that resolves when the value is stored
-	*/
-	abstract setItem<
-		T = unknown,
-		U = unknown
-	>(key: string, value: T, options?: U): void | Promise<void>;
-	/**
-	* Removes a value from storage by its key
-	* @param {string} key - The key of the value to delete
-	* @returns {Promise<void>} A promise that resolves when the value is deleted
-	*/
-	abstract deleteItem(key: string): void | Promise<void>;
-	/**
-	* Checks if a value exists in storage for the given key
-	* @param {string} key - The key to check
-	* @returns {Promise<boolean>} A promise that resolves to true if the key exists, false otherwise
-	*/
-	abstract hasItem(key: string): boolean | Promise<boolean>;
-	/**
-	* Retrieves all keys currently stored in storage
-	* @returns {Promise<string[]>} A promise that resolves with an array of all stored keys
-	*/
-	abstract getKeys(): string[] | Promise<string[]>;
-	/**
-	* Removes all stored values from storage
-	* @returns {Promise<void>} A promise that resolves when all values are cleared
-	*/
-	abstract clear(): void | Promise<void>;
-	/**
-	* Gets the number of key-value pairs stored in storage
-	* @returns {Promise<number>} A promise that resolves with the number of stored items
-	*/
-	abstract size(): number | Promise<number>;
-}

package/dist/Service/StorageManager.d.ts

@@ -1,94 +0,0 @@
-import { Storage } from "./Storage.js";
-import { StorageTypes } from "../Types/StorageTypes.js";
-/**
-* Manages multiple storage instances and provides a unified interface for storage operations.
-* Each storage instance is identified by a unique name and implements the Storage interface.
-* This class handles initialization, registration, and delegation of storage operations.
-*/
-export declare class StorageManager {
-	private gContainer;
-	private gLogger;
-	/**
-	* Map of registered storage instances indexed by their names
-	*/
-	private fStorages;
-	/**
-	* Mounts a new storage instance with the specified name
-	* @param {StorageTypes.Mount} params - Mount parameters containing name and storage implementation
-	* @param {string} [params.name] - Optional name for the storage instance, defaults to 'default'
-	* @param {IOC.Newable<Storage>} params.storage - Storage implementation to mount
-	* @returns {Promise<void>} A promise that resolves when mounting is complete
-	*/
-	mount({ name, storage, initOptions }: StorageTypes.Mount): Promise<void>;
-	/**
-	* Retrieves a registered storage instance by name
-	* @param {string} name - Name of the storage instance to retrieve
-	* @returns {Storage | undefined} The storage instance if found, undefined otherwise
-	*/
-	getStorage(name?: string): Storage | undefined;
-	/**
-	* Retrieves an item from the specified storage
-	* @template T - Type of the stored value
-	* @param {StorageTypes.GetItem} params - Parameters for retrieving an item
-	* @param {string} [params.storage] - Name of the storage to retrieve from, defaults to 'default'
-	* @param {string} params.key - Key of the item to retrieve
-	* @returns {Promise<T | null>} A promise that resolves with the stored value or null if not found
-	*/
-	getItem<T = unknown>({ storage, key }: StorageTypes.GetItem): Promise<T | null>;
-	/**
-	* Stores an item in the specified storage
-	* @template T - Type of the value to store
-	* @param {StorageTypes.SetItem<T>} params - Parameters for storing an item
-	* @param {string} [params.storage] - Name of the storage to store in, defaults to 'default'
-	* @param {string} params.key - Key under which to store the value
-	* @param {T} params.value - Value to store
-	* @returns {Promise<void>} A promise that resolves when the value is stored
-	*/
-	setItem<
-		T = unknown,
-		U = unknown
-	>({ storage, key, value, options }: StorageTypes.SetItem<T, U>): Promise<void>;
-	/**
-	* Deletes an item from the specified storage
-	* @param {StorageTypes.DeleteItem} params - Parameters for deleting an item
-	* @param {string} [params.storage] - Name of the storage to delete from, defaults to 'default'
-	* @param {string} params.key - Key of the item to delete
-	* @returns {Promise<void>} A promise that resolves when the item is deleted
-	*/
-	deleteItem({ storage, key }: StorageTypes.DeleteItem): Promise<void>;
-	/**
-	* Checks if an item exists in the specified storage
-	* @param {StorageTypes.HasItem} params - Parameters for checking item existence
-	* @param {string} [params.storage] - Name of the storage to check, defaults to 'default'
-	* @param {string} params.key - Key to check for
-	* @returns {Promise<boolean>} A promise that resolves to true if the item exists, false otherwise
-	*/
-	hasItem({ storage, key }: StorageTypes.HasItem): Promise<boolean>;
-	/**
-	* Retrieves all keys from the specified storage
-	* @param {StorageTypes.GetKeys} params - Parameters for retrieving keys
-	* @param {string} [params.storage] - Name of the storage to get keys from, defaults to 'default'
-	* @returns {Promise<string[]>} A promise that resolves with an array of all keys
-	*/
-	getKeys({ storage }: StorageTypes.GetKeys): Promise<string[]>;
-	/**
-	* Clears all items from the specified storage
-	* @param {StorageTypes.Clear} params - Parameters for clearing storage
-	* @param {string} [params.storage] - Name of the storage to clear, defaults to 'default'
-	* @returns {Promise<void>} A promise that resolves when the storage is cleared
-	*/
-	clear({ storage }: StorageTypes.Clear): Promise<void>;
-	/**
-	* Gets the number of items in the specified storage
-	* @param {StorageTypes.Size} params - Parameters for getting storage size
-	* @param {string} [params.storage] - Name of the storage to get size of, defaults to 'default'
-	* @returns {Promise<number>} A promise that resolves with the number of items
-	*/
-	size({ storage }: StorageTypes.Size): Promise<number>;
-	/**
-	* Initializes all registered storage instances
-	* Called automatically with @Init() decorator
-	* @returns {Promise<void>} A promise that resolves when all storages are initialized
-	*/
-	private init;
-}

package/dist/Storages/MemoryStorage.d.ts

@@ -1,60 +0,0 @@
-import { Storage } from "../Service/Storage.js";
-/**
-* In-memory storage implementation of the Storage interface
-* Provides a simple key-value store that persists only for the duration of the application runtime
-* Useful for testing, caching, and scenarios where temporary storage is needed
-* 
-* @implements {Storage}
-*/
-export declare class MemoryStorage implements Storage {
-	/** Internal storage map to hold key-value pairs */
-	private storage;
-	/**
-	* Initializes the memory storage
-	* No initialization is needed for in-memory storage as the Map is created on instantiation
-	*/
-	initialize(): void;
-	/**
-	* Retrieves a value from memory storage by its key
-	* @template T - Type of the stored value
-	* @param {string} key - The key to retrieve the value for
-	* @returns {T} The stored value cast to type T
-	*/
-	getItem<T = unknown>(key: string): T;
-	/**
-	* Stores a value in memory storage with the specified key
-	* @template T - Type of the value to store
-	* @template U - Type of the options object
-	* @param {string} key - The key under which to store the value
-	* @param {T} value - The value to store
-	*/
-	setItem<
-		T = unknown,
-		U = unknown
-	>(key: string, value: T, options?: U): void;
-	/**
-	* Removes a value from memory storage by its key
-	* @param {string} key - The key of the value to delete
-	*/
-	deleteItem(key: string): void;
-	/**
-	* Checks if a value exists in memory storage for the given key
-	* @param {string} key - The key to check
-	* @returns {boolean} True if the key exists, false otherwise
-	*/
-	hasItem(key: string): boolean;
-	/**
-	* Retrieves all keys currently stored in memory storage
-	* @returns {string[]} Array of all stored keys
-	*/
-	getKeys(): string[];
-	/**
-	* Removes all stored values from memory storage
-	*/
-	clear(): void;
-	/**
-	* Gets the number of key-value pairs stored in memory storage
-	* @returns {number} The number of stored items
-	*/
-	size(): number;
-}

package/dist/Types/StorageTypes.d.ts

@@ -1,36 +0,0 @@
-import type { IOC } from "@vercube/di";
-import { Storage } from "../Service/Storage.js";
-export declare namespace StorageTypes {
-	interface BaseOptions {
-		storage?: string;
-	}
-	interface Mount {
-		name?: string;
-		storage: IOC.Newable<Storage>;
-		initOptions?: unknown;
-	}
-	interface Storages<T = unknown> {
-		storage: Storage;
-		initOptions?: T;
-	}
-	interface GetItem extends BaseOptions {
-		key: string;
-	}
-	interface SetItem<
-		T = unknown,
-		U = unknown
-	> extends BaseOptions {
-		key: string;
-		value: T;
-		options?: U;
-	}
-	interface DeleteItem extends BaseOptions {
-		key: string;
-	}
-	interface HasItem extends BaseOptions {
-		key: string;
-	}
-	interface GetKeys extends BaseOptions {}
-	interface Clear extends BaseOptions {}
-	interface Size extends BaseOptions {}
-}

package/dist/index.cjs

@@ -1,262 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-const __vercube_di = __toESM(require("@vercube/di"));
-const __vercube_logger = __toESM(require("@vercube/logger"));
-
-//#region node_modules/.pnpm/@oxc-project+runtime@0.67.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
-var require_decorate = __commonJS({ "node_modules/.pnpm/@oxc-project+runtime@0.67.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js"(exports, module) {
-	function __decorate(decorators, target, key, desc) {
-		var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-		if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-		else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-		return c > 3 && r && Object.defineProperty(target, key, r), r;
-	}
-	module.exports = __decorate, module.exports.__esModule = true, module.exports["default"] = module.exports;
-} });
-var import_decorate = __toESM(require_decorate(), 1);
-
-//#endregion
-//#region packages/storage/src/Service/StorageManager.ts
-/**
-* Manages multiple storage instances and provides a unified interface for storage operations.
-* Each storage instance is identified by a unique name and implements the Storage interface.
-* This class handles initialization, registration, and delegation of storage operations.
-*/
-var StorageManager = class {
-	gContainer;
-	gLogger;
-	/**
-	* Map of registered storage instances indexed by their names
-	*/
-	fStorages = new Map();
-	/**
-	* Mounts a new storage instance with the specified name
-	* @param {StorageTypes.Mount} params - Mount parameters containing name and storage implementation
-	* @param {string} [params.name] - Optional name for the storage instance, defaults to 'default'
-	* @param {IOC.Newable<Storage>} params.storage - Storage implementation to mount
-	* @returns {Promise<void>} A promise that resolves when mounting is complete
-	*/
-	async mount({ name, storage, initOptions }) {
-		this.fStorages.set(name ?? "default", {
-			storage: this.gContainer.resolve(storage),
-			initOptions
-		});
-	}
-	/**
-	* Retrieves a registered storage instance by name
-	* @param {string} name - Name of the storage instance to retrieve
-	* @returns {Storage | undefined} The storage instance if found, undefined otherwise
-	*/
-	getStorage(name = "default") {
-		return this.fStorages.get(name)?.storage ?? void 0;
-	}
-	/**
-	* Retrieves an item from the specified storage
-	* @template T - Type of the stored value
-	* @param {StorageTypes.GetItem} params - Parameters for retrieving an item
-	* @param {string} [params.storage] - Name of the storage to retrieve from, defaults to 'default'
-	* @param {string} params.key - Key of the item to retrieve
-	* @returns {Promise<T | null>} A promise that resolves with the stored value or null if not found
-	*/
-	async getItem({ storage, key }) {
-		const storageInstance = this.getStorage(storage);
-		return storageInstance?.getItem(key) ?? null;
-	}
-	/**
-	* Stores an item in the specified storage
-	* @template T - Type of the value to store
-	* @param {StorageTypes.SetItem<T>} params - Parameters for storing an item
-	* @param {string} [params.storage] - Name of the storage to store in, defaults to 'default'
-	* @param {string} params.key - Key under which to store the value
-	* @param {T} params.value - Value to store
-	* @returns {Promise<void>} A promise that resolves when the value is stored
-	*/
-	async setItem({ storage, key, value, options }) {
-		const storageInstance = this.getStorage(storage);
-		storageInstance?.setItem(key, value, options);
-	}
-	/**
-	* Deletes an item from the specified storage
-	* @param {StorageTypes.DeleteItem} params - Parameters for deleting an item
-	* @param {string} [params.storage] - Name of the storage to delete from, defaults to 'default'
-	* @param {string} params.key - Key of the item to delete
-	* @returns {Promise<void>} A promise that resolves when the item is deleted
-	*/
-	async deleteItem({ storage, key }) {
-		const storageInstance = this.getStorage(storage);
-		storageInstance?.deleteItem(key);
-	}
-	/**
-	* Checks if an item exists in the specified storage
-	* @param {StorageTypes.HasItem} params - Parameters for checking item existence
-	* @param {string} [params.storage] - Name of the storage to check, defaults to 'default'
-	* @param {string} params.key - Key to check for
-	* @returns {Promise<boolean>} A promise that resolves to true if the item exists, false otherwise
-	*/
-	async hasItem({ storage, key }) {
-		const storageInstance = this.getStorage(storage);
-		return storageInstance?.hasItem(key) ?? false;
-	}
-	/**
-	* Retrieves all keys from the specified storage
-	* @param {StorageTypes.GetKeys} params - Parameters for retrieving keys
-	* @param {string} [params.storage] - Name of the storage to get keys from, defaults to 'default'
-	* @returns {Promise<string[]>} A promise that resolves with an array of all keys
-	*/
-	async getKeys({ storage }) {
-		const storageInstance = this.getStorage(storage);
-		return storageInstance?.getKeys() ?? [];
-	}
-	/**
-	* Clears all items from the specified storage
-	* @param {StorageTypes.Clear} params - Parameters for clearing storage
-	* @param {string} [params.storage] - Name of the storage to clear, defaults to 'default'
-	* @returns {Promise<void>} A promise that resolves when the storage is cleared
-	*/
-	async clear({ storage }) {
-		const storageInstance = this.getStorage(storage);
-		storageInstance?.clear();
-	}
-	/**
-	* Gets the number of items in the specified storage
-	* @param {StorageTypes.Size} params - Parameters for getting storage size
-	* @param {string} [params.storage] - Name of the storage to get size of, defaults to 'default'
-	* @returns {Promise<number>} A promise that resolves with the number of items
-	*/
-	async size({ storage }) {
-		const storageInstance = this.getStorage(storage);
-		return storageInstance?.size() ?? 0;
-	}
-	/**
-	* Initializes all registered storage instances
-	* Called automatically with @Init() decorator
-	* @returns {Promise<void>} A promise that resolves when all storages are initialized
-	*/
-	async init() {
-		for (const { storage, initOptions } of this.fStorages.values()) try {
-			await storage?.initialize(initOptions);
-		} catch (error) {
-			this.gLogger?.error("Vercube/StorageManager::init", error);
-		}
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_di.Container)], StorageManager.prototype, "gContainer", void 0);
-(0, import_decorate.default)([(0, __vercube_di.InjectOptional)(__vercube_logger.Logger)], StorageManager.prototype, "gLogger", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Init)()], StorageManager.prototype, "init", null);
-
-//#endregion
-//#region packages/storage/src/Service/Storage.ts
-/**
-* Abstract base class for storage implementations
-* Provides a common interface for different storage providers
-* 
-* @abstract
-* @class Storage
-* @description
-* The Storage class defines a standard interface for storing and retrieving data.
-* It supports basic operations like get, set, delete, and querying storage state.
-* Concrete implementations must provide the actual storage mechanism.
-*/
-var Storage = class {};
-
-//#endregion
-//#region packages/storage/src/Storages/MemoryStorage.ts
-/**
-* In-memory storage implementation of the Storage interface
-* Provides a simple key-value store that persists only for the duration of the application runtime
-* Useful for testing, caching, and scenarios where temporary storage is needed
-* 
-* @implements {Storage}
-*/
-var MemoryStorage = class {
-	/** Internal storage map to hold key-value pairs */
-	storage = new Map();
-	/**
-	* Initializes the memory storage
-	* No initialization is needed for in-memory storage as the Map is created on instantiation
-	*/
-	initialize() {}
-	/**
-	* Retrieves a value from memory storage by its key
-	* @template T - Type of the stored value
-	* @param {string} key - The key to retrieve the value for
-	* @returns {T} The stored value cast to type T
-	*/
-	getItem(key) {
-		return this.storage.get(key);
-	}
-	/**
-	* Stores a value in memory storage with the specified key
-	* @template T - Type of the value to store
-	* @template U - Type of the options object
-	* @param {string} key - The key under which to store the value
-	* @param {T} value - The value to store
-	*/
-	setItem(key, value, options) {
-		this.storage.set(key, value);
-	}
-	/**
-	* Removes a value from memory storage by its key
-	* @param {string} key - The key of the value to delete
-	*/
-	deleteItem(key) {
-		this.storage.delete(key);
-	}
-	/**
-	* Checks if a value exists in memory storage for the given key
-	* @param {string} key - The key to check
-	* @returns {boolean} True if the key exists, false otherwise
-	*/
-	hasItem(key) {
-		return this.storage.has(key);
-	}
-	/**
-	* Retrieves all keys currently stored in memory storage
-	* @returns {string[]} Array of all stored keys
-	*/
-	getKeys() {
-		return [...this.storage.keys()];
-	}
-	/**
-	* Removes all stored values from memory storage
-	*/
-	clear() {
-		this.storage.clear();
-	}
-	/**
-	* Gets the number of key-value pairs stored in memory storage
-	* @returns {number} The number of stored items
-	*/
-	size() {
-		return this.storage.size;
-	}
-};
-
-//#endregion
-exports.MemoryStorage = MemoryStorage
-exports.Storage = Storage
-exports.StorageManager = StorageManager

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./Service/StorageManager.js";
-export * from "./Service/Storage.js";
-export * from "./Storages/MemoryStorage.js";
-export * from "./Types/StorageTypes.js";