@abdokouta/react-support 1.1.0

package/dist/index.js

@@ -0,0 +1,2418 @@
+"use strict";
+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 __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseRegistry: () => BaseRegistry,
+  Collection: () => Collection,
+  Facade: () => Facade,
+  MapCollection: () => MapCollection,
+  SetCollection: () => SetCollection,
+  Str: () => Str,
+  collect: () => collect,
+  collectMap: () => collectMap,
+  collectSet: () => collectSet,
+  createFacade: () => createFacade,
+  createFacadeClass: () => createFacadeClass,
+  getContainerFromModule: () => getContainerFromModule,
+  isFake: () => isFake
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/str/str.ts
+var Str = class _Str {
+  /**
+   * Return the remainder of a string after the first occurrence of a given value
+   */
+  static after(subject, search) {
+    if (search === "") return subject;
+    const index = subject.indexOf(search);
+    return index === -1 ? subject : subject.substring(index + search.length);
+  }
+  /**
+   * Return the remainder of a string after the last occurrence of a given value
+   */
+  static afterLast(subject, search) {
+    if (search === "") return subject;
+    const index = subject.lastIndexOf(search);
+    return index === -1 ? subject : subject.substring(index + search.length);
+  }
+  /**
+   * Convert a string to title case following APA guidelines
+   */
+  static apa(value) {
+    const minorWords = ["a", "an", "and", "as", "at", "but", "by", "for", "in", "of", "on", "or", "the", "to", "up"];
+    const words = value.split(" ");
+    return words.map((word, index) => {
+      if (index === 0 || !minorWords.includes(word.toLowerCase())) {
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+      }
+      return word.toLowerCase();
+    }).join(" ");
+  }
+  /**
+   * Transliterate a UTF-8 value to ASCII
+   */
+  static ascii(value) {
+    return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+  }
+  /**
+   * Get the portion of a string before the first occurrence of a given value
+   */
+  static before(subject, search) {
+    if (search === "") return subject;
+    const index = subject.indexOf(search);
+    return index === -1 ? subject : subject.substring(0, index);
+  }
+  /**
+   * Get the portion of a string before the last occurrence of a given value
+   */
+  static beforeLast(subject, search) {
+    if (search === "") return subject;
+    const index = subject.lastIndexOf(search);
+    return index === -1 ? subject : subject.substring(0, index);
+  }
+  /**
+   * Get the portion of a string between two values
+   */
+  static between(subject, from, to) {
+    if (from === "" || to === "") return subject;
+    const startIndex = subject.indexOf(from);
+    if (startIndex === -1) return "";
+    const start = startIndex + from.length;
+    const endIndex = subject.indexOf(to, start);
+    return endIndex === -1 ? "" : subject.substring(start, endIndex);
+  }
+  /**
+   * Get the smallest possible portion of a string between two values
+   */
+  static betweenFirst(subject, from, to) {
+    return _Str.between(subject, from, to);
+  }
+  /**
+   * Convert a string to camelCase
+   */
+  static camel(value) {
+    return value.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^(.)/, (char) => char.toLowerCase());
+  }
+  /**
+   * Get the character at the specified index
+   */
+  static charAt(subject, index) {
+    if (index < 0 || index >= subject.length) return false;
+    return subject.charAt(index);
+  }
+  /**
+   * Remove the first occurrence of the given value from the start of the string
+   */
+  static chopStart(subject, search) {
+    const searches = Array.isArray(search) ? search : [search];
+    for (const s of searches) {
+      if (subject.startsWith(s)) {
+        return subject.substring(s.length);
+      }
+    }
+    return subject;
+  }
+  /**
+   * Remove the last occurrence of the given value from the end of the string
+   */
+  static chopEnd(subject, search) {
+    const searches = Array.isArray(search) ? search : [search];
+    for (const s of searches) {
+      if (subject.endsWith(s)) {
+        return subject.substring(0, subject.length - s.length);
+      }
+    }
+    return subject;
+  }
+  /**
+   * Determine if a given string contains a given substring
+   */
+  static contains(haystack, needles, ignoreCase = false) {
+    const needleArray = Array.isArray(needles) ? needles : [needles];
+    const subject = ignoreCase ? haystack.toLowerCase() : haystack;
+    return needleArray.some((needle) => {
+      const search = ignoreCase ? needle.toLowerCase() : needle;
+      return subject.includes(search);
+    });
+  }
+  /**
+   * Determine if a given string contains all array values
+   */
+  static containsAll(haystack, needles, ignoreCase = false) {
+    const subject = ignoreCase ? haystack.toLowerCase() : haystack;
+    return needles.every((needle) => {
+      const search = ignoreCase ? needle.toLowerCase() : needle;
+      return subject.includes(search);
+    });
+  }
+  /**
+   * Determine if a given string doesn't contain a given substring
+   */
+  static doesntContain(haystack, needles, ignoreCase = false) {
+    return !_Str.contains(haystack, needles, ignoreCase);
+  }
+  /**
+   * Replace consecutive instances of a character with a single instance
+   */
+  static deduplicate(value, character = " ") {
+    const escaped = character.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`${escaped}+`, "g");
+    return value.replace(regex, character);
+  }
+  /**
+   * Determine if a given string ends with a given substring
+   */
+  static endsWith(haystack, needles) {
+    const needleArray = Array.isArray(needles) ? needles : [needles];
+    return needleArray.some((needle) => haystack.endsWith(needle));
+  }
+  /**
+   * Extract an excerpt from text that matches the first instance of a phrase
+   */
+  static excerpt(text, phrase, options = {}) {
+    const radius = options.radius ?? 100;
+    const omission = options.omission ?? "...";
+    const index = text.indexOf(phrase);
+    if (index === -1) return "";
+    const start = Math.max(0, index - radius);
+    const end = Math.min(text.length, index + phrase.length + radius);
+    let excerpt = text.substring(start, end);
+    if (start > 0) excerpt = omission + excerpt;
+    if (end < text.length) excerpt = excerpt + omission;
+    return excerpt;
+  }
+  /**
+   * Cap a string with a single instance of a given value
+   */
+  static finish(value, cap) {
+    return value.endsWith(cap) ? value : value + cap;
+  }
+  /**
+   * Convert a string to headline case
+   */
+  static headline(value) {
+    return value.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[-_]/g, " ").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+  }
+  /**
+   * Determine if a given string matches a given pattern
+   */
+  static is(pattern, value, ignoreCase = false) {
+    const regexPattern = pattern.replace(/\*/g, ".*");
+    const flags = ignoreCase ? "i" : "";
+    const regex = new RegExp(`^${regexPattern}$`, flags);
+    return regex.test(value);
+  }
+  /**
+   * Determine if a given string is 7-bit ASCII
+   */
+  static isAscii(value) {
+    return /^[\x00-\x7F]*$/.test(value);
+  }
+  /**
+   * Determine if a given string is valid JSON
+   */
+  static isJson(value) {
+    try {
+      JSON.parse(value);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Determine if a given string is a valid URL
+   */
+  static isUrl(value, protocols) {
+    try {
+      if (typeof URL === "undefined") {
+        const urlPattern = /^https?:\/\/.+/i;
+        return urlPattern.test(value);
+      }
+      const urlObj = new URL(value);
+      if (protocols) {
+        return protocols.includes(urlObj.protocol.replace(":", ""));
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Determine if a given string is a valid ULID
+   */
+  static isUlid(value) {
+    return /^[0-9A-HJKMNP-TV-Z]{26}$/i.test(value);
+  }
+  /**
+   * Determine if a given string is a valid UUID
+   */
+  static isUuid(value) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+  }
+  /**
+   * Convert a string to kebab-case
+   */
+  static kebab(value) {
+    return value.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+  }
+  /**
+   * Return the given string with the first character lowercased
+   */
+  static lcfirst(value) {
+    return value.charAt(0).toLowerCase() + value.slice(1);
+  }
+  /**
+   * Return the length of the given string
+   */
+  static len(value) {
+    return value.length;
+  }
+  /**
+   * Limit the number of characters in a string
+   */
+  static limit(value, limit = 100, end = "...", preserveWords = false) {
+    if (value.length <= limit) return value;
+    let truncated = value.substring(0, limit);
+    if (preserveWords) {
+      const lastSpace = truncated.lastIndexOf(" ");
+      if (lastSpace > 0) {
+        truncated = truncated.substring(0, lastSpace);
+      }
+    }
+    return truncated + end;
+  }
+  /**
+   * Convert the given string to lowercase
+   */
+  static lower(value) {
+    return value.toLowerCase();
+  }
+  /**
+   * Masks a portion of a string with a repeated character
+   */
+  static mask(value, character, index, length) {
+    if (index < 0) {
+      index = value.length + index;
+    }
+    const maskLength = length ?? value.length - index;
+    const mask = character.repeat(Math.abs(maskLength));
+    return value.substring(0, index) + mask + value.substring(index + Math.abs(maskLength));
+  }
+  /**
+   * Pad both sides of a string with another
+   */
+  static padBoth(value, length, pad = " ") {
+    const totalPadding = length - value.length;
+    if (totalPadding <= 0) return value;
+    const leftPadding = Math.floor(totalPadding / 2);
+    const rightPadding = totalPadding - leftPadding;
+    return pad.repeat(leftPadding) + value + pad.repeat(rightPadding);
+  }
+  /**
+   * Pad the left side of a string with another
+   */
+  static padLeft(value, length, pad = " ") {
+    return value.padStart(length, pad);
+  }
+  /**
+   * Pad the right side of a string with another
+   */
+  static padRight(value, length, pad = " ") {
+    return value.padEnd(length, pad);
+  }
+  /**
+   * Get the plural form of an English word
+   */
+  static plural(value, count = 2) {
+    if (count === 1) return value;
+    if (value.endsWith("y") && !/[aeiou]y$/i.test(value)) {
+      return value.slice(0, -1) + "ies";
+    }
+    if (value.endsWith("s") || value.endsWith("x") || value.endsWith("z") || value.endsWith("ch") || value.endsWith("sh")) {
+      return value + "es";
+    }
+    return value + "s";
+  }
+  /**
+   * Pluralize the last word of an English, studly caps case string
+   */
+  static pluralStudly(value, count = 2) {
+    const parts = value.match(/[A-Z][a-z]*/g) || [value];
+    const lastWord = parts[parts.length - 1];
+    const pluralized = _Str.plural(lastWord, count);
+    parts[parts.length - 1] = pluralized;
+    return parts.join("");
+  }
+  /**
+   * Find the position of the first occurrence of a substring
+   */
+  static position(haystack, needle) {
+    const pos = haystack.indexOf(needle);
+    return pos === -1 ? false : pos;
+  }
+  /**
+   * Generate a random string
+   */
+  static random(length = 16) {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  }
+  /**
+   * Remove the given value from the string
+   */
+  static remove(search, subject, caseSensitive = true) {
+    const searches = Array.isArray(search) ? search : [search];
+    let result = subject;
+    searches.forEach((s) => {
+      const flags = caseSensitive ? "g" : "gi";
+      const escaped = s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      result = result.replace(new RegExp(escaped, flags), "");
+    });
+    return result;
+  }
+  /**
+   * Repeat the given string
+   */
+  static repeat(value, times) {
+    return value.repeat(times);
+  }
+  /**
+   * Replace the given value in the given string
+   */
+  static replace(search, replace, subject, caseSensitive = true) {
+    const flags = caseSensitive ? "g" : "gi";
+    const escaped = search.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return subject.replace(new RegExp(escaped, flags), replace);
+  }
+  /**
+   * Replace a given value in the string sequentially with an array
+   */
+  static replaceArray(search, replacements, subject) {
+    let result = subject;
+    let index = 0;
+    while (result.includes(search) && index < replacements.length) {
+      result = result.replace(search, replacements[index]);
+      index++;
+    }
+    return result;
+  }
+  /**
+   * Replace the first occurrence of a given value in the string
+   */
+  static replaceFirst(search, replace, subject) {
+    return subject.replace(search, replace);
+  }
+  /**
+   * Replace the last occurrence of a given value in the string
+   */
+  static replaceLast(search, replace, subject) {
+    const index = subject.lastIndexOf(search);
+    if (index === -1) return subject;
+    return subject.substring(0, index) + replace + subject.substring(index + search.length);
+  }
+  /**
+   * Replace the first occurrence only if it appears at the start
+   */
+  static replaceStart(search, replace, subject) {
+    return subject.startsWith(search) ? replace + subject.substring(search.length) : subject;
+  }
+  /**
+   * Replace the last occurrence only if it appears at the end
+   */
+  static replaceEnd(search, replace, subject) {
+    return subject.endsWith(search) ? subject.substring(0, subject.length - search.length) + replace : subject;
+  }
+  /**
+   * Reverse the given string
+   */
+  static reverse(value) {
+    return value.split("").reverse().join("");
+  }
+  /**
+   * Get the singular form of an English word
+   */
+  static singular(value) {
+    if (value.endsWith("ies")) {
+      return value.slice(0, -3) + "y";
+    }
+    if (value.endsWith("es")) {
+      return value.slice(0, -2);
+    }
+    if (value.endsWith("s") && !value.endsWith("ss")) {
+      return value.slice(0, -1);
+    }
+    return value;
+  }
+  /**
+   * Generate a URL friendly slug
+   */
+  static slug(value, separator = "-") {
+    return value.toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, separator).replace(new RegExp(`${separator}+`, "g"), separator).replace(new RegExp(`^${separator}|${separator}$`, "g"), "");
+  }
+  /**
+   * Convert a string to snake_case
+   */
+  static snake(value, delimiter = "_") {
+    return value.replace(/([a-z])([A-Z])/g, `$1${delimiter}$2`).replace(/[\s-]+/g, delimiter).toLowerCase();
+  }
+  /**
+   * Remove all extraneous whitespace
+   */
+  static squish(value) {
+    return value.trim().replace(/\s+/g, " ");
+  }
+  /**
+   * Begin a string with a single instance of a given value
+   */
+  static start(value, prefix) {
+    return value.startsWith(prefix) ? value : prefix + value;
+  }
+  /**
+   * Determine if a given string starts with a given substring
+   */
+  static startsWith(haystack, needles) {
+    const needleArray = Array.isArray(needles) ? needles : [needles];
+    return needleArray.some((needle) => haystack.startsWith(needle));
+  }
+  /**
+   * Convert a value to studly caps case
+   */
+  static studly(value) {
+    return value.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^(.)/, (char) => char.toUpperCase());
+  }
+  /**
+   * Returns the portion of string specified by the start and length parameters
+   */
+  static substr(value, start, length) {
+    return value.substr(start, length);
+  }
+  /**
+   * Returns the number of substring occurrences
+   */
+  static substrCount(haystack, needle) {
+    return (haystack.match(new RegExp(needle, "g")) || []).length;
+  }
+  /**
+   * Replace text within a portion of a string
+   */
+  static substrReplace(value, replace, start, length) {
+    const actualLength = length ?? value.length - start;
+    return value.substring(0, start) + replace + value.substring(start + actualLength);
+  }
+  /**
+   * Swap multiple keywords in a string with other keywords
+   */
+  static swap(map, subject) {
+    let result = subject;
+    Object.entries(map).forEach(([search, replace]) => {
+      result = _Str.replace(search, replace, result);
+    });
+    return result;
+  }
+  /**
+   * Take the first or last {limit} characters
+   */
+  static take(value, limit) {
+    if (limit < 0) {
+      return value.slice(limit);
+    }
+    return value.slice(0, limit);
+  }
+  /**
+   * Convert the given string to title case
+   */
+  static title(value) {
+    return value.toLowerCase().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  }
+  /**
+   * Convert the given string to Base64
+   */
+  static toBase64(value) {
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(value).toString("base64");
+    }
+    if (typeof btoa !== "undefined") {
+      return btoa(value);
+    }
+    throw new Error("Base64 encoding not supported in this environment");
+  }
+  /**
+   * Transliterate a string to its closest ASCII representation
+   */
+  static transliterate(value) {
+    return _Str.ascii(value);
+  }
+  /**
+   * Trim whitespace from both ends of the string
+   */
+  static trim(value, characters) {
+    if (!characters) return value.trim();
+    const escaped = characters.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return value.replace(new RegExp(`^[${escaped}]+|[${escaped}]+$`, "g"), "");
+  }
+  /**
+   * Trim whitespace from the beginning of the string
+   */
+  static ltrim(value, characters) {
+    if (!characters) return value.trimStart();
+    const escaped = characters.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return value.replace(new RegExp(`^[${escaped}]+`, "g"), "");
+  }
+  /**
+   * Trim whitespace from the end of the string
+   */
+  static rtrim(value, characters) {
+    if (!characters) return value.trimEnd();
+    const escaped = characters.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return value.replace(new RegExp(`[${escaped}]+$`, "g"), "");
+  }
+  /**
+   * Make a string's first character uppercase
+   */
+  static ucfirst(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+  }
+  /**
+   * Split a string by uppercase characters
+   */
+  static ucsplit(value) {
+    return value.match(/[A-Z][a-z]*/g) || [value];
+  }
+  /**
+   * Convert the given string to uppercase
+   */
+  static upper(value) {
+    return value.toUpperCase();
+  }
+  /**
+   * Remove the specified strings from the beginning and end
+   */
+  static unwrap(value, before, after) {
+    const actualAfter = after ?? before;
+    let result = value;
+    if (result.startsWith(before)) {
+      result = result.substring(before.length);
+    }
+    if (result.endsWith(actualAfter)) {
+      result = result.substring(0, result.length - actualAfter.length);
+    }
+    return result;
+  }
+  /**
+   * Get the number of words a string contains
+   */
+  static wordCount(value) {
+    return value.trim().split(/\s+/).filter((word) => word.length > 0).length;
+  }
+  /**
+   * Wrap a string to a given number of characters
+   */
+  static wordWrap(value, characters = 75, breakStr = "\n") {
+    const words = value.split(" ");
+    let line = "";
+    const lines = [];
+    words.forEach((word) => {
+      if ((line + word).length > characters) {
+        if (line) lines.push(line.trim());
+        line = word + " ";
+      } else {
+        line += word + " ";
+      }
+    });
+    if (line) lines.push(line.trim());
+    return lines.join(breakStr);
+  }
+  /**
+   * Limit the number of words in a string
+   */
+  static words(value, words = 100, end = "...") {
+    const wordArray = value.split(/\s+/);
+    if (wordArray.length <= words) return value;
+    return wordArray.slice(0, words).join(" ") + end;
+  }
+  /**
+   * Wrap the string with the given strings
+   */
+  static wrap(value, before, after) {
+    const actualAfter = after ?? before;
+    return before + value + actualAfter;
+  }
+};
+
+// src/collections/collection.ts
+var import_collect = __toESM(require("collect.js"), 1);
+var Collection = class _Collection {
+  constructor(items = []) {
+    this.collection = (0, import_collect.default)(items);
+  }
+  /**
+   * Create a new collection instance
+   */
+  static make(items = []) {
+    return new _Collection(items);
+  }
+  /**
+   * Get all items in the collection
+   */
+  all() {
+    return this.collection.all();
+  }
+  /**
+   * Get the average value of a given key
+   */
+  avg(key) {
+    return this.collection.avg(key);
+  }
+  /**
+   * Chunk the collection into chunks of the given size
+   */
+  chunk(size) {
+    return new _Collection(this.collection.chunk(size).all());
+  }
+  /**
+   * Collapse a collection of arrays into a single, flat collection
+   */
+  collapse() {
+    return new _Collection(this.collection.collapse().all());
+  }
+  /**
+   * Determine if an item exists in the collection
+   */
+  contains(key, value) {
+    return this.collection.contains(key, value);
+  }
+  /**
+   * Get the total number of items in the collection
+   */
+  count() {
+    return this.collection.count();
+  }
+  /**
+   * Get the items in the collection that are not present in the given items
+   */
+  diff(items) {
+    return new _Collection(this.collection.diff(items).all());
+  }
+  /**
+   * Execute a callback over each item
+   */
+  each(callback) {
+    this.collection.each(callback);
+    return this;
+  }
+  /**
+   * Determine if all items pass the given test
+   */
+  every(callback) {
+    return this.collection.every(callback);
+  }
+  /**
+   * Get all items except for those with the specified keys
+   */
+  except(keys) {
+    return new _Collection(this.collection.except(keys).all());
+  }
+  /**
+   * Run a filter over each of the items
+   */
+  filter(callback) {
+    return new _Collection(this.collection.filter(callback).all());
+  }
+  /**
+   * Get the first item from the collection
+   */
+  first(callback) {
+    return this.collection.first(callback);
+  }
+  /**
+   * Get a flattened array of the items in the collection
+   */
+  flatten(depth) {
+    return new _Collection(this.collection.flatten(depth).all());
+  }
+  /**
+   * Flip the items in the collection
+   */
+  flip() {
+    return new _Collection(this.collection.flip().all());
+  }
+  /**
+   * Remove an item from the collection by key
+   */
+  forget(key) {
+    this.collection.forget(key);
+    return this;
+  }
+  /**
+   * Get an item from the collection by key
+   */
+  get(key, defaultValue) {
+    const result = this.collection.get(key, defaultValue);
+    return result === null ? void 0 : result;
+  }
+  /**
+   * Group the collection's items by a given key
+   */
+  groupBy(key) {
+    const grouped = this.collection.groupBy(key);
+    const result = {};
+    grouped.each((items, groupKey) => {
+      result[groupKey] = new _Collection(items.all());
+    });
+    return new _Collection(Object.values(result));
+  }
+  /**
+   * Determine if a given key exists in the collection
+   */
+  has(key) {
+    return this.collection.has(key);
+  }
+  /**
+   * Concatenate values of a given key as a string
+   */
+  implode(key, glue) {
+    return this.collection.implode(key, glue);
+  }
+  /**
+   * Intersect the collection with the given items
+   */
+  intersect(items) {
+    return new _Collection(this.collection.intersect(items).all());
+  }
+  /**
+   * Determine if the collection is empty
+   */
+  isEmpty() {
+    return this.collection.isEmpty();
+  }
+  /**
+   * Determine if the collection is not empty
+   */
+  isNotEmpty() {
+    return this.collection.isNotEmpty();
+  }
+  /**
+   * Join all items from the collection using a string
+   */
+  join(glue, finalGlue) {
+    return this.collection.join(glue, finalGlue);
+  }
+  /**
+   * Key the collection by the given key
+   */
+  keyBy(key) {
+    return new _Collection(this.collection.keyBy(key).all());
+  }
+  /**
+   * Get the keys of the collection items
+   */
+  keys() {
+    return new _Collection(this.collection.keys().all());
+  }
+  /**
+   * Get the last item from the collection
+   */
+  last(callback) {
+    return this.collection.last(callback);
+  }
+  /**
+   * Run a map over each of the items
+   */
+  map(callback) {
+    return new _Collection(this.collection.map(callback).all());
+  }
+  /**
+   * Get the max value of a given key
+   */
+  max(key) {
+    return this.collection.max(key);
+  }
+  /**
+   * Merge the collection with the given items
+   */
+  merge(items) {
+    return new _Collection(this.collection.merge(items).all());
+  }
+  /**
+   * Get the min value of a given key
+   */
+  min(key) {
+    return this.collection.min(key);
+  }
+  /**
+   * Get the items with the specified keys
+   */
+  only(keys) {
+    return new _Collection(this.collection.only(keys).all());
+  }
+  /**
+   * Get and remove the last item from the collection
+   */
+  pop() {
+    return this.collection.pop();
+  }
+  /**
+   * Push an item onto the beginning of the collection
+   */
+  prepend(value) {
+    this.collection.prepend(value);
+    return this;
+  }
+  /**
+   * Get and remove an item from the collection
+   */
+  pull(key) {
+    const result = this.collection.pull(key);
+    return result === null ? void 0 : result;
+  }
+  /**
+   * Push an item onto the end of the collection
+   */
+  push(value) {
+    this.collection.push(value);
+    return this;
+  }
+  /**
+   * Put an item in the collection by key
+   */
+  put(key, value) {
+    this.collection.put(key, value);
+    return this;
+  }
+  /**
+   * Get one or a specified number of items randomly from the collection
+   */
+  random(count) {
+    if (count) {
+      const result = this.collection.random(count);
+      return new _Collection(result.all());
+    }
+    return this.collection.random();
+  }
+  /**
+   * Reduce the collection to a single value
+   */
+  reduce(callback, initial) {
+    return this.collection.reduce(callback, initial);
+  }
+  /**
+   * Filter items by the given key value pair
+   */
+  reject(callback) {
+    return new _Collection(this.collection.reject(callback).all());
+  }
+  /**
+   * Reverse items order
+   */
+  reverse() {
+    return new _Collection(this.collection.reverse().all());
+  }
+  /**
+   * Search the collection for a given value
+   */
+  search(value) {
+    const result = this.collection.search(value);
+    return result === false ? false : result;
+  }
+  /**
+   * Get and remove the first item from the collection
+   */
+  shift() {
+    return this.collection.shift();
+  }
+  /**
+   * Shuffle the items in the collection
+   */
+  shuffle() {
+    return new _Collection(this.collection.shuffle().all());
+  }
+  /**
+   * Slice the underlying collection array
+   */
+  slice(start, length) {
+    return new _Collection(this.collection.slice(start, length).all());
+  }
+  /**
+   * Sort through each item with a callback
+   */
+  sort(callback) {
+    return new _Collection(this.collection.sort(callback).all());
+  }
+  /**
+   * Sort the collection by the given key
+   */
+  sortBy(key) {
+    return new _Collection(this.collection.sortBy(key).all());
+  }
+  /**
+   * Sort the collection in descending order by the given key
+   */
+  sortByDesc(key) {
+    return new _Collection(this.collection.sortByDesc(key).all());
+  }
+  /**
+   * Splice a portion of the underlying collection array
+   */
+  splice(start, length, ...items) {
+    const actualLength = length ?? 0;
+    const itemsArray = items;
+    return new _Collection(this.collection.splice(start, actualLength, ...itemsArray).all());
+  }
+  /**
+   * Get the sum of the given values
+   */
+  sum(key) {
+    const result = this.collection.sum(key);
+    return typeof result === "number" ? result : 0;
+  }
+  /**
+   * Take the first or last {limit} items
+   */
+  take(limit) {
+    return new _Collection(this.collection.take(limit).all());
+  }
+  /**
+   * Pass the collection to the given callback and return the result
+   */
+  pipe(callback) {
+    return callback(this);
+  }
+  /**
+   * Pass the collection to the given callback and then return it
+   */
+  tap(callback) {
+    callback(this);
+    return this;
+  }
+  /**
+   * Transform each item in the collection using a callback
+   */
+  transform(callback) {
+    this.collection = this.collection.map(callback);
+    return this;
+  }
+  /**
+   * Return only unique items from the collection array
+   */
+  unique(key) {
+    return new _Collection(this.collection.unique(key).all());
+  }
+  /**
+   * Reset the keys on the underlying array
+   */
+  values() {
+    return new _Collection(this.collection.values().all());
+  }
+  where(key, operatorOrValue, value) {
+    if (value === void 0) {
+      return new _Collection(this.collection.where(key, operatorOrValue).all());
+    }
+    return new _Collection(this.collection.where(key, operatorOrValue, value).all());
+  }
+  /**
+   * Filter items by the given key value pair using loose comparison
+   */
+  whereIn(key, values) {
+    return new _Collection(this.collection.whereIn(key, values).all());
+  }
+  /**
+   * Filter items by the given key value pair using loose comparison
+   */
+  whereNotIn(key, values) {
+    return new _Collection(this.collection.whereNotIn(key, values).all());
+  }
+  /**
+   * Zip the collection together with one or more arrays
+   */
+  zip(...arrays) {
+    const zipArgs = arrays;
+    return new _Collection(this.collection.zip(...zipArgs).all());
+  }
+  /**
+   * Convert the collection to a plain array
+   */
+  toArray() {
+    return this.all();
+  }
+  /**
+   * Convert the collection to JSON
+   */
+  toJson() {
+    return JSON.stringify(this.all());
+  }
+  /**
+   * Get the collection as a string
+   */
+  toString() {
+    return this.toJson();
+  }
+};
+function collect(items = []) {
+  return new Collection(items);
+}
+
+// src/collections/map.collection.ts
+var MapCollection = class _MapCollection {
+  constructor(entries) {
+    if (entries && typeof entries === "object" && !(Symbol.iterator in entries)) {
+      this.internalMap = new Map(Object.entries(entries));
+    } else {
+      this.internalMap = new Map(entries);
+    }
+  }
+  /**
+   * Create a new map collection instance
+   */
+  static make(entries) {
+    return new _MapCollection(entries);
+  }
+  /**
+   * Get all entries as an array of [key, value] pairs
+   */
+  all() {
+    return Array.from(this.internalMap.entries());
+  }
+  /**
+   * Get the number of items in the map
+   */
+  count() {
+    return this.internalMap.size;
+  }
+  /**
+   * Get the number of items in the map (alias for count)
+   */
+  size() {
+    return this.internalMap.size;
+  }
+  /**
+   * Determine if the map is empty
+   */
+  isEmpty() {
+    return this.internalMap.size === 0;
+  }
+  /**
+   * Determine if the map is not empty
+   */
+  isNotEmpty() {
+    return this.internalMap.size > 0;
+  }
+  /**
+   * Determine if a key exists in the map
+   */
+  has(key) {
+    return this.internalMap.has(key);
+  }
+  /**
+   * Get a value from the map by key
+   */
+  get(key, defaultValue) {
+    return this.internalMap.has(key) ? this.internalMap.get(key) : defaultValue;
+  }
+  /**
+   * Set a value in the map
+   */
+  set(key, value) {
+    this.internalMap.set(key, value);
+    return this;
+  }
+  /**
+   * Put a value in the map (alias for set)
+   */
+  put(key, value) {
+    return this.set(key, value);
+  }
+  /**
+   * Remove a key from the map
+   */
+  delete(key) {
+    return this.internalMap.delete(key);
+  }
+  /**
+   * Remove a key from the map (alias for delete)
+   */
+  forget(key) {
+    return this.delete(key);
+  }
+  /**
+   * Remove all items from the map
+   */
+  clear() {
+    this.internalMap.clear();
+    return this;
+  }
+  /**
+   * Get all keys from the map
+   */
+  keys() {
+    return Array.from(this.internalMap.keys());
+  }
+  /**
+   * Get all values from the map
+   */
+  values() {
+    return Array.from(this.internalMap.values());
+  }
+  /**
+   * Execute a callback over each item
+   */
+  each(callback) {
+    for (const [key, value] of this.internalMap) {
+      if (callback(value, key) === false) {
+        break;
+      }
+    }
+    return this;
+  }
+  /**
+   * Run a map over each of the items
+   */
+  mapValues(callback) {
+    const result = /* @__PURE__ */ new Map();
+    this.internalMap.forEach((value, key) => {
+      result.set(key, callback(value, key));
+    });
+    return new _MapCollection(result);
+  }
+  /**
+   * Run a filter over each of the items
+   */
+  filter(callback) {
+    const result = /* @__PURE__ */ new Map();
+    this.internalMap.forEach((value, key) => {
+      if (callback(value, key)) {
+        result.set(key, value);
+      }
+    });
+    return new _MapCollection(result);
+  }
+  /**
+   * Determine if all items pass the given test
+   */
+  every(callback) {
+    for (const [key, value] of this.internalMap) {
+      if (!callback(value, key)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Determine if any item passes the given test
+   */
+  some(callback) {
+    for (const [key, value] of this.internalMap) {
+      if (callback(value, key)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get the first value that passes the given test
+   */
+  first(callback) {
+    if (!callback) {
+      return this.internalMap.values().next().value;
+    }
+    for (const [key, value] of this.internalMap) {
+      if (callback(value, key)) {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get the last value that passes the given test
+   */
+  last(callback) {
+    const entries = Array.from(this.internalMap.entries()).reverse();
+    if (!callback) {
+      return entries[0]?.[1];
+    }
+    for (const [key, value] of entries) {
+      if (callback(value, key)) {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Reduce the map to a single value
+   */
+  reduce(callback, initial) {
+    let carry = initial;
+    this.internalMap.forEach((value, key) => {
+      carry = callback(carry, value, key);
+    });
+    return carry;
+  }
+  /**
+   * Merge another map into this one
+   */
+  merge(other) {
+    if (other instanceof _MapCollection) {
+      other.each((value, key) => {
+        this.set(key, value);
+        return void 0;
+      });
+    } else if (other instanceof Map) {
+      other.forEach((value, key) => this.set(key, value));
+    } else {
+      Object.entries(other).forEach(([key, value]) => {
+        this.set(key, value);
+      });
+    }
+    return this;
+  }
+  /**
+   * Get only the specified keys
+   */
+  only(keys) {
+    const result = /* @__PURE__ */ new Map();
+    keys.forEach((key) => {
+      if (this.internalMap.has(key)) {
+        result.set(key, this.internalMap.get(key));
+      }
+    });
+    return new _MapCollection(result);
+  }
+  /**
+   * Get all items except the specified keys
+   */
+  except(keys) {
+    const result = /* @__PURE__ */ new Map();
+    this.internalMap.forEach((value, key) => {
+      if (!keys.includes(key)) {
+        result.set(key, value);
+      }
+    });
+    return new _MapCollection(result);
+  }
+  /**
+   * Flip the keys and values
+   */
+  flip() {
+    const result = /* @__PURE__ */ new Map();
+    this.internalMap.forEach((value, key) => {
+      result.set(value, key);
+    });
+    return new _MapCollection(result);
+  }
+  /**
+   * Pass the map to the given callback and return the result
+   */
+  pipe(callback) {
+    return callback(this);
+  }
+  /**
+   * Pass the map to the given callback and then return it
+   */
+  tap(callback) {
+    callback(this);
+    return this;
+  }
+  /**
+   * Convert the map to a plain object
+   */
+  toObject() {
+    const obj = {};
+    this.internalMap.forEach((value, key) => {
+      obj[String(key)] = value;
+    });
+    return obj;
+  }
+  /**
+   * Convert the map to an array of [key, value] pairs
+   */
+  toArray() {
+    return this.all();
+  }
+  /**
+   * Convert the map to JSON
+   */
+  toJson() {
+    return JSON.stringify(this.toObject());
+  }
+  /**
+   * Get the map as a string
+   */
+  toString() {
+    return this.toJson();
+  }
+  /**
+   * Get the underlying Map instance
+   */
+  toMap() {
+    return new Map(this.internalMap);
+  }
+};
+function collectMap(entries) {
+  return new MapCollection(entries);
+}
+
+// src/collections/set.collection.ts
+var SetCollection = class _SetCollection {
+  constructor(items) {
+    this.set = new Set(items);
+  }
+  /**
+   * Create a new set collection instance
+   */
+  static make(items) {
+    return new _SetCollection(items);
+  }
+  /**
+   * Get all items as an array
+   */
+  all() {
+    return Array.from(this.set);
+  }
+  /**
+   * Get the number of items in the set
+   */
+  count() {
+    return this.set.size;
+  }
+  /**
+   * Get the number of items in the set (alias for count)
+   */
+  size() {
+    return this.set.size;
+  }
+  /**
+   * Determine if the set is empty
+   */
+  isEmpty() {
+    return this.set.size === 0;
+  }
+  /**
+   * Determine if the set is not empty
+   */
+  isNotEmpty() {
+    return this.set.size > 0;
+  }
+  /**
+   * Determine if an item exists in the set
+   */
+  has(item) {
+    return this.set.has(item);
+  }
+  /**
+   * Determine if an item exists in the set (alias for has)
+   */
+  contains(item) {
+    return this.has(item);
+  }
+  /**
+   * Add an item to the set
+   */
+  add(item) {
+    this.set.add(item);
+    return this;
+  }
+  /**
+   * Add an item to the set (alias for add)
+   */
+  push(item) {
+    return this.add(item);
+  }
+  /**
+   * Remove an item from the set
+   */
+  delete(item) {
+    return this.set.delete(item);
+  }
+  /**
+   * Remove an item from the set (alias for delete)
+   */
+  forget(item) {
+    return this.delete(item);
+  }
+  /**
+   * Remove all items from the set
+   */
+  clear() {
+    this.set.clear();
+    return this;
+  }
+  /**
+   * Execute a callback over each item
+   */
+  each(callback) {
+    let index = 0;
+    for (const item of this.set) {
+      if (callback(item, index++) === false) {
+        break;
+      }
+    }
+    return this;
+  }
+  /**
+   * Run a map over each of the items
+   */
+  map(callback) {
+    const result = /* @__PURE__ */ new Set();
+    let index = 0;
+    this.set.forEach((item) => {
+      result.add(callback(item, index++));
+    });
+    return new _SetCollection(result);
+  }
+  /**
+   * Run a filter over each of the items
+   */
+  filter(callback) {
+    const result = /* @__PURE__ */ new Set();
+    let index = 0;
+    this.set.forEach((item) => {
+      if (callback(item, index++)) {
+        result.add(item);
+      }
+    });
+    return new _SetCollection(result);
+  }
+  /**
+   * Determine if all items pass the given test
+   */
+  every(callback) {
+    let index = 0;
+    for (const item of this.set) {
+      if (!callback(item, index++)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Determine if any item passes the given test
+   */
+  some(callback) {
+    let index = 0;
+    for (const item of this.set) {
+      if (callback(item, index++)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get the first item that passes the given test
+   */
+  first(callback) {
+    if (!callback) {
+      return this.set.values().next().value;
+    }
+    let index = 0;
+    for (const item of this.set) {
+      if (callback(item, index++)) {
+        return item;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get the last item that passes the given test
+   */
+  last(callback) {
+    const items = Array.from(this.set).reverse();
+    if (!callback) {
+      return items[0];
+    }
+    for (let i = 0; i < items.length; i++) {
+      if (callback(items[i], i)) {
+        return items[i];
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Reduce the set to a single value
+   */
+  reduce(callback, initial) {
+    let carry = initial;
+    let index = 0;
+    this.set.forEach((item) => {
+      carry = callback(carry, item, index++);
+    });
+    return carry;
+  }
+  /**
+   * Merge another set into this one
+   */
+  merge(other) {
+    if (other instanceof _SetCollection) {
+      other.each((item) => {
+        this.add(item);
+        return void 0;
+      });
+    } else if (other instanceof Set) {
+      other.forEach((item) => this.add(item));
+    } else {
+      other.forEach((item) => this.add(item));
+    }
+    return this;
+  }
+  /**
+   * Get the union of this set and another
+   */
+  union(other) {
+    const result = new _SetCollection(this.set);
+    return result.merge(other);
+  }
+  /**
+   * Get the intersection of this set and another
+   */
+  intersect(other) {
+    const otherSet = other instanceof _SetCollection ? other.toSet() : other instanceof Set ? other : new Set(other);
+    const result = /* @__PURE__ */ new Set();
+    this.set.forEach((item) => {
+      if (otherSet.has(item)) {
+        result.add(item);
+      }
+    });
+    return new _SetCollection(result);
+  }
+  /**
+   * Get the difference between this set and another
+   */
+  diff(other) {
+    const otherSet = other instanceof _SetCollection ? other.toSet() : other instanceof Set ? other : new Set(other);
+    const result = /* @__PURE__ */ new Set();
+    this.set.forEach((item) => {
+      if (!otherSet.has(item)) {
+        result.add(item);
+      }
+    });
+    return new _SetCollection(result);
+  }
+  /**
+   * Get items that are in either set but not in both
+   */
+  symmetricDiff(other) {
+    const otherSet = other instanceof _SetCollection ? other.toSet() : other instanceof Set ? other : new Set(other);
+    const result = /* @__PURE__ */ new Set();
+    this.set.forEach((item) => {
+      if (!otherSet.has(item)) {
+        result.add(item);
+      }
+    });
+    otherSet.forEach((item) => {
+      if (!this.set.has(item)) {
+        result.add(item);
+      }
+    });
+    return new _SetCollection(result);
+  }
+  /**
+   * Determine if this set is a subset of another
+   */
+  isSubsetOf(other) {
+    const otherSet = other instanceof _SetCollection ? other.toSet() : other instanceof Set ? other : new Set(other);
+    for (const item of this.set) {
+      if (!otherSet.has(item)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Determine if this set is a superset of another
+   */
+  isSupersetOf(other) {
+    const otherSet = other instanceof _SetCollection ? other.toSet() : other instanceof Set ? other : new Set(other);
+    for (const item of otherSet) {
+      if (!this.set.has(item)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Pass the set to the given callback and return the result
+   */
+  pipe(callback) {
+    return callback(this);
+  }
+  /**
+   * Pass the set to the given callback and then return it
+   */
+  tap(callback) {
+    callback(this);
+    return this;
+  }
+  /**
+   * Convert the set to an array
+   */
+  toArray() {
+    return this.all();
+  }
+  /**
+   * Convert the set to JSON
+   */
+  toJson() {
+    return JSON.stringify(this.all());
+  }
+  /**
+   * Get the set as a string
+   */
+  toString() {
+    return this.toJson();
+  }
+  /**
+   * Get the underlying Set instance
+   */
+  toSet() {
+    return new Set(this.set);
+  }
+};
+function collectSet(items) {
+  return new SetCollection(items);
+}
+
+// src/registry/base-registry.ts
+var RegistryCollection = class {
+  constructor() {
+    this._storage = new MapCollection();
+  }
+  add(key, value) {
+    this._storage.set(key, value);
+  }
+  get(key) {
+    return this._storage.get(key);
+  }
+  getAll() {
+    return this._storage.values();
+  }
+  getKeys() {
+    return this._storage.keys();
+  }
+  getAsRecord() {
+    return this._storage.toObject();
+  }
+  has(key) {
+    return this._storage.has(key);
+  }
+  remove(key) {
+    return this._storage.delete(key);
+  }
+  clear() {
+    this._storage.clear();
+  }
+  size() {
+    return this._storage.size();
+  }
+  isEmpty() {
+    return this._storage.isEmpty();
+  }
+  forEach(callback) {
+    this._storage.each((value, key) => {
+      callback(value, key);
+    });
+  }
+  map(callback) {
+    const result = [];
+    this._storage.each((value, key) => {
+      result.push(callback(value, key));
+    });
+    return result;
+  }
+  filter(predicate) {
+    const result = [];
+    this._storage.each((value, key) => {
+      if (predicate(value, key)) {
+        result.push(value);
+      }
+    });
+    return result;
+  }
+  find(predicate) {
+    return this._storage.first(predicate);
+  }
+};
+var BaseRegistry = class {
+  /**
+   * Creates a new BaseRegistry instance
+   * 
+   * Initializes the registry with optional configuration for default
+   * item and validation hooks. By default, uses MapCollection for storage.
+   * 
+   * @param options - Registry configuration options
+   * 
+   * @example
+   * ```typescript
+   * // Simple registry without options
+   * const registry = new BaseRegistry<Theme>();
+   * ```
+   * 
+   * @example
+   * ```typescript
+   * // Registry with default item
+   * const registry = new BaseRegistry<Theme>({
+   *   defaultItem: defaultTheme
+   * });
+   * ```
+   * 
+   * @example
+   * ```typescript
+   * // Registry with validation
+   * const registry = new BaseRegistry<Theme>({
+   *   validateBeforeAdd: (key, theme) => {
+   *     if (!theme.name) {
+   *       return { valid: false, error: 'Theme must have a name' };
+   *     }
+   *     return { valid: true };
+   *   },
+   *   afterAdd: (key, theme) => {
+   *     console.log(`Registered theme: ${theme.name}`);
+   *   }
+   * });
+   * ```
+   */
+  constructor(options = {}) {
+    this.collection = new RegistryCollection();
+    this.defaultItem = options.defaultItem;
+    this.validateBeforeAdd = options.validateBeforeAdd;
+    this.afterAdd = options.afterAdd;
+  }
+  /**
+   * Register an item in the registry
+   * 
+   * Adds or updates an item in the registry with the specified key.
+   * If an item with the same key already exists, it will be replaced.
+   * 
+   * If a validation hook is configured, it will be called before adding
+   * the item. If validation fails, an error is thrown and the item is
+   * not added.
+   * 
+   * If an afterAdd hook is configured, it will be called after the item
+   * is successfully added.
+   * 
+   * Time Complexity: O(1) + validation time
+   * 
+   * @param key - Unique identifier for the item
+   * @param item - Item to register
+   * @throws Error if validation fails
+   * 
+   * @example
+   * ```typescript
+   * const registry = new BaseRegistry<Theme>();
+   * 
+   * // Register a theme
+   * registry.register('blue', {
+   *   name: 'Blue',
+   *   colors: { accent: '#0000FF' }
+   * });
+   * 
+   * // Update existing theme
+   * registry.register('blue', {
+   *   name: 'Blue',
+   *   colors: { accent: '#0066FF' }
+   * });
+   * ```
+   */
+  register(key, item) {
+    if (this.validateBeforeAdd) {
+      const result = this.validateBeforeAdd(key, item);
+      if (!result.valid) {
+        throw new Error(
+          `Validation failed for key "${key}": ${result.error || "Unknown error"}`
+        );
+      }
+    }
+    this.collection.add(key, item);
+    if (this.afterAdd) {
+      this.afterAdd(key, item);
+    }
+  }
+  // ============================================================================
+  // Collection Interface Implementation
+  // All methods below delegate directly to the internal collection
+  // ============================================================================
+  /**
+   * Add an item to the collection (alias for register)
+   * 
+   * This method is part of the Collection interface.
+   * It delegates to register() to ensure validation hooks are called.
+   * 
+   * Time Complexity: O(1) + validation time
+   * 
+   * @param key - Unique identifier for the item
+   * @param value - Item to add
+   */
+  add(key, value) {
+    this.register(key, value);
+  }
+  /**
+   * Get an item from the registry
+   * 
+   * Retrieves an item by its key. If the item doesn't exist:
+   * - Returns the default item if one was configured
+   * - Returns undefined if no default item was configured
+   * 
+   * Time Complexity: O(1)
+   * 
+   * @param key - Item identifier
+   * @returns Item if found, default item if configured, or undefined
+   * 
+   * @example
+   * ```typescript
+   * const theme = registry.get('blue');
+   * ```
+   */
+  get(key) {
+    const item = this.collection.get(key);
+    if (item !== void 0) {
+      return item;
+    }
+    return this.defaultItem;
+  }
+  /**
+   * Get all items in the registry
+   * 
+   * Returns an array containing all items in the registry.
+   * The order of items depends on the collection implementation
+   * (MapCollection maintains insertion order).
+   * 
+   * Time Complexity: O(n) where n is the number of items
+   * 
+   * @returns Array of all items in the registry
+   * 
+   * @example
+   * ```typescript
+   * const allThemes = registry.getAll();
+   * ```
+   */
+  getAll() {
+    return this.collection.getAll();
+  }
+  /**
+   * Get all keys in the registry
+   * 
+   * Returns an array containing all keys in the registry.
+   * Useful for iteration or checking what items are registered.
+   * 
+   * Time Complexity: O(n) where n is the number of items
+   * 
+   * @returns Array of all keys in the registry
+   * 
+   * @example
+   * ```typescript
+   * const keys = registry.getKeys();
+   * ```
+   */
+  getKeys() {
+    return this.collection.getKeys();
+  }
+  /**
+   * Get registry as a record object
+   * 
+   * Converts the registry to a plain JavaScript object (record)
+   * with keys mapping to values. Useful for serialization.
+   * 
+   * Time Complexity: O(n) where n is the number of items
+   * 
+   * @returns Record object with keys mapping to values
+   * 
+   * @example
+   * ```typescript
+   * const record = registry.getAsRecord();
+   * ```
+   */
+  getAsRecord() {
+    return this.collection.getAsRecord();
+  }
+  /**
+   * Check if an item is registered
+   * 
+   * Checks whether an item with the specified key exists in the registry.
+   * Does not check the value, only the presence of the key.
+   * 
+   * Time Complexity: O(1)
+   * 
+   * @param key - Item identifier to check
+   * @returns True if item is registered, false otherwise
+   * 
+   * @example
+   * ```typescript
+   * if (registry.has('blue')) {
+   *   console.log('Blue theme exists');
+   * }
+   * ```
+   */
+  has(key) {
+    return this.collection.has(key);
+  }
+  /**
+   * Remove an item from the registry
+   * 
+   * Removes an item with the specified key from the registry.
+   * Returns true if the item was removed, false if it didn't exist.
+   * 
+   * Time Complexity: O(1)
+   * 
+   * @param key - Item identifier to remove
+   * @returns True if item was removed, false if it didn't exist
+   * 
+   * @example
+   * ```typescript
+   * const removed = registry.remove('blue');
+   * ```
+   */
+  remove(key) {
+    return this.collection.remove(key);
+  }
+  /**
+   * Clear all items from the registry
+   * 
+   * Removes all items from the registry, leaving it empty.
+   * This operation is irreversible.
+   * 
+   * Time Complexity: O(1)
+   * 
+   * @example
+   * ```typescript
+   * registry.clear();
+   * ```
+   */
+  clear() {
+    this.collection.clear();
+  }
+  /**
+   * Get the number of items in the registry
+   * 
+   * Returns the total count of items currently registered.
+   * 
+   * Time Complexity: O(1)
+   * 
+   * @returns Number of items in the registry
+   * 
+   * @example
+   * ```typescript
+   * console.log(registry.size()); // 2
+   * ```
+   */
+  size() {
+    return this.collection.size();
+  }
+  /**
+   * Check if the registry is empty
+   * 
+   * Returns true if the registry contains no items, false otherwise.
+   * This is a convenience method equivalent to checking if size() === 0.
+   * 
+   * Time Complexity: O(1)
+   * 
+   * @returns True if registry has no items, false otherwise
+   * 
+   * @example
+   * ```typescript
+   * console.log(registry.isEmpty()); // true
+   * ```
+   */
+  isEmpty() {
+    return this.collection.isEmpty();
+  }
+  /**
+   * Iterate over all items in the registry
+   * 
+   * Executes a callback function for each item in the registry.
+   * Items are iterated in insertion order (for MapCollection).
+   * 
+   * Time Complexity: O(n) where n is the number of items
+   * 
+   * @param callback - Function to call for each item (value, key)
+   * 
+   * @example
+   * ```typescript
+   * registry.forEach((theme, key) => {
+   *   console.log(`${key}: ${theme.name}`);
+   * });
+   * ```
+   */
+  forEach(callback) {
+    this.collection.forEach(callback);
+  }
+  /**
+   * Map over all items in the registry
+   * 
+   * Transforms each item in the registry using a callback function
+   * and returns an array of the transformed values.
+   * 
+   * Time Complexity: O(n) where n is the number of items
+   * 
+   * @template U - The type of the transformed items
+   * @param callback - Function to transform each item (value, key) => U
+   * @returns Array of transformed items
+   * 
+   * @example
+   * ```typescript
+   * const names = registry.map(theme => theme.name);
+   * ```
+   */
+  map(callback) {
+    return this.collection.map(callback);
+  }
+  /**
+   * Filter items in the registry
+   * 
+   * Returns an array of items that pass the test implemented by the
+   * provided predicate function.
+   * 
+   * Time Complexity: O(n) where n is the number of items
+   * 
+   * @param predicate - Function to test each item (value, key) => boolean
+   * @returns Array of items that pass the test
+   * 
+   * @example
+   * ```typescript
+   * const darkThemes = registry.filter(theme => theme.isDark);
+   * ```
+   */
+  filter(predicate) {
+    return this.collection.filter(predicate);
+  }
+  /**
+   * Find an item in the registry
+   * 
+   * Returns the first item that satisfies the provided predicate function.
+   * Returns undefined if no item passes the test.
+   * 
+   * Time Complexity: O(n) worst case, O(1) best case
+   * 
+   * @param predicate - Function to test each item (value, key) => boolean
+   * @returns First item that passes the test, or undefined
+   * 
+   * @example
+   * ```typescript
+   * const defaultTheme = registry.find(theme => theme.isDefault);
+   * ```
+   */
+  find(predicate) {
+    return this.collection.find(predicate);
+  }
+};
+
+// src/facades/facade.ts
+var import_react_di = require("@abdokouta/react-di");
+
+// src/facades/facade.interface.ts
+function isFake(obj) {
+  return typeof obj === "object" && obj !== null && "__isFake" in obj && obj.__isFake === true;
+}
+
+// src/facades/facade.ts
+var Facade = class {
+  /**
+   * Hotswap the underlying instance behind the facade
+   *
+   * Useful for testing - swap the real service with a mock or fake.
+   *
+   * @param instance - Instance to swap in
+   *
+   * @example
+   * ```typescript
+   * // In tests
+   * const mockLogger = { info: vi.fn(), error: vi.fn() };
+   * Log.swap(mockLogger);
+   *
+   * // Now Log.info() calls mockLogger.info()
+   * Log.info('test');
+   * expect(mockLogger.info).toHaveBeenCalledWith('test');
+   * ```
+   */
+  static swap(instance) {
+    const accessor = this.getFacadeAccessor();
+    const key = this.getAccessorKey(accessor);
+    this.resolvedInstance.set(key, instance);
+  }
+  /**
+   * Determines whether a "fake" has been set as the facade instance
+   *
+   * @returns True if the current instance is a Fake
+   *
+   * @example
+   * ```typescript
+   * if (Log.isFake()) {
+   *   console.log('Using fake logger');
+   * }
+   * ```
+   */
+  static isFake() {
+    const accessor = this.getFacadeAccessor();
+    const key = this.getAccessorKey(accessor);
+    const instance = this.resolvedInstance.get(key);
+    return instance !== void 0 && isFake(instance);
+  }
+  /**
+   * Get the root object behind the facade
+   *
+   * Resolves and returns the actual service instance.
+   *
+   * @returns The resolved service instance
+   */
+  static getFacadeRoot() {
+    return this.resolveFacadeInstance(this.getFacadeAccessor());
+  }
+  /**
+   * Get the registered name of the component
+   *
+   * Subclasses MUST override this method to specify which service
+   * the facade represents.
+   *
+   * @returns Service identifier (string, symbol, or class)
+   * @throws Error if not implemented
+   *
+   * @example
+   * ```typescript
+   * class Log extends Facade {
+   *   protected static getFacadeAccessor(): ServiceIdentifier {
+   *     return LoggerService; // or 'logger' string token
+   *   }
+   * }
+   * ```
+   */
+  static getFacadeAccessor() {
+    throw new Error("Facade does not implement getFacadeAccessor method.");
+  }
+  /**
+   * Get a consistent key for the accessor
+   */
+  static getAccessorKey(accessor) {
+    if (typeof accessor === "function") {
+      return accessor.name || accessor.toString();
+    }
+    return accessor;
+  }
+  /**
+   * Resolve the facade root instance from the container
+   *
+   * @param identifier - Service identifier
+   * @returns Resolved service instance
+   */
+  static resolveFacadeInstance(identifier) {
+    const key = this.getAccessorKey(identifier);
+    if (this.resolvedInstance.has(key)) {
+      return this.resolvedInstance.get(key);
+    }
+    const container = this.getContainer();
+    if (!container) {
+      throw new Error(
+        `Unable to resolve facade instance. Module not set. Call Facade.setFacadeModule(YourModule) first.`
+      );
+    }
+    const instance = container.get(identifier);
+    if (this.cached) {
+      this.resolvedInstance.set(key, instance);
+    }
+    return instance;
+  }
+  /**
+   * Get the module container
+   *
+   * @returns The module container instance
+   */
+  static getContainer() {
+    if (this.container) {
+      return this.container;
+    }
+    if (this.moduleClass) {
+      this.container = (0, import_react_di.getModuleContainer)(this.moduleClass);
+      return this.container;
+    }
+    return null;
+  }
+  /**
+   * Clear a resolved facade instance
+   *
+   * @param name - Service identifier to clear (defaults to this facade's accessor)
+   */
+  static clearResolvedInstance(name) {
+    const key = name ?? this.getAccessorKey(this.getFacadeAccessor());
+    this.resolvedInstance.delete(key);
+  }
+  /**
+   * Clear all resolved instances
+   *
+   * Useful for test cleanup.
+   */
+  static clearResolvedInstances() {
+    this.resolvedInstance.clear();
+  }
+  /**
+   * Get the module class
+   *
+   * @returns The module class
+   */
+  static getFacadeModule() {
+    return this.moduleClass;
+  }
+  /**
+   * Set the module class for facade resolution
+   *
+   * Must be called during application bootstrap to enable facades.
+   * Call this AFTER Inversiland.run() or Container.configure().build().
+   *
+   * @param module - The root module class
+   *
+   * @example
+   * ```typescript
+   * // In your app bootstrap (main.tsx)
+   * import { Facade } from '@abdokouta/react-support';
+   * import { Container, ContainerProvider } from '@abdokouta/react-di';
+   * import { AppModule } from './app.module';
+   *
+   * // Initialize container
+   * Container.configure().withModule(AppModule).withDefaults().build();
+   *
+   * // Set facade module
+   * Facade.setFacadeModule(AppModule);
+   *
+   * // Now facades work anywhere
+   * ReactDOM.createRoot(document.getElementById("root")!).render(
+   *   <ContainerProvider module={AppModule}>
+   *     <App />
+   *   </ContainerProvider>
+   * );
+   * ```
+   */
+  static setFacadeModule(module2) {
+    this.moduleClass = module2;
+    this.container = null;
+  }
+  /**
+   * Set the container directly (alternative to setFacadeModule)
+   *
+   * @param container - The module container instance
+   */
+  static setFacadeContainer(container) {
+    this.container = container;
+  }
+  // ============================================================================
+  // Legacy API (for compatibility with FacadeApplication interface)
+  // ============================================================================
+  /**
+   * @deprecated Use setFacadeModule instead
+   */
+  static setFacadeApplication(app) {
+    if (app) {
+      this.container = {
+        get: (id) => app.get(id)
+      };
+    } else {
+      this.container = null;
+    }
+  }
+  /**
+   * @deprecated Use getFacadeModule instead
+   */
+  static getFacadeApplication() {
+    const container = this.getContainer();
+    if (!container) return null;
+    return {
+      get: (abstract) => container.get(abstract)
+    };
+  }
+};
+/**
+ * The root module class for resolving services
+ */
+Facade.moduleClass = null;
+/**
+ * The module container instance (cached)
+ */
+Facade.container = null;
+/**
+ * The resolved object instances
+ *
+ * Caches resolved instances by their accessor key for performance.
+ */
+Facade.resolvedInstance = /* @__PURE__ */ new Map();
+/**
+ * Indicates if the resolved instance should be cached
+ *
+ * Set to false in subclasses to always resolve fresh instances.
+ */
+Facade.cached = true;
+
+// src/facades/create-facade.ts
+var import_react_di2 = require("@abdokouta/react-di");
+function createFacade(options) {
+  const { accessor, cached = true } = options;
+  class ConcreteFacade extends Facade {
+    static getFacadeAccessor() {
+      return accessor;
+    }
+  }
+  ConcreteFacade.cached = cached;
+  const proxy = new Proxy(ConcreteFacade, {
+    get(target, prop, receiver) {
+      if (prop in target) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+      return (...args) => {
+        const instance = target.getFacadeRoot();
+        if (!instance) {
+          throw new Error(
+            `A facade root has not been set. Call Facade.setFacadeModule() first.`
+          );
+        }
+        const method = instance[prop];
+        if (typeof method !== "function") {
+          throw new Error(
+            `Method "${String(prop)}" does not exist on the facade root.`
+          );
+        }
+        return method.apply(instance, args);
+      };
+    }
+  });
+  return proxy;
+}
+function createFacadeClass(accessor) {
+  return class extends Facade {
+    static getFacadeAccessor() {
+      return accessor;
+    }
+  };
+}
+function getContainerFromModule(moduleClass) {
+  return (0, import_react_di2.getModuleContainer)(moduleClass);
+}
+//# sourceMappingURL=index.js.map