alepha 0.7.5 → 0.7.6

package/core.js

@@ -1 +1 @@
-export * from '@alepha/core';
+export * from '@alepha/core'

package/datetime.cjs

@@ -1,12 +1,8 @@
 'use strict';
-
-var datetime = require('@alepha/datetime');
-
-
-
-Object.keys(datetime).forEach(function (k) {
+var m = require('@alepha/datetime');
+Object.keys(m).forEach(function (k) {
 	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,
-		get: function () { return datetime[k]; }
+		get: function () { return m[k]; }
 	});
-});
+});

package/datetime.d.ts

@@ -1,162 +1,167 @@
-import * as _alepha_core from '@alepha/core';
-import { Async } from '@alepha/core';
-import dayjs, { ManipulateType, Dayjs } from 'dayjs';
-import dayjsDuration from 'dayjs/plugin/duration.js';
+import * as _alepha_core1 from "@alepha/core";
+import { Async } from "@alepha/core";
+import dayjs, { Dayjs, ManipulateType } from "dayjs";
+import dayjsDuration from "dayjs/plugin/duration.js";
 
+//#region src/helpers/Interval.d.ts
 declare class Interval {
-    private timer;
-    private readonly run;
-    private duration;
-    private options;
-    constructor(duration: number, options: IntervalDescriptorOptions);
-    /**
-     * Start the interval.
-     */
-    start(): Promise<void>;
-    /**
-     * Add time to the interval.
-     *
-     * @param amountMs
-     */
-    add(amountMs: number): Promise<void>;
-    /**
-     * Clear the interval.
-     */
-    clear(): void;
+  private timer;
+  private readonly run;
+  private duration;
+  private options;
+  constructor(duration: number, options: IntervalDescriptorOptions);
+  /**
+   * Start the interval.
+   */
+  start(): Promise<void>;
+  /**
+   * Add time to the interval.
+   *
+   * @param amountMs
+   */
+  add(amountMs: number): Promise<void>;
+  /**
+   * Clear the interval.
+   */
+  clear(): void;
 }
-
+//#endregion
+//#region src/helpers/Timeout.d.ts
 declare class Timeout {
-    private timer;
-    private duration;
-    private readonly now;
-    private readonly callback;
-    constructor(now: number, duration: number, callback: () => void);
-    /**
-     * Add time to the timeout.
-     */
-    add(amountMs: number): void;
-    /**
-     * Clear the timeout.
-     */
-    clear(): void;
-    /**
-     * Start the timeout.
-     *
-     * @private
-     */
-    private start;
+  private timer;
+  private duration;
+  private readonly now;
+  private readonly callback;
+  constructor(now: number, duration: number, callback: () => void);
+  /**
+   * Add time to the timeout.
+   */
+  add(amountMs: number): void;
+  /**
+   * Clear the timeout.
+   */
+  clear(): void;
+  /**
+   * Start the timeout.
+   *
+   * @private
+   */
+  private start;
 }
-
+//#endregion
+//#region src/providers/DateTimeProvider.d.ts
 type DateTime = dayjs.Dayjs;
 type Duration = dayjsDuration.Duration;
 type DurationLike = number | dayjsDuration.Duration | [number, ManipulateType];
 declare class DateTimeProvider {
-    protected log: _alepha_core.Logger;
-    protected ref: DateTime | null;
-    protected readonly timeouts: Timeout[];
-    protected readonly intervals: Interval[];
-    constructor();
-    protected readonly start: _alepha_core.HookDescriptor<"start">;
-    protected readonly stop: _alepha_core.HookDescriptor<"stop">;
-    /**
-     * Create a new DateTime instance.
-     */
-    of(date: string | number | Date | Dayjs | null | undefined): DateTime;
-    /**
-     * Get the current date.
-     */
-    now(): DateTime;
-    /**
-     * Get the current date as a string.
-     *
-     * @param date
-     */
-    toISOString(date?: Date | string | DateTime): string;
-    /**
-     * Get the current date as a string.
-     */
-    nowISOString(): string;
-    /**
-     * Get the current date as a string.
-     *
-     * @protected
-     */
-    protected getCurrentDate(): DateTime;
-    /**
-     * Create a new Duration instance.
-     */
-    duration: (duration: DurationLike, unit?: ManipulateType) => Duration;
-    isDurationLike(value: unknown): value is DurationLike;
-    /**
-     * Return a promise that resolves after a next tick.
-     * It uses `setTimeout` with 0ms delay.
-     */
-    tick(): Promise<void>;
-    /**
-     * Wait for a certain duration.
-     *
-     * You can clear the timeout by using the `AbortSignal` API.
-     * Aborted signal will resolve the promise immediately, it does not reject it.
-     */
-    wait(duration: DurationLike, options?: {
-        signal?: AbortSignal;
-        now?: number;
-    }): Promise<void>;
-    /**
-     * Run a callback after a certain duration.
-     */
-    timeout(callback: () => void, duration: DurationLike, now?: number): Timeout;
-    /**
-     * Create an interval.
-     *
-     * @param args
-     */
-    interval(args: IntervalDescriptorOptions): Interval;
-    /**
-     * Run a function with a deadline.
-     */
-    deadline<T>(fn: (signal: AbortSignal) => Promise<T>, duration: DurationLike): Promise<T>;
-    /**
-     * Add time to the current date.
-     */
-    travel(duration: DurationLike, unit?: ManipulateType): Promise<void>;
-    /**
-     * Stop the time.
-     */
-    pause(): dayjs.Dayjs;
-    /**
-     * Reset the reference date.
-     */
-    reset(): void;
+  protected log: _alepha_core1.Logger;
+  protected ref: DateTime | null;
+  protected readonly timeouts: Timeout[];
+  protected readonly intervals: Interval[];
+  constructor();
+  protected readonly start: _alepha_core1.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core1.HookDescriptor<"stop">;
+  /**
+   * Create a new DateTime instance.
+   */
+  of(date: string | number | Date | Dayjs | null | undefined): DateTime;
+  /**
+   * Get the current date.
+   */
+  now(): DateTime;
+  /**
+   * Get the current date as a string.
+   *
+   * @param date
+   */
+  toISOString(date?: Date | string | DateTime): string;
+  /**
+   * Get the current date as a string.
+   */
+  nowISOString(): string;
+  /**
+   * Get the current date as a string.
+   *
+   * @protected
+   */
+  protected getCurrentDate(): DateTime;
+  /**
+   * Create a new Duration instance.
+   */
+  duration: (duration: DurationLike, unit?: ManipulateType) => Duration;
+  isDurationLike(value: unknown): value is DurationLike;
+  /**
+   * Return a promise that resolves after a next tick.
+   * It uses `setTimeout` with 0ms delay.
+   */
+  tick(): Promise<void>;
+  /**
+   * Wait for a certain duration.
+   *
+   * You can clear the timeout by using the `AbortSignal` API.
+   * Aborted signal will resolve the promise immediately, it does not reject it.
+   */
+  wait(duration: DurationLike, options?: {
+    signal?: AbortSignal;
+    now?: number;
+  }): Promise<void>;
+  /**
+   * Run a callback after a certain duration.
+   */
+  timeout(callback: () => void, duration: DurationLike, now?: number): Timeout;
+  /**
+   * Create an interval.
+   *
+   * @param args
+   */
+  interval(args: IntervalDescriptorOptions): Interval;
+  /**
+   * Run a function with a deadline.
+   */
+  deadline<T>(fn: (signal: AbortSignal) => Promise<T>, duration: DurationLike): Promise<T>;
+  /**
+   * Add time to the current date.
+   */
+  travel(duration: DurationLike, unit?: ManipulateType): Promise<void>;
+  /**
+   * Stop the time.
+   */
+  pause(): dayjs.Dayjs;
+  /**
+   * Reset the reference date.
+   */
+  reset(): void;
 }
-
+//#endregion
+//#region src/descriptors/$interval.d.ts
 interface IntervalDescriptorOptions {
-    /**
-     * Whether to start the interval immediately.
-     *
-     * @default false
-     */
-    run?: boolean;
-    /**
-     * Whether to attach the interval to the context.
-     *
-     * Attached intervals are automatically started when the context starts and stopped when the context stops.
-     *
-     * @default true
-     */
-    attach?: boolean;
-    /**
-     * The interval handler.
-     */
-    handler: () => Async<void>;
-    /**
-     * The interval duration.
-     */
-    duration: DurationLike;
+  /**
+   * Whether to start the interval immediately.
+   *
+   * @default false
+   */
+  run?: boolean;
+  /**
+   * Whether to attach the interval to the context.
+   *
+   * Attached intervals are automatically started when the context starts and stopped when the context stops.
+   *
+   * @default true
+   */
+  attach?: boolean;
+  /**
+   * The interval handler.
+   */
+  handler: () => Async<void>;
+  /**
+   * The interval duration.
+   */
+  duration: DurationLike;
 }
 /**
  * Registers a new interval.
  */
 declare const $interval: (options: IntervalDescriptorOptions) => Interval;
-
-export { $interval, type DateTime, DateTimeProvider, type Duration, type DurationLike, Interval, type IntervalDescriptorOptions, Timeout };
+//#endregion
+export { $interval, DateTime, DateTimeProvider, Duration, DurationLike, Interval, IntervalDescriptorOptions, Timeout };
+//# sourceMappingURL=index.d.ts.map

package/datetime.js

@@ -1 +1 @@
-export * from '@alepha/datetime';
+export * from '@alepha/datetime'

package/lock/redis.cjs

@@ -1,50 +1,8 @@
 'use strict';
-
-var lock = require('@alepha/lock');
-var topicRedis = require('@alepha/topic-redis');
-var core = require('@alepha/core');
-var redis = require('@alepha/redis');
-
-class RedisLockProvider {
-  log = core.$logger();
-  redisProvider = core.$inject(redis.RedisProvider);
-  async set(key, value, nx, px) {
-    const options = {
-      GET: true
-      // all the secrets of $lock is based on this
-    };
-    if (px) {
-      options.expiration = {
-        type: "PX",
-        value: px
-      };
-    }
-    if (nx) {
-      options.condition = "NX";
-    }
-    const resp = await this.redisProvider.set(key, value, options);
-    if (resp === null) {
-      this.log.debug(`Lock already exists`, { key, value });
-      return value;
-    }
-    return resp.toString("utf-8");
-  }
-  async del(...keys) {
-    await this.redisProvider.del(keys);
-  }
-}
-class AlephaLockRedis {
-  name = "alepha.lock.redis";
-  $services = (alepha) => alepha.with({
-    provide: lock.LockTopicProvider,
-    use: topicRedis.RedisTopicProvider,
-    optional: true
-  }).with({
-    provide: lock.LockProvider,
-    use: RedisLockProvider,
-    optional: true
-  }).with(lock.AlephaLock);
-}
-
-exports.AlephaLockRedis = AlephaLockRedis;
-exports.RedisLockProvider = RedisLockProvider;
+var m = require('@alepha/lock-redis');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});

package/lock/redis.d.ts

@@ -1,15 +1,17 @@
-import * as _alepha_core from '@alepha/core';
-import { Alepha } from '@alepha/core';
-import { LockProvider } from '@alepha/lock';
-import { RedisProvider } from '@alepha/redis';
+import { LockProvider } from "@alepha/lock";
+import * as _alepha_core0 from "@alepha/core";
+import { Alepha } from "@alepha/core";
+import { RedisProvider } from "@alepha/redis";
 
+//#region src/providers/RedisLockProvider.d.ts
 declare class RedisLockProvider implements LockProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly redisProvider: RedisProvider;
-    set(key: string, value: string, nx?: boolean, px?: number): Promise<string>;
-    del(...keys: string[]): Promise<void>;
+  protected readonly log: _alepha_core0.Logger;
+  protected readonly redisProvider: RedisProvider;
+  set(key: string, value: string, nx?: boolean, px?: number): Promise<string>;
+  del(...keys: string[]): Promise<void>;
 }
-
+//#endregion
+//#region src/index.d.ts
 /**
  * Alepha Lock Redis Module
  *
@@ -19,8 +21,9 @@ declare class RedisLockProvider implements LockProvider {
  * @module alepha.lock.redis
  */
 declare class AlephaLockRedis {
-    readonly name = "alepha.lock.redis";
-    readonly $services: (alepha: Alepha) => Alepha;
+  readonly name = "alepha.lock.redis";
+  readonly $services: (alepha: Alepha) => Alepha;
 }
-
+//#endregion
 export { AlephaLockRedis, RedisLockProvider };
+//# sourceMappingURL=index.d.ts.map

package/lock/redis.js

@@ -1,47 +1 @@
-import { LockTopicProvider, LockProvider, AlephaLock } from '@alepha/lock';
-import { RedisTopicProvider } from '@alepha/topic-redis';
-import { $logger, $inject } from '@alepha/core';
-import { RedisProvider } from '@alepha/redis';
-
-class RedisLockProvider {
-  log = $logger();
-  redisProvider = $inject(RedisProvider);
-  async set(key, value, nx, px) {
-    const options = {
-      GET: true
-      // all the secrets of $lock is based on this
-    };
-    if (px) {
-      options.expiration = {
-        type: "PX",
-        value: px
-      };
-    }
-    if (nx) {
-      options.condition = "NX";
-    }
-    const resp = await this.redisProvider.set(key, value, options);
-    if (resp === null) {
-      this.log.debug(`Lock already exists`, { key, value });
-      return value;
-    }
-    return resp.toString("utf-8");
-  }
-  async del(...keys) {
-    await this.redisProvider.del(keys);
-  }
-}
-class AlephaLockRedis {
-  name = "alepha.lock.redis";
-  $services = (alepha) => alepha.with({
-    provide: LockTopicProvider,
-    use: RedisTopicProvider,
-    optional: true
-  }).with({
-    provide: LockProvider,
-    use: RedisLockProvider,
-    optional: true
-  }).with(AlephaLock);
-}
-
-export { AlephaLockRedis, RedisLockProvider };
+export * from '@alepha/lock-redis'

package/lock.cjs

@@ -1,12 +1,8 @@
 'use strict';
-
-var lock = require('@alepha/lock');
-
-
-
-Object.keys(lock).forEach(function (k) {
+var m = require('@alepha/lock');
+Object.keys(m).forEach(function (k) {
 	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,
-		get: function () { return lock[k]; }
+		get: function () { return m[k]; }
 	});
-});
+});