@bgord/bun 1.15.3 → 1.15.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.15.3",
+  "version": "1.15.4",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -20,21 +20,21 @@
     "preinstall": "bunx only-allow bun"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.7",
+    "@biomejs/biome": "2.4.8",
     "@commitlint/cli": "20.5.0",
     "@commitlint/config-conventional": "20.5.0",
     "@standard-schema/spec": "1.1.0",
     "@stryker-mutator/core": "9.6.0",
-    "@types/bun": "1.3.10",
+    "@types/bun": "1.3.11",
     "@types/nodemailer": "7.0.11",
     "@types/yazl": "3.3.0",
     "better-auth": "1.5.5",
     "cspell": "9.7.0",
-    "csv": "6.5.0",
-    "knip": "5.88.0",
+    "csv": "6.5.1",
+    "knip": "6.0.0",
     "lefthook": "2.1.4",
     "lockfile-lint": "5.0.0",
-    "nodemailer": "8.0.2",
+    "nodemailer": "8.0.3",
     "only-allow": "1.2.2",
     "resend": "6.9.4",
     "sharp": "0.34.5",
@@ -43,15 +43,15 @@
     "yazl": "3.3.1"
   },
   "dependencies": {
-    "@bgord/tools": "1.4.2",
+    "@bgord/tools": "1.4.3",
     "emittery": "2.0.0",
     "hono": "4.12.8",
     "node-cache": "5.1.2"
   },
   "peerDependencies": {
     "better-auth": "1.5.5",
-    "csv": "6.5.0",
-    "nodemailer": "8.0.2",
+    "csv": "6.5.1",
+    "nodemailer": "8.0.3",
     "resend": "6.9.4",
     "sharp": "0.34.5",
     "yazl": "3.3.1"

package/readme.md

@@ -57,6 +57,7 @@ src/
 ├── cache-file.service.ts
 ├── cache-repository-node-cache.adapter.ts
 ├── cache-repository-noop.adapter.ts
+├── cache-repository-redis.adapter.ts
 ├── cache-repository.port.ts
 ├── cache-resolver-simple.strategy.ts
 ├── cache-resolver.strategy.ts
@@ -209,6 +210,9 @@ src/
 ├── image-formatter-noop.adapter.ts
 ├── image-formatter-sharp.adapter.ts
 ├── image-formatter.port.ts
+├── image-grayscale-noop.adapter.ts
+├── image-grayscale-sharp.adapter.ts
+├── image-grayscale.port.ts
 ├── image-info-noop.adapter.ts
 ├── image-info-sharp.adapter.ts
 ├── image-info.port.ts
@@ -237,6 +241,8 @@ src/
 ├── language-detector.middleware.ts
 ├── language-detector.strategy.ts
 ├── languages.vo.ts
+├── liveness-hono.handler.ts
+├── liveness.handler.ts
 ├── logger-collecting.adapter.ts
 ├── logger-noop.adapter.ts
 ├── logger-stats-provider-noop.adapter.ts
@@ -319,8 +325,6 @@ src/
 ├── pdf-generator-noop.adapter.ts
 ├── pdf-generator-with-logger.adapter.ts
 ├── pdf-generator.port.ts
-├── ping-hono.handler.ts
-├── ping.handler.ts
 ├── port.vo.ts
 ├── prerequisite-runner-startup.service.ts
 ├── prerequisite-verifier-binary.adapter.ts
@@ -353,6 +357,12 @@ src/
 ├── prerequisite-verifier.decorator.ts
 ├── prerequisite-verifier.port.ts
 ├── prerequisite.vo.ts
+├── randomness-crypto.strategy.ts
+├── randomness-math.strategy.ts
+├── randomness-noop.strategy.ts
+├── randomness.strategy.ts
+├── readiness-hono.handler.ts
+├── readiness.handler.ts
 ├── recaptcha-secret-key.vo.ts
 ├── recaptcha-site-key.vo.ts
 ├── redactor-composite.strategy.ts
@@ -369,7 +379,7 @@ src/
 ├── request-context-hono.adapter.ts
 ├── request-context.port.ts
 ├── retry-backoff-exponential.strategy.ts
-├── retry-backoff-fibonacci.strategy.ts
+├── retry-backoff-jitter.strategy.ts
 ├── retry-backoff-linear.strategy.ts
 ├── retry-backoff-noop.strategy.ts
 ├── retry-backoff.strategy.ts
@@ -413,6 +423,10 @@ src/
 ├── shield-hcaptcha-hono-local.strategy.ts
 ├── shield-hcaptcha-hono.strategy.ts
 ├── shield-hcaptcha.strategy.ts
+├── shield-ip-blacklist-hono.strategy.ts
+├── shield-ip-blacklist.strategy.ts
+├── shield-ip-whitelist-hono.strategy.ts
+├── shield-ip-whitelist.strategy.ts
 ├── shield-maintenance-hono.strategy.ts
 ├── shield-maintenance.strategy.ts
 ├── shield-rate-limit-hono.strategy.ts

package/src/cache-repository-redis.adapter.ts

@@ -0,0 +1,31 @@
+import type { RedisClient } from "bun";
+import type { CacheRepositoryPort, CacheRepositoryTtlType } from "./cache-repository.port";
+import type { Hash } from "./hash.vo";
+
+export class CacheRepositoryRedisAdapter implements CacheRepositoryPort {
+  constructor(
+    private readonly client: RedisClient,
+    private readonly config: CacheRepositoryTtlType,
+  ) {}
+
+  async get<T>(subject: Hash): Promise<T | null> {
+    const value = await this.client.get(subject.get());
+    if (value === null) return null;
+    return JSON.parse(value) as T;
+  }
+
+  async set<T>(subject: Hash, value: T): Promise<void> {
+    await this.client.set(subject.get(), JSON.stringify(value));
+    if (this.config.type === "finite") {
+      await this.client.expire(subject.get(), this.config.ttl.seconds);
+    }
+  }
+
+  async delete(subject: Hash): Promise<void> {
+    await this.client.del(subject.get());
+  }
+
+  async flush(): Promise<void> {
+    await this.client.send("FLUSHALL", []);
+  }
+}

package/src/healthcheck-hono.handler.ts

@@ -23,9 +23,8 @@ export class HealthcheckHonoHandler implements HandlerHonoPort {
   handle() {
     return factory.createHandlers(async (c) => {
       const healthcheck = await this.handler.check();
-      const code = healthcheck.ok ? 200 : 424;
 
-      return c.json(healthcheck, code);
+      return c.json(healthcheck, healthcheck.code);
     });
   }
 }

package/src/healthcheck.handler.ts

@@ -19,6 +19,12 @@ import type { RedactorStrategy } from "./redactor.strategy";
 import { Stopwatch } from "./stopwatch.service";
 import { Uptime, type UptimeResultType } from "./uptime.service";
 
+export enum HealthcheckStatusEnum {
+  healthy = "healthy",
+  degraded = "degraded",
+  unhealthy = "unhealthy",
+}
+
 type Dependencies = {
   Clock: ClockPort;
   BuildInfoRepository: BuildInfoRepositoryStrategy;
@@ -33,8 +39,15 @@ export type HealthcheckConfig = {
 
 const self = new Prerequisite("self", new PrerequisiteVerifierSelfAdapter());
 
+export const HealthcheckStatusCode = {
+  [HealthcheckStatusEnum.healthy]: 200,
+  [HealthcheckStatusEnum.degraded]: 207,
+  [HealthcheckStatusEnum.unhealthy]: 424,
+} as const;
+
 export type HealthcheckResult = {
-  ok: boolean;
+  status: HealthcheckStatusEnum;
+  code: (typeof HealthcheckStatusCode)[keyof typeof HealthcheckStatusCode];
   deployment: {
     version: string;
     timestamp: tools.TimestampValueType;
@@ -99,7 +112,18 @@ export class HealthcheckHandler {
       }),
     );
 
-    const ok = details.every((result) => result.outcome.outcome !== PrerequisiteVerificationOutcome.failure);
+    const hasFailure = details.some(
+      (result) => result.outcome.outcome === PrerequisiteVerificationOutcome.failure,
+    );
+    const hasUndetermined = details.some(
+      (result) => result.outcome.outcome === PrerequisiteVerificationOutcome.undetermined,
+    );
+
+    const status = hasFailure
+      ? HealthcheckStatusEnum.unhealthy
+      : hasUndetermined
+        ? HealthcheckStatusEnum.degraded
+        : HealthcheckStatusEnum.healthy;
 
     const build = await this.deps.BuildInfoRepository.extract();
     const uptime = Uptime.get(this.deps.Clock);
@@ -107,7 +131,8 @@ export class HealthcheckHandler {
     const memory = MemoryConsumption.snapshot();
 
     return {
-      ok,
+      status,
+      code: HealthcheckStatusCode[status],
       details,
       deployment: {
         version: build.version.toString(),

package/src/image-grayscale-noop.adapter.ts

@@ -0,0 +1,8 @@
+import type * as tools from "@bgord/tools";
+import type { ImageGrayscalePort, ImageGrayscaleStrategy } from "./image-grayscale.port";
+
+export class ImageGrayscaleNoopAdapter implements ImageGrayscalePort {
+  async grayscale(recipe: ImageGrayscaleStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return recipe.strategy === "output_path" ? recipe.output : recipe.input;
+  }
+}

package/src/image-grayscale-sharp.adapter.ts

@@ -0,0 +1,45 @@
+import type * as tools from "@bgord/tools";
+import type sharp from "sharp";
+import { DynamicImport } from "./dynamic-import.service";
+import type { FileRenamerPort } from "./file-renamer.port";
+import type { ImageGrayscalePort, ImageGrayscaleStrategy } from "./image-grayscale.port";
+
+export const ImageGrayscaleSharpAdapterError = {
+  MissingDependency: "image.grayscale.sharp.adapter.error.missing.dependency",
+};
+
+type Dependencies = { FileRenamer: FileRenamerPort };
+type Sharp = typeof sharp;
+
+export class ImageGrayscaleSharpAdapter implements ImageGrayscalePort {
+  private static readonly importer = DynamicImport.for<{ default: Sharp }>(
+    "sharp",
+    ImageGrayscaleSharpAdapterError.MissingDependency,
+  );
+
+  private constructor(
+    private readonly sharp: Sharp,
+    private readonly deps: Dependencies,
+  ) {}
+
+  static async build(deps: Dependencies): Promise<ImageGrayscaleSharpAdapter> {
+    const library = await ImageGrayscaleSharpAdapter.importer.resolve();
+
+    return new ImageGrayscaleSharpAdapter(library.default, deps);
+  }
+
+  async grayscale(recipe: ImageGrayscaleStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;
+
+    const filename = final.getFilename();
+    const temporary = final.withFilename(filename.withSuffix("-grayscale"));
+
+    const pipeline = this.sharp(recipe.input.get());
+    using _sharp_ = { [Symbol.dispose]: () => pipeline.destroy() };
+
+    await pipeline.rotate().grayscale().toFile(temporary.get());
+    await this.deps.FileRenamer.rename(temporary, final);
+
+    return final;
+  }
+}

package/src/image-grayscale.port.ts

@@ -0,0 +1,16 @@
+import type * as tools from "@bgord/tools";
+
+export type ImageGrayscaleOutputPathStrategy = {
+  strategy: "output_path";
+  input: tools.FilePathRelative | tools.FilePathAbsolute;
+  output: tools.FilePathRelative | tools.FilePathAbsolute;
+};
+export type ImageGrayscaleInPlaceStrategy = {
+  strategy: "in_place";
+  input: tools.FilePathRelative | tools.FilePathAbsolute;
+};
+export type ImageGrayscaleStrategy = ImageGrayscaleInPlaceStrategy | ImageGrayscaleOutputPathStrategy;
+
+export interface ImageGrayscalePort {
+  grayscale(recipe: ImageGrayscaleStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute>;
+}

package/src/index.ts

@@ -32,6 +32,7 @@ export * from "./cache-file.service";
 export * from "./cache-repository.port";
 export * from "./cache-repository-node-cache.adapter";
 export * from "./cache-repository-noop.adapter";
+export * from "./cache-repository-redis.adapter";
 export * from "./cache-resolver.strategy";
 export * from "./cache-resolver-simple.strategy";
 export * from "./cache-response.middleware";
@@ -182,6 +183,9 @@ export * from "./image-exif-clear-sharp.adapter";
 export * from "./image-formatter.port";
 export * from "./image-formatter-noop.adapter";
 export * from "./image-formatter-sharp.adapter";
+export * from "./image-grayscale.port";
+export * from "./image-grayscale-noop.adapter";
+export * from "./image-grayscale-sharp.adapter";
 export * from "./image-info.port";
 export * from "./image-info-noop.adapter";
 export * from "./image-info-sharp.adapter";
@@ -208,6 +212,8 @@ export * from "./language-detector-header.strategy";
 export * from "./language-detector-hono.middleware";
 export * from "./language-detector-query.strategy";
 export * from "./languages.vo";
+export * from "./liveness.handler";
+export * from "./liveness-hono.handler";
 export * from "./logger.port";
 export * from "./logger-collecting.adapter";
 export * from "./logger-noop.adapter";
@@ -253,8 +259,6 @@ export * from "./nonce-value.vo";
 export * from "./pdf-generator.port";
 export * from "./pdf-generator-noop.adapter";
 export * from "./pdf-generator-with-logger.adapter";
-export * from "./ping.handler";
-export * from "./ping-hono.handler";
 export * from "./port.vo";
 export * from "./prerequisite.vo";
 export * from "./prerequisite-runner-startup.service";
@@ -282,6 +286,12 @@ export * from "./prerequisite-verifier-sqlite.adapter";
 export * from "./prerequisite-verifier-ssl-certificate-expiry.adapter";
 export * from "./prerequisite-verifier-timezone-utc.adapter";
 export * from "./prerequisite-verifier-translations.adapter";
+export * from "./randomness.strategy";
+export * from "./randomness-crypto.strategy";
+export * from "./randomness-math.strategy";
+export * from "./randomness-noop.strategy";
+export * from "./readiness.handler";
+export * from "./readiness-hono.handler";
 export * from "./recaptcha-secret-key.vo";
 export * from "./recaptcha-site-key.vo";
 export * from "./redactor.strategy";
@@ -300,7 +310,7 @@ export * from "./request-context-hono.adapter";
 export * from "./retry.service";
 export * from "./retry-backoff.strategy";
 export * from "./retry-backoff-exponential.strategy";
-export * from "./retry-backoff-fibonacci.strategy";
+export * from "./retry-backoff-jitter.strategy";
 export * from "./retry-backoff-linear.strategy";
 export * from "./retry-backoff-noop.strategy";
 export * from "./sealer.port";
@@ -342,6 +352,10 @@ export * from "./shield-csrf-hono.strategy";
 export * from "./shield-hcaptcha.strategy";
 export * from "./shield-hcaptcha-hono.strategy";
 export * from "./shield-hcaptcha-hono-local.strategy";
+export * from "./shield-ip-blacklist.strategy";
+export * from "./shield-ip-blacklist-hono.strategy";
+export * from "./shield-ip-whitelist.strategy";
+export * from "./shield-ip-whitelist-hono.strategy";
 export * from "./shield-maintenance.strategy";
 export * from "./shield-maintenance-hono.strategy";
 export * from "./shield-rate-limit.strategy";

package/src/liveness-hono.handler.ts

@@ -0,0 +1,13 @@
+import { createFactory } from "hono/factory";
+import type { HandlerHonoPort } from "./handler-hono.port";
+import { LivenessHandler } from "./liveness.handler";
+
+const factory = createFactory();
+
+export class LivenessHonoHandler implements HandlerHonoPort {
+  private readonly handler = new LivenessHandler();
+
+  handle() {
+    return factory.createHandlers(async (c) => c.json(this.handler.execute(), 200));
+  }
+}

package/src/liveness.handler.ts

@@ -0,0 +1,5 @@
+export class LivenessHandler {
+  execute(): { ok: true } {
+    return { ok: true };
+  }
+}

package/src/randomness-crypto.strategy.ts

@@ -0,0 +1,9 @@
+import type { RandomnessStrategy } from "./randomness.strategy";
+
+export class RandomnessCryptoStrategy implements RandomnessStrategy {
+  next(): number {
+    const array = new Uint32Array(1);
+    crypto.getRandomValues(array);
+    return array[0]! / 0xffffffff;
+  }
+}

package/src/randomness-math.strategy.ts

@@ -0,0 +1,7 @@
+import type { RandomnessStrategy } from "./randomness.strategy";
+
+export class RandomnessMathStrategy implements RandomnessStrategy {
+  next(): number {
+    return Math.random();
+  }
+}

package/src/randomness-noop.strategy.ts

@@ -0,0 +1,9 @@
+import type { RandomnessStrategy } from "./randomness.strategy";
+
+export class RandomnessNoopStrategy implements RandomnessStrategy {
+  constructor(private readonly value: number) {}
+
+  next(): number {
+    return this.value;
+  }
+}

package/src/randomness.strategy.ts

@@ -0,0 +1,3 @@
+export interface RandomnessStrategy {
+  next(): number;
+}

package/src/readiness-hono.handler.ts

@@ -0,0 +1,22 @@
+import { createFactory } from "hono/factory";
+import type { HandlerHonoPort } from "./handler-hono.port";
+import { type ReadinessConfig, ReadinessHandler } from "./readiness.handler";
+
+const factory = createFactory();
+
+export class ReadinessHonoHandler implements HandlerHonoPort {
+  private readonly handler: ReadinessHandler;
+
+  constructor(config: ReadinessConfig) {
+    this.handler = new ReadinessHandler(config);
+  }
+
+  handle() {
+    return factory.createHandlers(async (c) => {
+      const readiness = await this.handler.check();
+      const code = readiness.ok ? 200 : 503;
+
+      return c.json(readiness, code);
+    });
+  }
+}

package/src/readiness.handler.ts

@@ -0,0 +1,33 @@
+import type { Prerequisite, PrerequisiteLabelType } from "./prerequisite.vo";
+import {
+  PrerequisiteVerificationOutcome,
+  type PrerequisiteVerificationResult,
+} from "./prerequisite-verifier.port";
+
+export type ReadinessConfig = { prerequisites: ReadonlyArray<Prerequisite> };
+
+type ReadinessResult = {
+  ok: boolean;
+  details: ReadonlyArray<{ label: PrerequisiteLabelType; outcome: PrerequisiteVerificationResult }>;
+};
+
+export class ReadinessHandler {
+  constructor(private readonly config: ReadinessConfig) {}
+
+  async check(): Promise<ReadinessResult> {
+    const prerequisites = this.config.prerequisites
+      .filter((prerequisite) => prerequisite.enabled)
+      .filter((prerequisite) => prerequisite.kind !== "port");
+
+    const details = await Promise.all(
+      prerequisites.map(async (prerequisite) => ({
+        label: prerequisite.label,
+        outcome: await prerequisite.build().verify(),
+      })),
+    );
+
+    const ok = details.every((detail) => detail.outcome.outcome !== PrerequisiteVerificationOutcome.failure);
+
+    return { ok, details };
+  }
+}

package/src/retry-backoff-jitter.strategy.ts

@@ -0,0 +1,15 @@
+import * as tools from "@bgord/tools";
+import * as v from "valibot";
+import type { RandomnessStrategy } from "./randomness.strategy";
+import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
+
+export class RetryBackoffJitterStrategy implements RetryBackoffStrategy {
+  constructor(
+    private readonly delay: tools.Duration,
+    private readonly randomness: RandomnessStrategy,
+  ) {}
+
+  next(attempt: tools.IntegerPositiveType): tools.Duration {
+    return this.delay.times(v.parse(tools.MultiplicationFactor, attempt * this.randomness.next()));
+  }
+}

package/src/shield-ip-blacklist-hono.strategy.ts

@@ -0,0 +1,30 @@
+import type { MiddlewareHandler } from "hono";
+import { HTTPException } from "hono/http-exception";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+import {
+  type ShieldIpBlacklistConfig,
+  ShieldIpBlacklistStrategy,
+  ShieldIpBlacklistStrategyError,
+} from "./shield-ip-blacklist.strategy";
+
+export const ShieldIpBlacklistError = new HTTPException(403, {
+  message: ShieldIpBlacklistStrategyError.Rejected,
+});
+
+export class ShieldIpBlacklistHonoStrategy implements MiddlewareHonoPort {
+  private readonly strategy: ShieldIpBlacklistStrategy;
+
+  constructor(config: ShieldIpBlacklistConfig) {
+    this.strategy = new ShieldIpBlacklistStrategy(config);
+  }
+
+  handle(): MiddlewareHandler {
+    return async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+
+      if (this.strategy.evaluate(context)) return next();
+      throw ShieldIpBlacklistError;
+    };
+  }
+}

package/src/shield-ip-blacklist.strategy.ts

@@ -0,0 +1,18 @@
+import * as v from "valibot";
+import { ClientIp, type ClientIpType } from "./client-ip.vo";
+import type { HasIdentityIp } from "./request-context.port";
+
+export type ShieldIpBlacklistConfig = { blacklist: Array<ClientIpType> };
+
+export const ShieldIpBlacklistStrategyError = { Rejected: "shield.ip.blacklist.rejected" };
+
+export class ShieldIpBlacklistStrategy {
+  constructor(private readonly config: ShieldIpBlacklistConfig) {}
+
+  evaluate(context: HasIdentityIp): boolean {
+    const ip = v.safeParse(ClientIp, context.identity.ip());
+
+    if (!ip.success) return false;
+    return !this.config.blacklist.includes(ip.output);
+  }
+}

package/src/shield-ip-whitelist-hono.strategy.ts

@@ -0,0 +1,30 @@
+import type { MiddlewareHandler } from "hono";
+import { HTTPException } from "hono/http-exception";
+import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
+import {
+  type ShieldIpWhitelistConfig,
+  ShieldIpWhitelistStrategy,
+  ShieldIpWhitelistStrategyError,
+} from "./shield-ip-whitelist.strategy";
+
+export const ShieldIpWhitelistError = new HTTPException(403, {
+  message: ShieldIpWhitelistStrategyError.Rejected,
+});
+
+export class ShieldIpWhitelistHonoStrategy implements MiddlewareHonoPort {
+  private readonly strategy: ShieldIpWhitelistStrategy;
+
+  constructor(config: ShieldIpWhitelistConfig) {
+    this.strategy = new ShieldIpWhitelistStrategy(config);
+  }
+
+  handle(): MiddlewareHandler {
+    return async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+
+      if (this.strategy.evaluate(context)) return next();
+      throw ShieldIpWhitelistError;
+    };
+  }
+}

package/src/shield-ip-whitelist.strategy.ts

@@ -0,0 +1,18 @@
+import * as v from "valibot";
+import { ClientIp, type ClientIpType } from "./client-ip.vo";
+import type { HasIdentityIp } from "./request-context.port";
+
+export type ShieldIpWhitelistConfig = { whitelist: Array<ClientIpType> };
+
+export const ShieldIpWhitelistStrategyError = { Rejected: "shield.ip.whitelist.rejected" };
+
+export class ShieldIpWhitelistStrategy {
+  constructor(private readonly config: ShieldIpWhitelistConfig) {}
+
+  evaluate(context: HasIdentityIp): boolean {
+    const ip = v.safeParse(ClientIp, context.identity.ip());
+
+    if (!ip.success) return false;
+    return this.config.whitelist.includes(ip.output);
+  }
+}

package/dist/ping-hono.handler.d.ts

@@ -1,6 +0,0 @@
-import type { HandlerHonoPort } from "./handler-hono.port";
-export declare class PingHonoHandler implements HandlerHonoPort {
-    private readonly handler;
-    handle(): [import("hono/types").H<import("hono").Env, string, {}, Promise<Response & import("hono").TypedResponse<"pong", 200, "text">>>];
-}
-//# sourceMappingURL=ping-hono.handler.d.ts.map

package/dist/ping-hono.handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ping-hono.handler.d.ts","sourceRoot":"","sources":["../src/ping-hono.handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAK3D,qBAAa,eAAgB,YAAW,eAAe;IACrD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAE7C,MAAM;CAOP"}

package/dist/ping-hono.handler.js

@@ -1,13 +0,0 @@
-import { createFactory } from "hono/factory";
-import { PingHandler } from "./ping.handler";
-const factory = createFactory();
-export class PingHonoHandler {
-    handler = new PingHandler();
-    handle() {
-        return factory.createHandlers(async (c) => {
-            const result = this.handler.execute();
-            return c.text(result, 200);
-        });
-    }
-}
-//# sourceMappingURL=ping-hono.handler.js.map

package/dist/ping-hono.handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ping-hono.handler.js","sourceRoot":"","sources":["../src/ping-hono.handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,MAAM,OAAO,GAAG,aAAa,EAAE,CAAC;AAEhC,MAAM,OAAO,eAAe;IACT,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;IAE7C,MAAM;QACJ,OAAO,OAAO,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAEtC,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/ping.handler.d.ts

@@ -1,4 +0,0 @@
-export declare class PingHandler {
-    execute(): "pong";
-}
-//# sourceMappingURL=ping.handler.d.ts.map

package/dist/ping.handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ping.handler.d.ts","sourceRoot":"","sources":["../src/ping.handler.ts"],"names":[],"mappings":"AAAA,qBAAa,WAAW;IACtB,OAAO,IAAI,MAAM;CAGlB"}

package/dist/ping.handler.js

@@ -1,6 +0,0 @@
-export class PingHandler {
-    execute() {
-        return "pong";
-    }
-}
-//# sourceMappingURL=ping.handler.js.map

package/dist/ping.handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ping.handler.js","sourceRoot":"","sources":["../src/ping.handler.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,WAAW;IACtB,OAAO;QACL,OAAO,MAAM,CAAC;IAChB,CAAC;CACF"}

package/dist/retry-backoff-fibonacci.strategy.d.ts

@@ -1,9 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
-export declare class RetryBackoffFibonacciStrategy implements RetryBackoffStrategy {
-    private readonly delay;
-    constructor(delay: tools.Duration);
-    next(attempt: tools.IntegerPositiveType): tools.Duration;
-    private fibonacci;
-}
-//# sourceMappingURL=retry-backoff-fibonacci.strategy.d.ts.map