@warlock.js/core 4.0.174 → 4.1.3

package/esm/utils/paths.d.mts

@@ -0,0 +1,72 @@
+//#region ../../@warlock.js/core/src/utils/paths.d.ts
+/**
+ * Get root path or join the given paths to the root path
+ */
+declare function rootPath(...paths: string[]): string;
+/**
+ * Get src directory path or join the given paths to the src directory path
+ */
+declare function srcPath(...paths: string[]): string;
+/**
+ * Get the absolute path to the storage folder to the given path
+ *
+ * If no path is given, it will return the absolute path to the storage folder
+ */
+declare function storagePath(relativePath?: string): string;
+/**
+ * Get the absolute path to the uploads folder to the given path
+ *
+ * If no path is given, it will return the absolute path to the uploads folder
+ */
+declare function uploadsPath(relativePath?: string): any;
+/**
+ * Get the absolute path to the public folder to the given path
+ *
+ * If no path is given, it will return the absolute path to the public folder
+ */
+declare function publicPath(relativePath?: string): string;
+/**
+ * Get the absolute path to the cache folder to the given path
+ *
+ * If no path is given, it will return the absolute path to the cache folder
+ */
+declare function cachePath(relativePath?: string): string;
+/**
+ * App path
+ */
+declare function appPath(relativePath?: string): string;
+/**
+ * Get logs directory path
+ */
+declare function logsPath(relativePath?: string): string;
+/**
+ * Get a temp path
+ */
+declare function tempPath(relativePath?: string): string;
+declare function sanitizePath(filePath: string): string;
+/**
+ * Warlock path
+ * PLEASE DO NOT add any files in this directory as it may be deleted
+ */
+declare function warlockPath(...path: string[]): string;
+/**
+ * Get config directory path
+ */
+declare function configPath(...path: string[]): string;
+declare const paths: {
+  root: typeof rootPath;
+  src: typeof srcPath;
+  storage: typeof storagePath;
+  logs: typeof logsPath;
+  uploads: typeof uploadsPath;
+  public: typeof publicPath;
+  cache: typeof cachePath;
+  app: typeof appPath;
+  temp: typeof tempPath;
+  warlock: typeof warlockPath;
+  config: typeof configPath;
+  sanitize: typeof sanitizePath;
+};
+//#endregion
+export { appPath, cachePath, configPath, logsPath, paths, publicPath, rootPath, sanitizePath, srcPath, storagePath, tempPath, uploadsPath, warlockPath };
+//# sourceMappingURL=paths.d.mts.map

package/esm/utils/paths.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/paths.ts"],"mappings":";;AAMA;;iBAAgB,QAAA,CAAA,GAAY,KAAK;;AAAA;AAOjC;iBAAgB,OAAA,CAAA,GAAW,KAAK;;;AAAA;AAShC;;iBAAgB,WAAA,CAAY,YAAiB;;AAAA;AAS7C;;;iBAAgB,WAAA,CAAY,YAAiB;AAAA;AAgB7C;;;;AAhB6C,iBAgB7B,UAAA,CAAW,YAAiB;AAS5C;;;;AAA2C;AAA3C,iBAAgB,SAAA,CAAU,YAAiB;;;;iBAO3B,OAAA,CAAQ,YAAiB;AAOzC;;;AAAA,iBAAgB,QAAA,CAAS,YAAiB;AAAA;AAO1C;;AAP0C,iBAO1B,QAAA,CAAS,YAAiB;AAAA,iBAS1B,YAAA,CAAa,QAAgB;AATH;AAS1C;;;AAT0C,iBAiB1B,WAAA,CAAA,GAAe,IAAI;AARU;AAQ7C;;AAR6C,iBAe7B,UAAA,CAAA,GAAc,IAAI;AAAA,cAIrB,KAAA"}

package/esm/utils/paths.mjs

@@ -0,0 +1,107 @@
+import config from "@mongez/config";
+import path from "path";
+
+//#region ../../@warlock.js/core/src/utils/paths.ts
+/**
+* Get root path or join the given paths to the root path
+*/
+function rootPath(...paths) {
+	return path.resolve(process.cwd(), ...paths);
+}
+/**
+* Get src directory path or join the given paths to the src directory path
+*/
+function srcPath(...paths) {
+	return rootPath("src", ...paths);
+}
+/**
+* Get the absolute path to the storage folder to the given path
+*
+* If no path is given, it will return the absolute path to the storage folder
+*/
+function storagePath(relativePath = "") {
+	return rootPath("storage", relativePath);
+}
+/**
+* Get the absolute path to the uploads folder to the given path
+*
+* If no path is given, it will return the absolute path to the uploads folder
+*/
+function uploadsPath(relativePath = "") {
+	const configPath = config.get("uploads.root");
+	if (!configPath) return rootPath("storage", "uploads", relativePath);
+	return typeof configPath === "function" ? configPath(relativePath) : path.resolve(configPath, relativePath);
+}
+/**
+* Get the absolute path to the public folder to the given path
+*
+* If no path is given, it will return the absolute path to the public folder
+*/
+function publicPath(relativePath = "") {
+	return rootPath("public", relativePath);
+}
+/**
+* Get the absolute path to the cache folder to the given path
+*
+* If no path is given, it will return the absolute path to the cache folder
+*/
+function cachePath(relativePath = "") {
+	return rootPath("storage", "cache", relativePath);
+}
+/**
+* App path
+*/
+function appPath(relativePath = "") {
+	return rootPath("src/app", relativePath);
+}
+/**
+* Get logs directory path
+*/
+function logsPath(relativePath = "") {
+	return rootPath("storage/logs", relativePath);
+}
+/**
+* Get a temp path
+*/
+function tempPath(relativePath = "") {
+	return rootPath("storage/tmp", relativePath);
+}
+/**
+* Remove any invalid characters from the file path using regex
+* It should accept any language character, numbers, and the following characters: _ - .
+*/
+const invalidCharsRegex = /[<>:"/\\|?*]/g;
+function sanitizePath(filePath) {
+	return filePath.replace(invalidCharsRegex, "");
+}
+/**
+* Warlock path
+* PLEASE DO NOT add any files in this directory as it may be deleted
+*/
+function warlockPath(...path) {
+	return rootPath(".warlock", ...path);
+}
+/**
+* Get config directory path
+*/
+function configPath(...path) {
+	return rootPath("src/config", ...path);
+}
+const paths = {
+	root: rootPath,
+	src: srcPath,
+	storage: storagePath,
+	logs: logsPath,
+	uploads: uploadsPath,
+	public: publicPath,
+	cache: cachePath,
+	app: appPath,
+	temp: tempPath,
+	warlock: warlockPath,
+	config: configPath,
+	sanitize: sanitizePath
+};
+
+//#endregion
+export { appPath, cachePath, configPath, logsPath, paths, publicPath, rootPath, sanitizePath, srcPath, storagePath, tempPath, uploadsPath, warlockPath };
+//# sourceMappingURL=paths.mjs.map

package/esm/utils/paths.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/paths.ts"],"sourcesContent":["import config from \"@mongez/config\";\r\nimport path from \"path\";\r\n\r\n/**\r\n * Get root path or join the given paths to the root path\r\n */\r\nexport function rootPath(...paths: string[]) {\r\n  return path.resolve(process.cwd(), ...paths);\r\n}\r\n\r\n/**\r\n * Get src directory path or join the given paths to the src directory path\r\n */\r\nexport function srcPath(...paths: string[]) {\r\n  return rootPath(\"src\", ...paths);\r\n}\r\n\r\n/**\r\n * Get the absolute path to the storage folder to the given path\r\n *\r\n * If no path is given, it will return the absolute path to the storage folder\r\n */\r\nexport function storagePath(relativePath = \"\") {\r\n  return rootPath(\"storage\", relativePath);\r\n}\r\n\r\n/**\r\n * Get the absolute path to the uploads folder to the given path\r\n *\r\n * If no path is given, it will return the absolute path to the uploads folder\r\n */\r\nexport function uploadsPath(relativePath = \"\") {\r\n  const configPath = config.get(\"uploads.root\");\r\n  if (!configPath) {\r\n    return rootPath(\"storage\", \"uploads\", relativePath);\r\n  }\r\n\r\n  return typeof configPath === \"function\"\r\n    ? configPath(relativePath)\r\n    : path.resolve(configPath, relativePath);\r\n}\r\n\r\n/**\r\n * Get the absolute path to the public folder to the given path\r\n *\r\n * If no path is given, it will return the absolute path to the public folder\r\n */\r\nexport function publicPath(relativePath = \"\") {\r\n  return rootPath(\"public\", relativePath);\r\n}\r\n\r\n/**\r\n * Get the absolute path to the cache folder to the given path\r\n *\r\n * If no path is given, it will return the absolute path to the cache folder\r\n */\r\nexport function cachePath(relativePath = \"\") {\r\n  return rootPath(\"storage\", \"cache\", relativePath);\r\n}\r\n\r\n/**\r\n * App path\r\n */\r\nexport function appPath(relativePath = \"\") {\r\n  return rootPath(\"src/app\", relativePath);\r\n}\r\n\r\n/**\r\n * Get logs directory path\r\n */\r\nexport function logsPath(relativePath = \"\") {\r\n  return rootPath(\"storage/logs\", relativePath);\r\n}\r\n\r\n/**\r\n * Get a temp path\r\n */\r\nexport function tempPath(relativePath = \"\") {\r\n  return rootPath(\"storage/tmp\", relativePath);\r\n}\r\n\r\n/**\r\n * Remove any invalid characters from the file path using regex\r\n * It should accept any language character, numbers, and the following characters: _ - .\r\n */\r\nconst invalidCharsRegex = /[<>:\"/\\\\|?*]/g; // Regex to match invalid characters\r\nexport function sanitizePath(filePath: string) {\r\n  return filePath.replace(invalidCharsRegex, \"\"); // Replace invalid characters with an empty string\r\n}\r\n\r\n/**\r\n * Warlock path\r\n * PLEASE DO NOT add any files in this directory as it may be deleted\r\n */\r\nexport function warlockPath(...path: string[]) {\r\n  return rootPath(\".warlock\", ...path);\r\n}\r\n\r\n/**\r\n * Get config directory path\r\n */\r\nexport function configPath(...path: string[]) {\r\n  return rootPath(\"src/config\", ...path);\r\n}\r\n\r\nexport const paths = {\r\n  root: rootPath,\r\n  src: srcPath,\r\n  storage: storagePath,\r\n  logs: logsPath,\r\n  uploads: uploadsPath,\r\n  public: publicPath,\r\n  cache: cachePath,\r\n  app: appPath,\r\n  temp: tempPath,\r\n  warlock: warlockPath,\r\n  config: configPath,\r\n  sanitize: sanitizePath,\r\n};\r\n"],"mappings":";;;;;;;AAMA,SAAgB,SAAS,GAAG,OAAiB;CAC3C,OAAO,KAAK,QAAQ,QAAQ,IAAI,GAAG,GAAG,KAAK;AAC7C;;;;AAKA,SAAgB,QAAQ,GAAG,OAAiB;CAC1C,OAAO,SAAS,OAAO,GAAG,KAAK;AACjC;;;;;;AAOA,SAAgB,YAAY,eAAe,IAAI;CAC7C,OAAO,SAAS,WAAW,YAAY;AACzC;;;;;;AAOA,SAAgB,YAAY,eAAe,IAAI;CAC7C,MAAM,aAAa,OAAO,IAAI,cAAc;CAC5C,IAAI,CAAC,YACH,OAAO,SAAS,WAAW,WAAW,YAAY;CAGpD,OAAO,OAAO,eAAe,aACzB,WAAW,YAAY,IACvB,KAAK,QAAQ,YAAY,YAAY;AAC3C;;;;;;AAOA,SAAgB,WAAW,eAAe,IAAI;CAC5C,OAAO,SAAS,UAAU,YAAY;AACxC;;;;;;AAOA,SAAgB,UAAU,eAAe,IAAI;CAC3C,OAAO,SAAS,WAAW,SAAS,YAAY;AAClD;;;;AAKA,SAAgB,QAAQ,eAAe,IAAI;CACzC,OAAO,SAAS,WAAW,YAAY;AACzC;;;;AAKA,SAAgB,SAAS,eAAe,IAAI;CAC1C,OAAO,SAAS,gBAAgB,YAAY;AAC9C;;;;AAKA,SAAgB,SAAS,eAAe,IAAI;CAC1C,OAAO,SAAS,eAAe,YAAY;AAC7C;;;;;AAMA,MAAM,oBAAoB;AAC1B,SAAgB,aAAa,UAAkB;CAC7C,OAAO,SAAS,QAAQ,mBAAmB,EAAE;AAC/C;;;;;AAMA,SAAgB,YAAY,GAAG,MAAgB;CAC7C,OAAO,SAAS,YAAY,GAAG,IAAI;AACrC;;;;AAKA,SAAgB,WAAW,GAAG,MAAgB;CAC5C,OAAO,SAAS,cAAc,GAAG,IAAI;AACvC;AAEA,MAAa,QAAQ;CACnB,MAAM;CACN,KAAK;CACL,SAAS;CACT,MAAM;CACN,SAAS;CACT,QAAQ;CACR,OAAO;CACP,KAAK;CACL,MAAM;CACN,SAAS;CACT,QAAQ;CACR,UAAU;AACZ"}

package/esm/utils/promise-all-object.d.mts

@@ -0,0 +1,9 @@
+//#region ../../@warlock.js/core/src/utils/promise-all-object.d.ts
+/**
+ * Resolve all of the given promises in the object and return the results as an object.
+ * This is more convenient than using `Promise.all` and then mapping the results back to the keys.
+ */
+declare function promiseAllObject<T extends Record<string, Promise<any>>>(promises: T): Promise<{ [K in keyof T]: T[K] extends Promise<infer U> ? U : never }>;
+//#endregion
+export { promiseAllObject };
+//# sourceMappingURL=promise-all-object.d.mts.map

package/esm/utils/promise-all-object.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-all-object.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/promise-all-object.ts"],"mappings":";;AAIA;;;iBAAsB,gBAAA,WAA2B,MAAA,SAAe,OAAA,OAAA,CAC9D,QAAA,EAAU,CAAA,GACT,OAAA,eAAsB,CAAA,GAAI,CAAA,CAAE,CAAA,UAAW,OAAA,YAAmB,CAAA"}

package/esm/utils/promise-all-object.mjs

@@ -0,0 +1,16 @@
+//#region ../../@warlock.js/core/src/utils/promise-all-object.ts
+/**
+* Resolve all of the given promises in the object and return the results as an object.
+* This is more convenient than using `Promise.all` and then mapping the results back to the keys.
+*/
+async function promiseAllObject(promises) {
+	const results = await Promise.all(Object.values(promises));
+	return Object.keys(promises).reduce((result, key, index) => {
+		result[key] = results[index];
+		return result;
+	}, {});
+}
+
+//#endregion
+export { promiseAllObject };
+//# sourceMappingURL=promise-all-object.mjs.map

package/esm/utils/promise-all-object.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-all-object.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/promise-all-object.ts"],"sourcesContent":["/**\n * Resolve all of the given promises in the object and return the results as an object.\n * This is more convenient than using `Promise.all` and then mapping the results back to the keys.\n */\nexport async function promiseAllObject<T extends Record<string, Promise<any>>>(\n  promises: T,\n): Promise<{ [K in keyof T]: T[K] extends Promise<infer U> ? U : never }> {\n  const results = await Promise.all(Object.values(promises));\n  const keys = Object.keys(promises);\n\n  return keys.reduce(\n    (result, key, index) => {\n      (result as any)[key] = results[index];\n      return result;\n    },\n    {} as { [K in keyof T]: T[K] extends Promise<infer U> ? U : never },\n  );\n}\n"],"mappings":";;;;;AAIA,eAAsB,iBACpB,UACwE;CACxE,MAAM,UAAU,MAAM,QAAQ,IAAI,OAAO,OAAO,QAAQ,CAAC;CAGzD,OAFa,OAAO,KAAK,QAEf,EAAE,QACT,QAAQ,KAAK,UAAU;EACtB,AAAC,OAAe,OAAO,QAAQ;EAC/B,OAAO;CACT,GACA,CAAC,CACH;AACF"}

package/esm/utils/queue.d.mts

@@ -0,0 +1,52 @@
+//#region ../../@warlock.js/core/src/utils/queue.d.ts
+/**
+ * A utility class for managing a queue of operations.
+ * Allows enqueuing values and executing a function when the queue reaches a certain size or after a specified interval.
+ * Supports both parallel and sequential execution of the queued operations.
+ */
+declare class Queue<T> {
+  /** The items currently in the queue. */
+  private items;
+  /** The maximum size of the queue before triggering execution. */
+  private readonly maxSize?;
+  /** The interval in milliseconds after which the queue will be executed if not already triggered by size. */
+  private readonly interval;
+  /** The function to execute with the items in the queue. */
+  private readonly executeFn;
+  /** Timer for managing the interval-based execution. */
+  private timer;
+  /** Flag to determine if execution should be parallel or sequential. */
+  private readonly executeInParallel;
+  /** The batch size for processing items. */
+  private readonly batchSize;
+  /** Whether the current queue is busy executing */
+  private isExecuting;
+  /**
+   * Constructs a new Queue instance.
+   * @param executeFn - The function to execute with the items in the queue.
+   * @param maxSize - The maximum number of items before the queue is executed.
+   * @param executeEvery - The time in milliseconds after which the queue is executed if not already triggered.
+   * @param executeInParallel - Whether to execute the function in parallel or sequentially.
+   * @param batchSize - The number of items to process in each batch.
+   */
+  constructor(executeFn: (items: T[]) => Promise<void>, executeInParallel: boolean | undefined, executeEvery: number | undefined, batchSize: number, maxSize?: number);
+  /**
+   * Adds an item to the queue.
+   * Triggers execution if the queue reaches the maximum size.
+   * Starts a timer if not already running.
+   * @param item - The item to add to the queue.
+   */
+  enqueue(item: T): void;
+  /**
+   * Starts a timer to execute the queue after the specified interval.
+   */
+  private startTimer;
+  /**
+   * Executes the function with the current items in the queue.
+   * Processes items in batches and resets the timer.
+   */
+  private execute;
+}
+//#endregion
+export { Queue };
+//# sourceMappingURL=queue.d.mts.map

package/esm/utils/queue.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/queue.ts"],"mappings":";;AAKA;;;;cAAa,KAAA;EAqDU;EAAA,QAnDb,KAAA;EAmDc;EAAA,iBAhDL,OAAA;EAHT;EAAA,iBAMS,QAAA;EAAA;EAAA,iBAGA,SAAA;EAGT;EAAA,QAAA,KAAA;EAMS;EAAA,iBAHA,iBAAA;;mBAGA,SAAA;EAcH;EAAA,QAXN,WAAA;EAWN;;;;;;;;cAAA,SAAA,GAAY,KAAA,EAAO,CAAA,OAAQ,OAAA,QAC3B,iBAAA,uBACA,YAAA,sBACA,SAAA,UACA,OAAA;EAyCY;;AAAO;;;;EA1Bd,OAAA,CAAQ,IAAA,EAAM,CAAA;;;;UAcb,UAAA;;;;;UAYM,OAAA;AAAA"}

package/esm/utils/queue.mjs

@@ -0,0 +1,66 @@
+//#region ../../@warlock.js/core/src/utils/queue.ts
+/**
+* A utility class for managing a queue of operations.
+* Allows enqueuing values and executing a function when the queue reaches a certain size or after a specified interval.
+* Supports both parallel and sequential execution of the queued operations.
+*/
+var Queue = class {
+	/**
+	* Constructs a new Queue instance.
+	* @param executeFn - The function to execute with the items in the queue.
+	* @param maxSize - The maximum number of items before the queue is executed.
+	* @param executeEvery - The time in milliseconds after which the queue is executed if not already triggered.
+	* @param executeInParallel - Whether to execute the function in parallel or sequentially.
+	* @param batchSize - The number of items to process in each batch.
+	*/
+	constructor(executeFn, executeInParallel = true, executeEvery = 5e3, batchSize, maxSize) {
+		this.items = [];
+		this.timer = null;
+		this.isExecuting = false;
+		this.executeFn = executeFn;
+		this.maxSize = maxSize;
+		this.interval = executeEvery;
+		this.executeInParallel = executeInParallel;
+		this.batchSize = batchSize;
+	}
+	/**
+	* Adds an item to the queue.
+	* Triggers execution if the queue reaches the maximum size.
+	* Starts a timer if not already running.
+	* @param item - The item to add to the queue.
+	*/
+	enqueue(item) {
+		this.items.push(item);
+		if (this.maxSize && this.items.length >= this.maxSize) this.execute();
+		if (!this.timer) this.startTimer();
+	}
+	/**
+	* Starts a timer to execute the queue after the specified interval.
+	*/
+	startTimer() {
+		this.timer = setInterval(() => {
+			if (this.items.length > 0) this.execute();
+		}, this.interval);
+	}
+	/**
+	* Executes the function with the current items in the queue.
+	* Processes items in batches and resets the timer.
+	*/
+	async execute() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = null;
+		}
+		this.isExecuting = true;
+		if (this.batchSize) {
+			const itemsToProcess = this.items.splice(0, this.batchSize);
+			if (this.executeInParallel) await Promise.all(itemsToProcess.map((item) => this.executeFn([item])));
+			else for (const item of itemsToProcess) await this.executeFn([item]);
+		}
+		this.isExecuting = false;
+	}
+};
+
+//#endregion
+export { Queue };
+//# sourceMappingURL=queue.mjs.map

package/esm/utils/queue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/queue.ts"],"sourcesContent":["/**\n * A utility class for managing a queue of operations.\n * Allows enqueuing values and executing a function when the queue reaches a certain size or after a specified interval.\n * Supports both parallel and sequential execution of the queued operations.\n */\nexport class Queue<T> {\n  /** The items currently in the queue. */\n  private items: T[] = [];\n\n  /** The maximum size of the queue before triggering execution. */\n  private readonly maxSize?: number;\n\n  /** The interval in milliseconds after which the queue will be executed if not already triggered by size. */\n  private readonly interval: number;\n\n  /** The function to execute with the items in the queue. */\n  private readonly executeFn: (items: T[]) => Promise<void>;\n\n  /** Timer for managing the interval-based execution. */\n  private timer: NodeJS.Timeout | null = null;\n\n  /** Flag to determine if execution should be parallel or sequential. */\n  private readonly executeInParallel: boolean;\n\n  /** The batch size for processing items. */\n  private readonly batchSize: number;\n\n  /** Whether the current queue is busy executing */\n  private isExecuting = false;\n\n  /**\n   * Constructs a new Queue instance.\n   * @param executeFn - The function to execute with the items in the queue.\n   * @param maxSize - The maximum number of items before the queue is executed.\n   * @param executeEvery - The time in milliseconds after which the queue is executed if not already triggered.\n   * @param executeInParallel - Whether to execute the function in parallel or sequentially.\n   * @param batchSize - The number of items to process in each batch.\n   */\n  public constructor(\n    executeFn: (items: T[]) => Promise<void>,\n    executeInParallel: boolean = true,\n    executeEvery: number = 5000,\n    batchSize: number,\n    maxSize?: number,\n  ) {\n    this.executeFn = executeFn;\n    this.maxSize = maxSize;\n    this.interval = executeEvery;\n    this.executeInParallel = executeInParallel;\n    this.batchSize = batchSize;\n  }\n\n  /**\n   * Adds an item to the queue.\n   * Triggers execution if the queue reaches the maximum size.\n   * Starts a timer if not already running.\n   * @param item - The item to add to the queue.\n   */\n  public enqueue(item: T): void {\n    this.items.push(item);\n    if (this.maxSize && this.items.length >= this.maxSize) {\n      this.execute();\n    }\n\n    if (!this.timer) {\n      this.startTimer();\n    }\n  }\n\n  /**\n   * Starts a timer to execute the queue after the specified interval.\n   */\n  private startTimer(): void {\n    this.timer = setInterval(() => {\n      if (this.items.length > 0) {\n        this.execute();\n      }\n    }, this.interval);\n  }\n\n  /**\n   * Executes the function with the current items in the queue.\n   * Processes items in batches and resets the timer.\n   */\n  private async execute(): Promise<void> {\n    if (this.timer) {\n      clearInterval(this.timer);\n      this.timer = null;\n    }\n\n    this.isExecuting = true;\n\n    // Now there are couple scenarios:\n    // 1. Batch size has value, we need to check if its going to be executed in parallel or sequentially\n    // 2. Batch size is not provided, we will execute all items in a single call\n    if (this.batchSize) {\n      const itemsToProcess = this.items.splice(0, this.batchSize);\n      if (this.executeInParallel) {\n        await Promise.all(itemsToProcess.map(item => this.executeFn([item])));\n      } else {\n        for (const item of itemsToProcess) {\n          await this.executeFn([item]);\n        }\n      }\n    }\n\n    this.isExecuting = false;\n  }\n}\n"],"mappings":";;;;;;AAKA,IAAa,QAAb,MAAsB;;;;;;;;;CAiCpB,AAAO,YACL,WACA,oBAA6B,MAC7B,eAAuB,KACvB,WACA,SACA;eArCmB,CAAC;eAYiB;qBASjB;EAiBpB,KAAK,YAAY;EACjB,KAAK,UAAU;EACf,KAAK,WAAW;EAChB,KAAK,oBAAoB;EACzB,KAAK,YAAY;CACnB;;;;;;;CAQA,AAAO,QAAQ,MAAe;EAC5B,KAAK,MAAM,KAAK,IAAI;EACpB,IAAI,KAAK,WAAW,KAAK,MAAM,UAAU,KAAK,SAC5C,KAAK,QAAQ;EAGf,IAAI,CAAC,KAAK,OACR,KAAK,WAAW;CAEpB;;;;CAKA,AAAQ,aAAmB;EACzB,KAAK,QAAQ,kBAAkB;GAC7B,IAAI,KAAK,MAAM,SAAS,GACtB,KAAK,QAAQ;EAEjB,GAAG,KAAK,QAAQ;CAClB;;;;;CAMA,MAAc,UAAyB;EACrC,IAAI,KAAK,OAAO;GACd,cAAc,KAAK,KAAK;GACxB,KAAK,QAAQ;EACf;EAEA,KAAK,cAAc;EAKnB,IAAI,KAAK,WAAW;GAClB,MAAM,iBAAiB,KAAK,MAAM,OAAO,GAAG,KAAK,SAAS;GAC1D,IAAI,KAAK,mBACP,MAAM,QAAQ,IAAI,eAAe,KAAI,SAAQ,KAAK,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;QAEpE,KAAK,MAAM,QAAQ,gBACjB,MAAM,KAAK,UAAU,CAAC,IAAI,CAAC;EAGjC;EAEA,KAAK,cAAc;CACrB;AACF"}

package/esm/utils/sleep.d.mts

@@ -0,0 +1,5 @@
+//#region ../../@warlock.js/core/src/utils/sleep.d.ts
+declare function sleep(ms: number): Promise<unknown>;
+//#endregion
+export { sleep };
+//# sourceMappingURL=sleep.d.mts.map

package/esm/utils/sleep.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/sleep.ts"],"mappings":";iBAAgB,KAAA,CAAM,EAAA,WAAU,OAAA"}

package/esm/utils/sleep.mjs

@@ -0,0 +1,8 @@
+//#region ../../@warlock.js/core/src/utils/sleep.ts
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+export { sleep };
+//# sourceMappingURL=sleep.mjs.map

package/esm/utils/sleep.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/sleep.ts"],"sourcesContent":["export function sleep(ms: number) {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n"],"mappings":";AAAA,SAAgB,MAAM,IAAY;CAChC,OAAO,IAAI,SAAQ,YAAW,WAAW,SAAS,EAAE,CAAC;AACvD"}

package/esm/utils/sluggable.d.mts

@@ -0,0 +1,10 @@
+import { Model } from "@warlock.js/cascade";
+
+//#region ../../@warlock.js/core/src/utils/sluggable.d.ts
+/**
+ * Used for model castings
+ */
+declare function sluggable(generateFrom: string, slugLocaleCode?: string): (model: Model) => any;
+//#endregion
+export { sluggable };
+//# sourceMappingURL=sluggable.d.mts.map

package/esm/utils/sluggable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sluggable.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/sluggable.ts"],"mappings":";;;;;AAMA;iBAAgB,SAAA,CAAU,YAAA,UAAsB,cAAA,aACtC,KAAA,EAAO,KAAK"}

package/esm/utils/sluggable.mjs

@@ -0,0 +1,18 @@
+import slug from "@mongez/slug";
+
+//#region ../../@warlock.js/core/src/utils/sluggable.ts
+/**
+* Used for model castings
+*/
+function sluggable(generateFrom, slugLocaleCode = "en") {
+	return (model) => {
+		let value = model.get(generateFrom);
+		if (!value) return "";
+		if (Array.isArray(value)) value = value.find((value) => value.localeCode === slugLocaleCode)?.value;
+		return (slug.default || slug)(String(value));
+	};
+}
+
+//#endregion
+export { sluggable };
+//# sourceMappingURL=sluggable.mjs.map

package/esm/utils/sluggable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sluggable.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/sluggable.ts"],"sourcesContent":["import slug from \"@mongez/slug\";\nimport type { Model } from \"@warlock.js/cascade\";\n\n/**\n * Used for model castings\n */\nexport function sluggable(generateFrom: string, slugLocaleCode = \"en\") {\n  return (model: Model) => {\n    let value = model.get(generateFrom);\n\n    if (!value) return \"\";\n\n    if (Array.isArray(value)) {\n      value = (value as any[]).find((value) => value.localeCode === slugLocaleCode)?.value;\n    }\n\n    const slugFunction = (slug as any).default || slug;\n\n    return slugFunction(String(value));\n  };\n}\n"],"mappings":";;;;;;AAMA,SAAgB,UAAU,cAAsB,iBAAiB,MAAM;CACrE,QAAQ,UAAiB;EACvB,IAAI,QAAQ,MAAM,IAAI,YAAY;EAElC,IAAI,CAAC,OAAO,OAAO;EAEnB,IAAI,MAAM,QAAQ,KAAK,GACrB,QAAS,MAAgB,MAAM,UAAU,MAAM,eAAe,cAAc,GAAG;EAKjF,QAFsB,KAAa,WAAW,MAE1B,OAAO,KAAK,CAAC;CACnC;AACF"}

package/esm/utils/to-json.d.mts

@@ -0,0 +1,5 @@
+//#region ../../@warlock.js/core/src/utils/to-json.d.ts
+declare function toJson(value: any): Promise<any>;
+//#endregion
+export { toJson };
+//# sourceMappingURL=to-json.d.mts.map

package/esm/utils/to-json.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-json.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/to-json.ts"],"mappings":";iBAEsB,MAAA,CAAO,KAAA,QAAa,OAAO"}

package/esm/utils/to-json.mjs

@@ -0,0 +1,23 @@
+import { isIterable, isPlainObject, isScalar } from "@mongez/supportive-is";
+
+//#region ../../@warlock.js/core/src/utils/to-json.ts
+async function toJson(value) {
+	if (!value || isScalar(value)) return value;
+	if (value.toJSON) return await value.toJSON();
+	if (isIterable(value)) {
+		const values = Array.from(value);
+		return Promise.all(values.map(async (item) => {
+			return await toJson(item);
+		}));
+	}
+	if (!isPlainObject(value)) return value;
+	for (const key in value) {
+		const subValue = value[key];
+		value[key] = await toJson(subValue);
+	}
+	return value;
+}
+
+//#endregion
+export { toJson };
+//# sourceMappingURL=to-json.mjs.map

package/esm/utils/to-json.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-json.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/to-json.ts"],"sourcesContent":["import { isIterable, isPlainObject, isScalar } from \"@mongez/supportive-is\";\n\nexport async function toJson(value: any): Promise<any> {\n  // if it is a falsy value, return it\n  if (!value || isScalar(value)) return value;\n\n  // if it has a `toJSON` method, call it and await the result then return it\n  if (value.toJSON) {\n    return await value.toJSON();\n  }\n\n  // if it is iterable, an array or array-like object then parse each item\n  if (isIterable(value)) {\n    const values = Array.from(value);\n\n    return Promise.all(\n      values.map(async (item: any) => {\n        return await toJson(item);\n      }),\n    );\n  }\n\n  // if not plain object, then return it\n  if (!isPlainObject(value)) {\n    return value;\n  }\n\n  // loop over the object and check if the value and call `parse` on it\n  for (const key in value) {\n    const subValue = value[key];\n\n    value[key] = await toJson(subValue);\n  }\n\n  return value;\n}\n"],"mappings":";;;AAEA,eAAsB,OAAO,OAA0B;CAErD,IAAI,CAAC,SAAS,SAAS,KAAK,GAAG,OAAO;CAGtC,IAAI,MAAM,QACR,OAAO,MAAM,MAAM,OAAO;CAI5B,IAAI,WAAW,KAAK,GAAG;EACrB,MAAM,SAAS,MAAM,KAAK,KAAK;EAE/B,OAAO,QAAQ,IACb,OAAO,IAAI,OAAO,SAAc;GAC9B,OAAO,MAAM,OAAO,IAAI;EAC1B,CAAC,CACH;CACF;CAGA,IAAI,CAAC,cAAc,KAAK,GACtB,OAAO;CAIT,KAAK,MAAM,OAAO,OAAO;EACvB,MAAM,WAAW,MAAM;EAEvB,MAAM,OAAO,MAAM,OAAO,QAAQ;CACpC;CAEA,OAAO;AACT"}

package/esm/utils/types.d.mts

@@ -0,0 +1,24 @@
+//#region ../../@warlock.js/core/src/utils/types.d.ts
+type AppConfigurations = {
+  /**
+   * Set default timezone
+   */
+  timezone: string;
+  /**
+   * Set base url
+   */
+  baseUrl: string;
+  /**
+   * Default locale code
+   *
+   * @default en
+   */
+  localeCode?: string;
+  /**
+   * List of allowed locale codes in the app
+   */
+  locales?: string[];
+};
+//#endregion
+export { AppConfigurations };
+//# sourceMappingURL=types.d.mts.map

package/esm/utils/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/types.ts"],"mappings":";KAAY,iBAAA;EAAA;;;EAIV,QAAA;EAAA;;;EAIA,OAAA;EAUO;AAAA;;;;EAJP,UAAA;;;;EAIA,OAAA;AAAA"}

package/esm/utils/urls.d.mts

@@ -0,0 +1,24 @@
+//#region ../../@warlock.js/core/src/utils/urls.d.ts
+/**
+ * Set base url
+ */
+declare function setBaseUrl(url: string): void;
+/**
+ * Get full path for the given path
+ */
+declare function url(path?: string): string;
+/**
+ * Get uploads url
+ */
+declare function uploadsUrl(path?: string): string;
+/**
+ * Get full path for the given path related to public route
+ */
+declare function publicUrl(path?: string): string;
+/**
+ * Assets url
+ */
+declare function assetsUrl(path?: string): string;
+//#endregion
+export { assetsUrl, publicUrl, setBaseUrl, uploadsUrl, url };
+//# sourceMappingURL=urls.d.mts.map

package/esm/utils/urls.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"urls.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/urls.ts"],"mappings":";;AAOA;;iBAAgB,UAAA,CAAW,GAAW;;AAAA;AAOtC;iBAAgB,GAAA,CAAI,IAAS;;;AAAA;iBAOb,UAAA,CAAW,IAAS;;;;iBAOpB,SAAA,CAAU,IAAS;AAAnC;;;AAAA,iBAOgB,SAAA,CAAU,IAAS"}

package/esm/utils/urls.mjs

@@ -0,0 +1,38 @@
+import { ltrim, rtrim } from "@mongez/reinforcements";
+
+//#region ../../@warlock.js/core/src/utils/urls.ts
+let baseUrl = "";
+/**
+* Set base url
+*/
+function setBaseUrl(url) {
+	baseUrl = url;
+}
+/**
+* Get full path for the given path
+*/
+function url(path = "") {
+	return rtrim(baseUrl, "/") + "/" + ltrim(path, "/");
+}
+/**
+* Get uploads url
+*/
+function uploadsUrl(path = "") {
+	return url("/uploads/" + ltrim(path, "/"));
+}
+/**
+* Get full path for the given path related to public route
+*/
+function publicUrl(path = "") {
+	return url("/public/" + ltrim(path, "/"));
+}
+/**
+* Assets url
+*/
+function assetsUrl(path = "") {
+	return publicUrl("/assets/" + ltrim(path, "/"));
+}
+
+//#endregion
+export { assetsUrl, publicUrl, setBaseUrl, uploadsUrl, url };
+//# sourceMappingURL=urls.mjs.map

package/esm/utils/urls.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"urls.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/utils/urls.ts"],"sourcesContent":["import { ltrim, rtrim } from \"@mongez/reinforcements\";\n\nlet baseUrl = \"\";\n\n/**\n * Set base url\n */\nexport function setBaseUrl(url: string) {\n  baseUrl = url;\n}\n\n/**\n * Get full path for the given path\n */\nexport function url(path = \"\") {\n  return rtrim(baseUrl, \"/\") + \"/\" + ltrim(path, \"/\");\n}\n\n/**\n * Get uploads url\n */\nexport function uploadsUrl(path = \"\") {\n  return url(\"/uploads/\" + ltrim(path, \"/\"));\n}\n\n/**\n * Get full path for the given path related to public route\n */\nexport function publicUrl(path = \"\") {\n  return url(\"/public/\" + ltrim(path, \"/\"));\n}\n\n/**\n * Assets url\n */\nexport function assetsUrl(path = \"\") {\n  return publicUrl(\"/assets/\" + ltrim(path, \"/\"));\n}\n"],"mappings":";;;AAEA,IAAI,UAAU;;;;AAKd,SAAgB,WAAW,KAAa;CACtC,UAAU;AACZ;;;;AAKA,SAAgB,IAAI,OAAO,IAAI;CAC7B,OAAO,MAAM,SAAS,GAAG,IAAI,MAAM,MAAM,MAAM,GAAG;AACpD;;;;AAKA,SAAgB,WAAW,OAAO,IAAI;CACpC,OAAO,IAAI,cAAc,MAAM,MAAM,GAAG,CAAC;AAC3C;;;;AAKA,SAAgB,UAAU,OAAO,IAAI;CACnC,OAAO,IAAI,aAAa,MAAM,MAAM,GAAG,CAAC;AAC1C;;;;AAKA,SAAgB,UAAU,OAAO,IAAI;CACnC,OAAO,UAAU,aAAa,MAAM,MAAM,GAAG,CAAC;AAChD"}

package/esm/validation/database/exists-except-current-id.d.mts

@@ -0,0 +1,11 @@
+import { ExistsExceptCurrentIdRuleOptions } from "./types.mjs";
+import { SchemaRule } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/core/src/validation/database/exists-except-current-id.d.ts
+/**
+ * Exists except current ID rule
+ */
+declare const existsExceptCurrentIdRule: SchemaRule<ExistsExceptCurrentIdRuleOptions>;
+//#endregion
+export { existsExceptCurrentIdRule };
+//# sourceMappingURL=exists-except-current-id.d.mts.map

package/esm/validation/database/exists-except-current-id.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exists-except-current-id.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/validation/database/exists-except-current-id.ts"],"mappings":";;;;;;;cAQa,yBAAA,EAA2B,UAAU,CAAC,gCAAA"}

package/esm/validation/database/exists-except-current-id.mjs

@@ -0,0 +1,30 @@
+import { useRequestStore } from "../../http/context/request-context.mjs";
+import "../../http/index.mjs";
+import { VALID_RULE, invalidRule } from "@warlock.js/seal";
+import { resolveModelClass } from "@warlock.js/cascade";
+
+//#region ../../@warlock.js/core/src/validation/database/exists-except-current-id.ts
+/**
+* Exists except current ID rule
+*/
+const existsExceptCurrentIdRule = {
+	name: "existsExceptCurrentId",
+	defaultErrorMessage: "The :input must exist",
+	async validate(value, context) {
+		const { Model, query, column = context.key, exceptCurrentIdColumn = "id" } = this.context.options;
+		const { request } = useRequestStore();
+		const dbQuery = resolveModelClass(Model).query();
+		dbQuery.where(column, value);
+		dbQuery.where(exceptCurrentIdColumn, "!=", request.int("id"));
+		if (query) await query({
+			query: dbQuery,
+			value,
+			allValues: context.allValues
+		});
+		return await dbQuery.first() ? VALID_RULE : invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { existsExceptCurrentIdRule };
+//# sourceMappingURL=exists-except-current-id.mjs.map

package/esm/validation/database/exists-except-current-id.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"exists-except-current-id.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/validation/database/exists-except-current-id.ts"],"sourcesContent":["import { resolveModelClass } from \"@warlock.js/cascade\";\nimport { invalidRule, VALID_RULE, type SchemaRule } from \"@warlock.js/seal\";\nimport { useRequestStore } from \"../../http\";\nimport type { ExistsExceptCurrentIdRuleOptions } from \"../types\";\n\n/**\n * Exists except current ID rule\n */\nexport const existsExceptCurrentIdRule: SchemaRule<ExistsExceptCurrentIdRuleOptions> = {\n  name: \"existsExceptCurrentId\",\n  defaultErrorMessage: \"The :input must exist\",\n  async validate(value: any, context) {\n    const {\n      Model,\n      query,\n      column = context.key,\n      exceptCurrentIdColumn = \"id\",\n    } = this.context.options;\n\n    const { request } = useRequestStore();\n\n    const ResolvedModelClass = resolveModelClass(Model);\n\n    const dbQuery = ResolvedModelClass.query();\n\n    dbQuery.where(column, value);\n    dbQuery.where(exceptCurrentIdColumn, \"!=\", request.int(\"id\"));\n\n    if (query) {\n      await query({\n        query: dbQuery,\n        value,\n        allValues: context.allValues,\n      });\n    }\n\n    const document = await dbQuery.first();\n    return document ? VALID_RULE : invalidRule(this, context);\n  },\n};\n"],"mappings":";;;;;;;;;AAQA,MAAa,4BAA0E;CACrF,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EACJ,OACA,OACA,SAAS,QAAQ,KACjB,wBAAwB,SACtB,KAAK,QAAQ;EAEjB,MAAM,EAAE,YAAY,gBAAgB;EAIpC,MAAM,UAFqB,kBAAkB,KAEZ,EAAE,MAAM;EAEzC,QAAQ,MAAM,QAAQ,KAAK;EAC3B,QAAQ,MAAM,uBAAuB,MAAM,QAAQ,IAAI,IAAI,CAAC;EAE5D,IAAI,OACF,MAAM,MAAM;GACV,OAAO;GACP;GACA,WAAW,QAAQ;EACrB,CAAC;EAIH,OAAO,MADgB,QAAQ,MAAM,IACnB,aAAa,YAAY,MAAM,OAAO;CAC1D;AACF"}

package/esm/validation/database/exists-except-current-user.d.mts

@@ -0,0 +1,11 @@
+import { ExistsExceptCurrentUserRuleOptions } from "./types.mjs";
+import { SchemaRule } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/core/src/validation/database/exists-except-current-user.d.ts
+/**
+ * Exists except current user rule
+ */
+declare const existsExceptCurrentUserRule: SchemaRule<ExistsExceptCurrentUserRuleOptions>;
+//#endregion
+export { existsExceptCurrentUserRule };
+//# sourceMappingURL=exists-except-current-user.d.mts.map

package/esm/validation/database/exists-except-current-user.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exists-except-current-user.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/validation/database/exists-except-current-user.ts"],"mappings":";;;;;;;cAQa,2BAAA,EAA6B,UAAU,CAAC,kCAAA"}