@akanjs/test 0.0.39 → 0.0.40

package/src/index.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  sample: () => import_sample.sample,
+  sampleOf: () => import_sampleOf.sampleOf
+});
+module.exports = __toCommonJS(src_exports);
+var import_sampleOf = require("./sampleOf");
+var import_sample = require("./sample");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sample,
+  sampleOf
+});

package/src/jest.config.base.d.ts

@@ -0,0 +1,5 @@
+import { Config } from '@jest/types';
+
+declare const withBase: (name: string) => Config.InitialOptions;
+
+export { withBase };

package/src/jest.config.base.js

@@ -0,0 +1,85 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jest_config_base_exports = {};
+__export(jest_config_base_exports, {
+  withBase: () => withBase
+});
+module.exports = __toCommonJS(jest_config_base_exports);
+var import_dotenv = require("dotenv");
+const withBase = /* @__PURE__ */ __name((name) => {
+  (0, import_dotenv.config)();
+  process.env.NEXT_PUBLIC_ENV = "testing";
+  process.env.NEXT_PUBLIC_OPERATION_MODE = "local";
+  process.env.NEXT_PUBLIC_APP_NAME = name;
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  const akanjsPrefix = process.env.USE_AKANJS_PKGS === "true" ? "../../pkgs/" : "";
+  return {
+    displayName: name,
+    resolver: "@nx/jest/plugins/resolver",
+    globalSetup: `${akanjsPrefix}@akanjs/test/src/jest.globalSetup.ts`,
+    setupFilesAfterEnv: [
+      `${akanjsPrefix}@akanjs/test/src/jest.setupFilesAfterEnv.ts`
+    ],
+    globalTeardown: `${akanjsPrefix}@akanjs/test/src/jest.globalTeardown.ts`,
+    testMatch: [
+      "**/?(*.)+(test).ts?(x)"
+    ],
+    testPathIgnorePatterns: [
+      "/node_modules/",
+      "/app/"
+    ],
+    maxWorkers: 1,
+    transform: {
+      "signal\\.(test)\\.ts$": [
+        "ts-jest",
+        {
+          tsconfig: "<rootDir>/tsconfig.spec.json"
+        }
+      ],
+      "^.+\\.(ts|js|html)$": [
+        "ts-jest",
+        {
+          tsconfig: "<rootDir>/tsconfig.spec.json"
+        }
+      ]
+    },
+    moduleFileExtensions: [
+      "ts",
+      "tsx",
+      "js",
+      "jsx"
+    ],
+    coverageDirectory: `../../coverage/libs/${name}`,
+    coverageReporters: [
+      "html"
+    ],
+    testEnvironment: "node",
+    testEnvironmentOptions: {
+      customExportConditions: [
+        "node",
+        "require",
+        "default"
+      ]
+    }
+  };
+}, "withBase");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withBase
+});

package/src/jest.globalSetup.d.ts

@@ -0,0 +1,5 @@
+import { Config } from '@jest/types';
+
+declare const setup: (globalConfig: Config.InitialOptions, projectConfig: any) => Promise<void>;
+
+export { setup as default };

package/src/jest.globalSetup.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jest_globalSetup_exports = {};
+__export(jest_globalSetup_exports, {
+  default: () => jest_globalSetup_default
+});
+module.exports = __toCommonJS(jest_globalSetup_exports);
+var import_register = require("tsconfig-paths/register");
+var import_jest = require("./jest.testServer");
+const setup = /* @__PURE__ */ __name(async (globalConfig, projectConfig) => {
+  const { env } = require(`${globalConfig.rootDir}/env/env.server.testing`);
+  const { fetch, registerModules } = require(`${globalConfig.rootDir}/server`);
+  const maxWorkers = globalConfig.maxWorkers;
+  if (!maxWorkers) throw new Error("maxWorkers is not defined");
+  const testServers = new Array(maxWorkers).fill(0).map((_, idx) => new import_jest.TestServer(registerModules, env, idx + 1));
+  await Promise.all(testServers.map((server) => server.init()));
+  global.__TEST_SERVERS__ = testServers;
+  global.fetch = fetch;
+  global.env = env;
+  global.registerModules = registerModules;
+}, "setup");
+var jest_globalSetup_default = setup;

package/src/jest.globalTeardown.d.ts

@@ -0,0 +1,3 @@
+declare const teardown: (globalConfig: any, projectConfig: any) => Promise<void>;
+
+export { teardown as default };

package/src/jest.globalTeardown.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jest_globalTeardown_exports = {};
+__export(jest_globalTeardown_exports, {
+  default: () => jest_globalTeardown_default
+});
+module.exports = __toCommonJS(jest_globalTeardown_exports);
+var import_register = require("tsconfig-paths/register");
+const teardown = /* @__PURE__ */ __name(async (globalConfig, projectConfig) => {
+  const testServers = global.__TEST_SERVERS__;
+  if (!testServers) throw new Error("Test servers are not defined");
+  await Promise.all(testServers.map((server) => server.terminate()));
+}, "teardown");
+var jest_globalTeardown_default = teardown;

package/src/jest.setupFilesAfterEnv.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/src/jest.setupFilesAfterEnv.js

@@ -0,0 +1,10 @@
+var import_jest = require("./jest.testServer");
+const { env, fetch } = global;
+jest.setTimeout(3e4);
+global.beforeAll(async () => {
+  import_jest.TestServer.initClient(env);
+  await fetch.cleanup();
+});
+global.afterAll(async () => {
+  await fetch.client.terminate();
+});

package/src/jest.testServer.d.ts

@@ -0,0 +1,44 @@
+import { SshOptions } from 'tunnel-ssh';
+
+type Environment = "testing" | "debug" | "develop" | "main";
+interface BaseEnv {
+    repoName: string;
+    serveDomain: string;
+    appName: string;
+    environment: Environment;
+    operationType: "server" | "client";
+    operationMode: "local" | "edge" | "cloud" | "module";
+    networkType: "mainnet" | "testnet" | "debugnet";
+    tunnelUsername: string;
+    tunnelPassword: string;
+}
+type BackendEnv = BaseEnv & {
+    hostname: string | null;
+    appCode: number;
+    mongo: {
+        username?: string;
+        password?: string;
+        sshOptions?: SshOptions;
+    };
+    redis?: {
+        sshOptions?: SshOptions;
+    };
+    port?: number;
+    mongoUri?: string;
+    redisUri?: string;
+    meiliUri?: string;
+    onCleanup?: () => Promise<void>;
+};
+
+declare class TestServer {
+    #private;
+    workerId: number;
+    static initClient(env: BackendEnv, workerId?: number): void;
+    constructor(registerModules: (options: any) => any[], env: BackendEnv, workerId?: number);
+    init(): Promise<void>;
+    startMongo(): Promise<string>;
+    cleanup(): Promise<void>;
+    terminate(): Promise<void>;
+}
+
+export { TestServer };

package/src/jest.testServer.js

@@ -0,0 +1,160 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var jest_testServer_exports = {};
+__export(jest_testServer_exports, {
+  TestServer: () => TestServer
+});
+module.exports = __toCommonJS(jest_testServer_exports);
+var import_common = require("@akanjs/common");
+var import_server = require("@akanjs/server");
+var import_signal = require("@akanjs/signal");
+var import_mongodb_memory_server = require("mongodb-memory-server");
+var import_mongoose = __toESM(require("mongoose"));
+var import_redis_memory_server = require("redis-memory-server");
+const MAX_RETRY = 5;
+const TEST_LISTEN_PORT_BASE = 38080;
+const TEST_MONGODB_PORT_BASE = 38081;
+const TEST_REDIS_PORT_BASE = 38082;
+const MIN_ACTIVATION_TIME = 0;
+const MAX_ACTIVATION_TIME = 3e4;
+class TestServer {
+  static {
+    __name(this, "TestServer");
+  }
+  #logger = new import_common.Logger("TestServer");
+  #mongod;
+  #redis;
+  #registerModules;
+  #env;
+  workerId;
+  #startAt = Date.now();
+  #app;
+  #portOffset = 0;
+  static initClient(env, workerId = parseInt(process.env.JEST_WORKER_ID ?? "0")) {
+    if (workerId === 0) throw new Error("TestClient should not be used in main thread");
+    const portOffset = workerId * 1e3 + env.appCode * 10;
+    const port = TEST_LISTEN_PORT_BASE + portOffset;
+    const endpoint = `http://localhost:${port}/backend/graphql`;
+    import_signal.client.init({
+      uri: endpoint
+    });
+  }
+  constructor(registerModules, env, workerId) {
+    this.workerId = workerId ?? parseInt(process.env.JEST_WORKER_ID ?? "0");
+    if (this.workerId === 0) throw new Error("TestServer should not be used in main thread");
+    this.#portOffset = this.workerId * 1e3 + env.appCode * 10;
+    this.#mongod = new import_mongodb_memory_server.MongoMemoryServer({
+      instance: {
+        port: TEST_MONGODB_PORT_BASE + this.#portOffset
+      }
+    });
+    this.#redis = new import_redis_memory_server.RedisMemoryServer({
+      instance: {
+        port: TEST_REDIS_PORT_BASE + this.#portOffset
+      }
+    });
+    this.#env = {
+      ...env
+    };
+    this.#registerModules = registerModules;
+  }
+  async init() {
+    for (let i = 0; i < MAX_RETRY; i++) {
+      try {
+        const watchdog = setTimeout(() => {
+          throw new Error("TestServer Init Timeout");
+        }, MAX_ACTIVATION_TIME);
+        await this.#init();
+        clearTimeout(watchdog);
+        return;
+      } catch (e) {
+        this.#logger.error(e);
+        await this.terminate();
+      }
+    }
+  }
+  async #init() {
+    const now = Date.now();
+    this.#logger.log(`Test System #${this.workerId} Initializing...`);
+    const port = TEST_LISTEN_PORT_BASE + this.#portOffset;
+    const [mongoUri, redisHost, redisPort] = await Promise.all([
+      this.startMongo(),
+      this.#redis.getHost(),
+      this.#redis.getPort()
+    ]);
+    this.#env.port = port;
+    this.#env.mongoUri = mongoUri;
+    this.#env.redisUri = `redis://${redisHost}:${redisPort}`;
+    this.#env.meiliUri = "http://localhost:7700/search";
+    this.#env.onCleanup = async () => {
+      await this.cleanup();
+    };
+    this.#app = await (0, import_server.createNestApp)({
+      registerModules: this.#registerModules,
+      env: this.#env
+    });
+    this.#logger.log(`Test System #${this.workerId} Initialized, Mongo: ${mongoUri}, Redis: ${redisHost}:${redisPort}`);
+    this.#startAt = Date.now();
+    this.#logger.log(`Test System #${this.workerId} Activation Time: ${this.#startAt - now}ms`);
+  }
+  async startMongo() {
+    await this.#mongod.start();
+    return this.#mongod.getUri();
+  }
+  async cleanup() {
+    const now = Date.now();
+    this.#logger.log("Mongo Memory Database Cleaning up...");
+    if (this.#mongod.state === "running") {
+      await this.#mongod.stop();
+      await this.#mongod.start(true);
+    }
+    this.#logger.log(`Mongo Memory Database Cleaned up in ${Date.now() - now}ms`);
+  }
+  async terminate() {
+    const now = Date.now();
+    const elapsed = now - this.#startAt;
+    await (0, import_common.sleep)(50);
+    import_signal.client.io?.socket.close();
+    await this.#app.close();
+    if (elapsed < MIN_ACTIVATION_TIME) {
+      this.#logger.log(`waiting for ${MIN_ACTIVATION_TIME - elapsed}`);
+      await (0, import_common.sleep)(MIN_ACTIVATION_TIME - elapsed);
+    }
+    await Promise.all([
+      import_mongoose.default.disconnect(),
+      this.#mongod.stop(),
+      this.#redis.stop()
+    ]);
+    this.#logger.log(`System Terminated in ${Date.now() - now}ms`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestServer
+});

package/src/playwright.config.base.d.ts

@@ -0,0 +1,12 @@
+import { PlaywrightTestConfig } from '@playwright/test';
+
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+declare const withBase: (filename: string, config?: PlaywrightTestConfig) => PlaywrightTestConfig<{}, {}>;
+
+export { withBase };

package/src/playwright.config.base.js

@@ -0,0 +1,71 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var playwright_config_base_exports = {};
+__export(playwright_config_base_exports, {
+  withBase: () => withBase
+});
+module.exports = __toCommonJS(playwright_config_base_exports);
+var import_devkit = require("@nx/devkit");
+var import_preset = require("@nx/playwright/preset");
+var import_test = require("@playwright/test");
+const baseURL = process.env.BASE_URL ?? "http://127.0.0.1:4200";
+const projectName = process.env.NEXT_PUBLIC_APP_NAME ?? "unknown";
+const withBase = /* @__PURE__ */ __name((filename, config = {}) => (0, import_test.defineConfig)({
+  ...(0, import_preset.nxE2EPreset)(filename, {
+    testDir: "./app"
+  }),
+  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+  use: {
+    baseURL,
+    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+    trace: "on-first-retry"
+  },
+  /* Run your local dev server before starting the tests */
+  webServer: {
+    command: `nx serve ${projectName}`,
+    url: "http://127.0.0.1:4200",
+    reuseExistingServer: !process.env.CI,
+    cwd: import_devkit.workspaceRoot
+  },
+  projects: [
+    {
+      name: "chromium",
+      use: {
+        ...import_test.devices["Desktop Chrome"]
+      }
+    },
+    {
+      name: "firefox",
+      use: {
+        ...import_test.devices["Desktop Firefox"]
+      }
+    },
+    {
+      name: "webkit",
+      use: {
+        ...import_test.devices["Desktop Safari"]
+      }
+    }
+  ],
+  ...config
+}), "withBase");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withBase
+});

package/src/playwright.pageAgent.d.ts

@@ -0,0 +1,14 @@
+import { Page } from '@playwright/test';
+export { expect, test } from '@playwright/test';
+
+declare class PageAgent {
+    #private;
+    readonly page: Page;
+    constructor(page: Page);
+    goto(path: string): Promise<void>;
+    waitForPathChange(path?: string): Promise<unknown>;
+    wait(ms?: number): Promise<void>;
+    url(): string;
+}
+
+export { PageAgent };

package/src/playwright.pageAgent.js

@@ -0,0 +1,74 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var playwright_pageAgent_exports = {};
+__export(playwright_pageAgent_exports, {
+  PageAgent: () => PageAgent,
+  expect: () => import_test2.expect,
+  test: () => import_test.test
+});
+module.exports = __toCommonJS(playwright_pageAgent_exports);
+var import_test = require("@playwright/test");
+var import_test2 = require("@playwright/test");
+class PageAgent {
+  static {
+    __name(this, "PageAgent");
+  }
+  page;
+  #defaultWaitMs = 500;
+  #isInitialized = false;
+  constructor(page) {
+    this.page = page;
+  }
+  async goto(path) {
+    await Promise.all([
+      this.page.goto(path),
+      this.waitForPathChange(path)
+    ]);
+    if (!this.#isInitialized) {
+      this.#isInitialized = true;
+    }
+  }
+  async waitForPathChange(path) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Timeout waiting for pathChange message"));
+      }, 3e4);
+      this.page.on("console", (msg) => {
+        if (msg.type() === "log" && msg.text().startsWith(`%cpathChange-finished:${path ?? ""}`)) {
+          clearInterval(timeout);
+          setTimeout(() => {
+            resolve(true);
+          }, this.#defaultWaitMs);
+        }
+      });
+    });
+  }
+  async wait(ms = this.#defaultWaitMs) {
+    await this.page.waitForTimeout(ms);
+  }
+  url() {
+    return "/" + this.page.url().split("/").slice(4).join("/");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PageAgent,
+  expect,
+  test
+});

package/src/sample.d.ts

@@ -0,0 +1,17 @@
+import { Dayjs } from 'dayjs';
+
+declare const sample: Chance.Chance & {
+    dayjs: (opt?: {
+        string?: boolean | undefined;
+        american?: boolean | undefined;
+        year?: number | undefined;
+        month?: number | undefined;
+        day?: number | undefined;
+        min?: Dayjs | undefined;
+        max?: Dayjs | undefined;
+    }) => Dayjs;
+    pick: <T = any>(arr: T[] | readonly T[]) => T;
+    picks: <T>(arr: T[] | readonly T[], count?: number, allowDuplicate?: boolean) => T[];
+};
+
+export { sample };

package/src/sample.js

@@ -0,0 +1,50 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var sample_exports = {};
+__export(sample_exports, {
+  sample: () => sample
+});
+module.exports = __toCommonJS(sample_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_chance = __toESM(require("chance"));
+const chance = new import_chance.default();
+const sample = Object.assign(chance, {
+  dayjs: /* @__PURE__ */ __name((opt) => (0, import_base.dayjs)(chance.date({
+    ...opt,
+    min: opt?.min?.toDate(),
+    max: opt?.max?.toDate()
+  })), "dayjs"),
+  pick: import_common.randomPick,
+  picks: import_common.randomPicks
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sample
+});