@mrxsys/mrx-core 2.11.0-2-and-276-20251029 → 2.11.0-3-and-276-20251029

package/dist/chunk-e30paw8a.js

@@ -0,0 +1,101 @@
+// @bun
+import {
+  KV_STORE_ERROR_KEYS
+} from "./chunk-xhhj1gvj.js";
+import {
+  BaseError
+} from "./chunk-9cgzhc50.js";
+
+// source/modules/kv-store/memory/memory-store.ts
+class MemoryStore {
+  _store = new Map;
+  _cleanupInterval;
+  _cleanupTimer = null;
+  constructor(cleanupIntervalMs) {
+    this._cleanupInterval = cleanupIntervalMs ?? 300000;
+    this._startCleanup();
+  }
+  get(key) {
+    const entry = this._store.get(key);
+    if (!entry)
+      return null;
+    const now = Date.now();
+    if (now > entry.expiresAt && entry.expiresAt !== -1) {
+      this._store.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  set(key, value, ttlSec) {
+    const expiresAt = ttlSec ? Date.now() + ttlSec * 1000 : -1;
+    this._store.set(key, { value, expiresAt });
+  }
+  increment(key, amount = 1) {
+    const current = this.get(key);
+    const entry = this._store.get(key);
+    if (current !== null && typeof current !== "number")
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
+    const currentValue = current ?? 0;
+    const newValue = currentValue + amount;
+    const expiresAt = entry ? entry.expiresAt : -1;
+    this._store.set(key, { value: newValue, expiresAt });
+    return newValue;
+  }
+  decrement(key, amount = 1) {
+    const current = this.get(key);
+    const entry = this._store.get(key);
+    if (current !== null && typeof current !== "number")
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
+    const currentValue = current ?? 0;
+    const newValue = currentValue - amount;
+    const expiresAt = entry ? entry.expiresAt : -1;
+    this._store.set(key, { value: newValue, expiresAt });
+    return newValue;
+  }
+  del(key) {
+    return this._store.delete(key);
+  }
+  expire(key, ttlSec) {
+    const entry = this._store.get(key);
+    if (!entry)
+      return false;
+    entry.expiresAt = Date.now() + ttlSec * 1000;
+    return true;
+  }
+  ttl(key) {
+    const entry = this._store.get(key);
+    if (!entry)
+      return -1;
+    if (entry.expiresAt === -1)
+      return -1;
+    const remaining = entry.expiresAt - Date.now();
+    return remaining > 0 ? Math.ceil(remaining / 1000) : -1;
+  }
+  clean() {
+    const sizeBefore = this._store.size;
+    this._store.clear();
+    return sizeBefore;
+  }
+  _startCleanup() {
+    if (this._cleanupTimer)
+      return;
+    this._cleanupTimer = setInterval(() => {
+      this._removeExpiredEntries();
+    }, this._cleanupInterval);
+  }
+  _removeExpiredEntries() {
+    const now = Date.now();
+    for (const [key, entry] of this._store.entries())
+      if (entry.expiresAt !== -1 && now > entry.expiresAt)
+        this._store.delete(key);
+  }
+  destroy() {
+    if (this._cleanupTimer) {
+      clearInterval(this._cleanupTimer);
+      this._cleanupTimer = null;
+    }
+    this._store.clear();
+  }
+}
+
+export { MemoryStore };

package/dist/chunk-eeb7yskp.js

@@ -0,0 +1,61 @@
+// @bun
+import {
+  PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS
+} from "./chunk-12qzn7jw.js";
+import {
+  BaseError
+} from "./chunk-9cgzhc50.js";
+
+// source/modules/jwt/utils/parse-human-time-to-seconds.ts
+var TIME_UNITS = {
+  SECOND: 1,
+  MINUTE: 60,
+  HOUR: 60 * 60,
+  DAY: 60 * 60 * 24,
+  WEEK: 60 * 60 * 24 * 7,
+  YEAR: 60 * 60 * 24 * 365.25
+};
+var TIME_EXPRESSION_REGEX = /^(\+|-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
+var UNIT_MAPPINGS = {
+  s: TIME_UNITS.SECOND,
+  sec: TIME_UNITS.SECOND,
+  secs: TIME_UNITS.SECOND,
+  second: TIME_UNITS.SECOND,
+  seconds: TIME_UNITS.SECOND,
+  m: TIME_UNITS.MINUTE,
+  min: TIME_UNITS.MINUTE,
+  mins: TIME_UNITS.MINUTE,
+  minute: TIME_UNITS.MINUTE,
+  minutes: TIME_UNITS.MINUTE,
+  h: TIME_UNITS.HOUR,
+  hr: TIME_UNITS.HOUR,
+  hrs: TIME_UNITS.HOUR,
+  hour: TIME_UNITS.HOUR,
+  hours: TIME_UNITS.HOUR,
+  d: TIME_UNITS.DAY,
+  day: TIME_UNITS.DAY,
+  days: TIME_UNITS.DAY,
+  w: TIME_UNITS.WEEK,
+  week: TIME_UNITS.WEEK,
+  weeks: TIME_UNITS.WEEK,
+  y: TIME_UNITS.YEAR,
+  yr: TIME_UNITS.YEAR,
+  yrs: TIME_UNITS.YEAR,
+  year: TIME_UNITS.YEAR,
+  years: TIME_UNITS.YEAR
+};
+var parseHumanTimeToSeconds = (timeExpression) => {
+  const match = TIME_EXPRESSION_REGEX.exec(timeExpression);
+  if (!match || match[4] && match[1])
+    throw new BaseError(PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS.INVALID_TIME_EXPRESSION);
+  const [, sign, valueStr, unitStr, direction] = match;
+  const value = parseFloat(valueStr);
+  const unit = unitStr.toLowerCase();
+  const multiplier = UNIT_MAPPINGS[unit];
+  const seconds = Math.round(value * multiplier);
+  if (sign === "-" || direction === "ago")
+    return -seconds;
+  return seconds;
+};
+
+export { parseHumanTimeToSeconds };

package/dist/chunk-fs3wm3p4.js

@@ -0,0 +1,32 @@
+// @bun
+import {
+  SINGLETON_MANAGER_ERROR_KEYS
+} from "./chunk-z0ct35ft.js";
+import {
+  BaseError
+} from "./chunk-9cgzhc50.js";
+
+// source/modules/singleton-manager/singleton-manager.ts
+class SingletonManager {
+  static _registry = new Map;
+  static register(name, instance) {
+    if (this._registry.has(name))
+      throw new BaseError(SINGLETON_MANAGER_ERROR_KEYS.CLASS_INSTANCE_ALREADY_REGISTERED, { name });
+    this._registry.set(name, instance);
+  }
+  static unregister(name) {
+    if (!this._registry.has(name))
+      throw new BaseError(SINGLETON_MANAGER_ERROR_KEYS.CLASS_INSTANCE_NOT_REGISTERED, { name });
+    this._registry.delete(name);
+  }
+  static get(name) {
+    if (!this._registry.has(name))
+      throw new BaseError(SINGLETON_MANAGER_ERROR_KEYS.CLASS_INSTANCE_NOT_REGISTERED, { name });
+    return this._registry.get(name);
+  }
+  static has(name) {
+    return this._registry.has(name);
+  }
+}
+
+export { SingletonManager };

package/dist/chunk-grfyngq0.js

@@ -0,0 +1,39 @@
+// @bun
+// source/shared/utils/is-date-string.ts
+var isDateString = (v) => typeof v === "string" && new Date(v).toString() !== "Invalid Date";
+
+// source/shared/utils/stream.ts
+var makeStreamAsyncIterable = (stream) => {
+  const asyncIterable = {
+    [Symbol.asyncIterator]: () => ({
+      next() {
+        return new Promise((resolve, reject) => {
+          const cleanup = () => {
+            stream.off("data", onData);
+            stream.off("end", onEnd);
+            stream.off("error", onError);
+          };
+          const onData = (data) => {
+            cleanup();
+            resolve({ value: data, done: false });
+          };
+          const onEnd = () => {
+            cleanup();
+            resolve({ value: undefined, done: true });
+          };
+          const onError = (error) => {
+            cleanup();
+            reject(error);
+          };
+          stream.on("data", onData);
+          stream.on("end", onEnd);
+          stream.on("error", onError);
+        });
+      }
+    })
+  };
+  stream[Symbol.asyncIterator] = asyncIterable[Symbol.asyncIterator];
+  return stream;
+};
+
+export { isDateString, makeStreamAsyncIterable };

package/dist/chunk-gtn1kn0z.js

@@ -0,0 +1,79 @@
+// @bun
+import {
+  DATA_ERROR_KEYS
+} from "./chunk-jksb9ers.js";
+import {
+  BaseError
+} from "./chunk-9cgzhc50.js";
+
+// source/modules/data/data.ts
+var _validateDataNull = (data) => {
+  if (data === null || data === undefined)
+    throw new BaseError(DATA_ERROR_KEYS.DATA_IS_NULL);
+};
+var filterByKeyExclusion = (data, keys, excludeNullUndefined) => {
+  _validateDataNull(data);
+  const filteredData = {};
+  for (const key in data) {
+    const typedKey = key;
+    if (!keys.includes(typedKey) && (!excludeNullUndefined || data[typedKey] !== null && data[typedKey] !== undefined))
+      filteredData[key] = data[typedKey];
+  }
+  return filteredData;
+};
+var filterByKeyExclusionRecursive = (data, keys, excludeNullUndefined = false) => {
+  _validateDataNull(data);
+  const filteredData = {};
+  for (const key in data) {
+    const typedKey = key;
+    if (!keys.includes(typedKey) && (!excludeNullUndefined || data[typedKey] !== null && data[typedKey] !== undefined))
+      if (typeof data[typedKey] === "object" && data[typedKey] !== null && !Array.isArray(data[typedKey]))
+        filteredData[key] = filterByKeyExclusionRecursive(data[typedKey], keys, excludeNullUndefined);
+      else if (Array.isArray(data[typedKey]))
+        filteredData[key] = data[typedKey].map((item) => {
+          if (typeof item === "object" && item !== null && !Array.isArray(item))
+            return filterByKeyExclusionRecursive(item, keys, excludeNullUndefined);
+          return item;
+        });
+      else
+        filteredData[key] = data[typedKey];
+  }
+  for (const symbol of Object.getOwnPropertySymbols(data))
+    filteredData[symbol] = data[symbol];
+  return filteredData;
+};
+var filterByKeyInclusion = (data, keys, excludeNullUndefined, throwIfDataIsNull = true) => {
+  if (throwIfDataIsNull)
+    _validateDataNull(data);
+  const filteredData = {};
+  for (const key of keys) {
+    const typedKey = key;
+    if (typedKey in data && (!excludeNullUndefined || data[typedKey] !== null && data[typedKey] !== undefined))
+      filteredData[key] = data[typedKey];
+  }
+  return filteredData;
+};
+var filterByValue = (data, predicate, excludeNullUndefined = false, throwIfDataIsNull = true) => {
+  if (throwIfDataIsNull)
+    _validateDataNull(data);
+  const filteredData = {};
+  for (const key in data)
+    if (Object.hasOwn(data, key)) {
+      const typedKey = key;
+      if (predicate(data[typedKey]) && (!excludeNullUndefined || data[typedKey] !== null && data[typedKey] !== undefined))
+        filteredData[typedKey] = data[typedKey];
+    }
+  return filteredData;
+};
+var transformKeys = (data, transformer, throwIfDataIsNull = true) => {
+  if (throwIfDataIsNull)
+    _validateDataNull(data);
+  const result = {};
+  for (const key in data) {
+    const transformedKey = transformer.convertCase(key);
+    result[transformedKey] = data[key];
+  }
+  return result;
+};
+
+export { filterByKeyExclusion, filterByKeyExclusionRecursive, filterByKeyInclusion, filterByValue, transformKeys };

package/dist/chunk-jksb9ers.js

@@ -0,0 +1,7 @@
+// @bun
+// source/modules/data/enums/data-error-keys.ts
+var DATA_ERROR_KEYS = {
+  DATA_IS_NULL: "mrx-core.data.error.is_null"
+};
+
+export { DATA_ERROR_KEYS };

package/dist/chunk-m3grz32t.js

@@ -0,0 +1,27 @@
+// @bun
+// source/modules/totp/utils/create-counter-buffer.ts
+var createCounterBuffer = (counter) => {
+  const counterBuffer = new ArrayBuffer(8);
+  const counterView = new DataView(counterBuffer);
+  if (typeof counter === "bigint")
+    counterView.setBigUint64(0, counter, false);
+  else
+    counterView.setUint32(4, counter, false);
+  return counterBuffer;
+};
+
+// source/modules/totp/utils/dynamic-truncation.ts
+var dynamicTruncation = (hmacArray, digits) => {
+  const offset = hmacArray[hmacArray.length - 1] & 15;
+  const code = ((hmacArray[offset] & 127) << 24 | (hmacArray[offset + 1] & 255) << 16 | (hmacArray[offset + 2] & 255) << 8 | hmacArray[offset + 3] & 255) % 10 ** digits;
+  return code.toString().padStart(digits, "0");
+};
+
+// source/modules/totp/utils/generate-hmac.ts
+import { webcrypto } from "crypto";
+var generateHmac = async (key, data) => {
+  const hmac = await webcrypto.subtle.sign("HMAC", key, data);
+  return new Uint8Array(hmac);
+};
+
+export { createCounterBuffer, dynamicTruncation, generateHmac };

package/dist/chunk-mvrxngm7.js

@@ -0,0 +1,41 @@
+// @bun
+// source/modules/typed-event-emitter/typed-event-emitter.ts
+import { EventEmitter } from "events";
+
+class TypedEventEmitter extends EventEmitter {
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  addListener(event, listener) {
+    return super.addListener(event, listener);
+  }
+  removeListener(event, listener) {
+    return super.removeListener(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  listenerCount(event) {
+    return super.listenerCount(event);
+  }
+  listeners(event) {
+    return super.listeners(event);
+  }
+  rawListeners(event) {
+    return super.rawListeners(event);
+  }
+  prependListener(event, listener) {
+    return super.prependListener(event, listener);
+  }
+  prependOnceListener(event, listener) {
+    return super.prependOnceListener(event, listener);
+  }
+}
+
+export { TypedEventEmitter };

package/dist/chunk-n0n14mf8.js

@@ -0,0 +1,7 @@
+// @bun
+// source/shared/enums/utils-error-keys.ts
+var UTILS_ERROR_KEYS = {
+  INVALID_ENVIRONMENT: "mrx-core.utils.error.invalid_environment"
+};
+
+export { UTILS_ERROR_KEYS };