@ohos-ports/prisma-internals 7.10.0-beta.0

package/dist/schemaEngineCommands.js

@@ -0,0 +1,36 @@
+"use strict";
+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 schemaEngineCommands_exports = {};
+__export(schemaEngineCommands_exports, {
+  SchemaEngineExitCode: () => import_chunk_CXEXLFVL.SchemaEngineExitCode,
+  canConnectToDatabase: () => import_chunk_CXEXLFVL.canConnectToDatabase,
+  createDatabase: () => import_chunk_CXEXLFVL.createDatabase,
+  dropDatabase: () => import_chunk_CXEXLFVL.dropDatabase,
+  execaCommand: () => import_chunk_CXEXLFVL.execaCommand
+});
+module.exports = __toCommonJS(schemaEngineCommands_exports);
+var import_chunk_CXEXLFVL = require("./chunk-CXEXLFVL.js");
+var import_chunk_JOIHHXR6 = require("./chunk-JOIHHXR6.js");
+var import_chunk_5PJQQKQI = require("./chunk-5PJQQKQI.js");
+var import_chunk_M3GBKLGE = require("./chunk-M3GBKLGE.js");
+var import_chunk_E476ARWS = require("./chunk-E476ARWS.js");
+var import_chunk_TWSLDIFL = require("./chunk-TWSLDIFL.js");
+var import_chunk_5DBOS77Y = require("./chunk-5DBOS77Y.js");
+var import_chunk_5VQNKCKW = require("./chunk-5VQNKCKW.js");
+var import_chunk_4VNS5WPM = require("./chunk-4VNS5WPM.js");

package/dist/sendPanic.d.ts

@@ -0,0 +1,10 @@
+import type { MigrateTypes } from './migrateTypes';
+import type { RustPanic } from './panic';
+type SendPanic = {
+    error: RustPanic;
+    cliVersion: string;
+    enginesVersion: string;
+    getDatabaseVersionSafe: (args: MigrateTypes.GetDatabaseVersionParams | undefined) => Promise<string | undefined>;
+};
+export declare function sendPanic({ error, cliVersion, enginesVersion, getDatabaseVersionSafe, }: SendPanic): Promise<number>;
+export {};

package/dist/sendPanic.js

@@ -0,0 +1,29 @@
+"use strict";
+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 sendPanic_exports = {};
+__export(sendPanic_exports, {
+  sendPanic: () => import_chunk_FRVJZOHP.sendPanic
+});
+module.exports = __toCommonJS(sendPanic_exports);
+var import_chunk_FRVJZOHP = require("./chunk-FRVJZOHP.js");
+var import_chunk_YNDZCLVL = require("./chunk-YNDZCLVL.js");
+var import_chunk_LMVSIVKQ = require("./chunk-LMVSIVKQ.js");
+var import_chunk_5AI4FIZ3 = require("./chunk-5AI4FIZ3.js");
+var import_chunk_NVNI2SRU = require("./chunk-NVNI2SRU.js");
+var import_chunk_4VNS5WPM = require("./chunk-4VNS5WPM.js");

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+import type { ConnectorType } from '@prisma/generator';
+export interface DatabaseCredentials {
+    type: ConnectorType;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+    alreadyData?: boolean;
+    schema?: string;
+    newSchema?: string;
+    ssl?: boolean;
+    uri?: string;
+    executeRaw?: boolean;
+    socket?: string;
+    extraFields?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Given a type T and a key K, return a new type that is T + the key K marked as required.
+ * E.g.:
+ * ```
+ * type T = {
+ *   a?: string
+ *   b: number
+ *   c?: string
+ *   d?: boolean
+ * }
+ * type R = RequireKey<T, 'a' | 'c'>
+ * // R is { a: string, b: number, c: string, d?: boolean }
+ * ```
+ */
+export type RequireKey<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;

package/dist/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils/__tests__/isCi.test.js

@@ -0,0 +1,58 @@
+"use strict";
+var import_chunk_VFNP7Q3Y = require("../../chunk-VFNP7Q3Y.js");
+var import_chunk_H4NI2RIK = require("../../chunk-H4NI2RIK.js");
+var import_chunk_4VNS5WPM = require("../../chunk-4VNS5WPM.js");
+var originalEnv = { ...process.env };
+var originalStdinisTTY = process.stdin.isTTY;
+function restoreEnv() {
+  for (const key of Object.keys(process.env)) {
+    if (!(key in originalEnv)) {
+      delete process.env[key];
+    }
+  }
+  for (const [key, value] of Object.entries(originalEnv)) {
+    if (value === void 0) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+}
+(0, import_chunk_VFNP7Q3Y.describe)("isCi", () => {
+  (0, import_chunk_VFNP7Q3Y.beforeEach)(() => {
+    restoreEnv();
+    process.stdin.isTTY = originalStdinisTTY;
+  });
+  (0, import_chunk_VFNP7Q3Y.afterAll)(() => {
+    restoreEnv();
+    process.stdin.isTTY = originalStdinisTTY;
+  });
+  (0, import_chunk_VFNP7Q3Y.describe)("in non TTY environment", () => {
+    (0, import_chunk_VFNP7Q3Y.beforeEach)(() => {
+      delete process.env.GITHUB_ACTIONS;
+      delete process.env.CI;
+      process.stdin.isTTY = false;
+    });
+    (0, import_chunk_VFNP7Q3Y.test)("with undefined env vars, isCi should be false", () => {
+      (0, import_chunk_VFNP7Q3Y.globalExpect)((0, import_chunk_H4NI2RIK.isCi)()).toBe(false);
+    });
+  });
+  (0, import_chunk_VFNP7Q3Y.describe)("in TTY environment", () => {
+    (0, import_chunk_VFNP7Q3Y.beforeEach)(() => {
+      delete process.env.GITHUB_ACTIONS;
+      delete process.env.CI;
+      process.stdin.isTTY = true;
+    });
+    (0, import_chunk_VFNP7Q3Y.test)("with CI env var, isCi should be true", () => {
+      process.env.CI = "true";
+      (0, import_chunk_VFNP7Q3Y.globalExpect)((0, import_chunk_H4NI2RIK.isCi)()).toBe(true);
+    });
+    (0, import_chunk_VFNP7Q3Y.test)("with GitHub Actions env var, isCi should be true", () => {
+      process.env.GITHUB_ACTIONS = "true";
+      (0, import_chunk_VFNP7Q3Y.globalExpect)((0, import_chunk_H4NI2RIK.isCi)()).toBe(true);
+    });
+    (0, import_chunk_VFNP7Q3Y.test)("with undefined env vars, isCi should be false", () => {
+      (0, import_chunk_VFNP7Q3Y.globalExpect)((0, import_chunk_H4NI2RIK.isCi)()).toBe(false);
+    });
+  });
+});

package/dist/utils/__tests__/isInteractive.test.js

@@ -0,0 +1,47 @@
+"use strict";
+var import_chunk_VFNP7Q3Y = require("../../chunk-VFNP7Q3Y.js");
+var import_chunk_ICFLO5JW = require("../../chunk-ICFLO5JW.js");
+var import_chunk_4VNS5WPM = require("../../chunk-4VNS5WPM.js");
+var originalEnv = { ...process.env };
+function restoreEnv() {
+  for (const key of Object.keys(process.env)) {
+    if (!(key in originalEnv)) {
+      delete process.env[key];
+    }
+  }
+  for (const [key, value] of Object.entries(originalEnv)) {
+    if (value === void 0) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+}
+(0, import_chunk_VFNP7Q3Y.describe)("isInteractive", () => {
+  (0, import_chunk_VFNP7Q3Y.beforeEach)(() => {
+    restoreEnv();
+  });
+  (0, import_chunk_VFNP7Q3Y.afterAll)(() => {
+    restoreEnv();
+  });
+  (0, import_chunk_VFNP7Q3Y.describe)("in non TTY environment", () => {
+    const mockedValue = { isTTY: false };
+    (0, import_chunk_VFNP7Q3Y.test)("isInteractive should be false", () => {
+      (0, import_chunk_VFNP7Q3Y.globalExpect)((0, import_chunk_ICFLO5JW.isInteractive)({ stream: mockedValue })).toBe(false);
+    });
+    (0, import_chunk_VFNP7Q3Y.test)("isInteractive should be false if TERM = dumb", () => {
+      process.env.TERM = "dumb";
+      (0, import_chunk_VFNP7Q3Y.globalExpect)((0, import_chunk_ICFLO5JW.isInteractive)({ stream: mockedValue })).toBe(false);
+    });
+  });
+  (0, import_chunk_VFNP7Q3Y.describe)("in TTY environment", () => {
+    const mockedValue = { isTTY: true };
+    (0, import_chunk_VFNP7Q3Y.test)("isInteractive should be true", () => {
+      (0, import_chunk_VFNP7Q3Y.globalExpect)((0, import_chunk_ICFLO5JW.isInteractive)({ stream: mockedValue })).toBe(true);
+    });
+    (0, import_chunk_VFNP7Q3Y.test)("isInteractive should be false if TERM = dumb", () => {
+      process.env.TERM = "dumb";
+      (0, import_chunk_VFNP7Q3Y.globalExpect)((0, import_chunk_ICFLO5JW.isInteractive)({ stream: mockedValue })).toBe(false);
+    });
+  });
+});

package/dist/utils/assertAlways.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Assertion function for internal consistency checks that should never fail
+ * in the correct code. It's purpose is pretty much:
+ * - ensuring we get more helpful error message if invariant does not hold due to a bug
+ * - have a better way of dealing with overly broad type definition than typecasting to `any`
+ * or more narrow type.
+ *
+ * This function should be for assertions only on the values where we control both the input and the output: engine to client, generator to generated client, etc.
+ * Don't use this function for assertion for any external input.
+ *
+ * @param condition
+ * @param message
+ */
+export declare function assertAlways(condition: unknown, message: string): asserts condition;

package/dist/utils/assertAlways.js

@@ -0,0 +1,25 @@
+"use strict";
+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 assertAlways_exports = {};
+__export(assertAlways_exports, {
+  assertAlways: () => import_chunk_Y4TOGY6I.assertAlways
+});
+module.exports = __toCommonJS(assertAlways_exports);
+var import_chunk_Y4TOGY6I = require("../chunk-Y4TOGY6I.js");
+var import_chunk_4VNS5WPM = require("../chunk-4VNS5WPM.js");

package/dist/utils/assertNever.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Utility function to ensure exhaustive checks for union types.
+ *
+ * @example
+ *   ```ts
+ *   declare const fruit: 'Apple' | 'Orange'
+ *
+ *   switch (fruit) {
+ *     case 'Apple:
+ *       // do apple things
+ *       break;
+ *     case 'Orange:
+ *       // do orange things
+ *       break;
+ *     default:
+ *       // in case `fruit` type will expand in the future,
+ *       // we'll get a compile-time error here, listing all unhandled
+ *       // cases
+ *       assertNever(fruit, 'Unknown fruit')
+ *   }
+ *   ```
+ * @param arg variable of the any union type. By the time `assertNever` is called
+ * all possible cases of this union must already be handled
+ * @param errorMessage error message to throw in runtime. Normally, should never happen
+ * unless compile-time check is skipped
+ */
+export declare function assertNever(arg: never, errorMessage: string): never;

package/dist/utils/assertNever.js

@@ -0,0 +1,25 @@
+"use strict";
+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 assertNever_exports = {};
+__export(assertNever_exports, {
+  assertNever: () => import_chunk_IL7PSY44.assertNever
+});
+module.exports = __toCommonJS(assertNever_exports);
+var import_chunk_IL7PSY44 = require("../chunk-IL7PSY44.js");
+var import_chunk_4VNS5WPM = require("../chunk-4VNS5WPM.js");

package/dist/utils/binaryTargetRegex.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This regex matches all supported binary target names in a given string.
+ *
+ * Platform names are sorted by their lengths in descending order to ensure that
+ * the longest substring is always matched (e.g., "darwin-arm64" is matched as a
+ * whole instead of "darwin" and "arm" separately)
+ */
+export declare const binaryTargetRegex: RegExp;

package/dist/utils/binaryTargetRegex.js

@@ -0,0 +1,25 @@
+"use strict";
+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 binaryTargetRegex_exports = {};
+__export(binaryTargetRegex_exports, {
+  binaryTargetRegex: () => import_chunk_DODIJPCS.binaryTargetRegex
+});
+module.exports = __toCommonJS(binaryTargetRegex_exports);
+var import_chunk_DODIJPCS = require("../chunk-DODIJPCS.js");
+var import_chunk_4VNS5WPM = require("../chunk-4VNS5WPM.js");

package/dist/utils/callOnce.d.ts

@@ -0,0 +1,13 @@
+type AsyncFn<Args extends unknown[], R> = (...args: Args) => Promise<R>;
+/**
+ * Takes an async function `fn` as a parameter and returns a wrapper function, which ensures
+ * that `fn` will be called only once if the promise succeeds:
+ *
+ * - If the first call is not finished yet, returns the promise to the same result
+ * - If the first call is finished and has succeeded, returns the result of this call
+ * - If the first call is finished but has failed, `fn` is called again
+ * @param fn
+ * @returns
+ */
+export declare function callOnceOnSuccess<Args extends unknown[], R>(fn: AsyncFn<Args, R>): AsyncFn<Args, R>;
+export {};

package/dist/utils/callOnce.js

@@ -0,0 +1,25 @@
+"use strict";
+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 callOnce_exports = {};
+__export(callOnce_exports, {
+  callOnceOnSuccess: () => import_chunk_NIWBAJZV.callOnceOnSuccess
+});
+module.exports = __toCommonJS(callOnce_exports);
+var import_chunk_NIWBAJZV = require("../chunk-NIWBAJZV.js");
+var import_chunk_4VNS5WPM = require("../chunk-4VNS5WPM.js");

package/dist/utils/callOnce.test.d.ts

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

package/dist/utils/callOnce.test.js

@@ -0,0 +1,36 @@
+"use strict";
+var import_chunk_VFNP7Q3Y = require("../chunk-VFNP7Q3Y.js");
+var import_chunk_NIWBAJZV = require("../chunk-NIWBAJZV.js");
+var import_chunk_4VNS5WPM = require("../chunk-4VNS5WPM.js");
+(0, import_chunk_VFNP7Q3Y.test)("returns the result correctly", async () => {
+  const wrapper = (0, import_chunk_NIWBAJZV.callOnceOnSuccess)(import_chunk_VFNP7Q3Y.vi.fn().mockResolvedValue("hello"));
+  await (0, import_chunk_VFNP7Q3Y.globalExpect)(wrapper()).resolves.toBe("hello");
+});
+(0, import_chunk_VFNP7Q3Y.test)("forwards the arguments correctly", async () => {
+  const wrapper = (0, import_chunk_NIWBAJZV.callOnceOnSuccess)((x) => Promise.resolve(x + 1));
+  await (0, import_chunk_VFNP7Q3Y.globalExpect)(wrapper(2)).resolves.toBe(3);
+});
+(0, import_chunk_VFNP7Q3Y.test)("\u0441alls wrapped function only once before promise resolves", async () => {
+  const wrapped = import_chunk_VFNP7Q3Y.vi.fn().mockResolvedValue("hello");
+  const wrapper = (0, import_chunk_NIWBAJZV.callOnceOnSuccess)(wrapped);
+  void wrapper();
+  void wrapper();
+  await wrapper();
+  (0, import_chunk_VFNP7Q3Y.globalExpect)(wrapped).toHaveBeenCalledTimes(1);
+});
+(0, import_chunk_VFNP7Q3Y.test)("caches the result when it succeeds", async () => {
+  const wrapped = import_chunk_VFNP7Q3Y.vi.fn().mockResolvedValue("hello");
+  const wrapper = (0, import_chunk_NIWBAJZV.callOnceOnSuccess)(wrapped);
+  await wrapper();
+  await wrapper();
+  const result = await wrapper();
+  (0, import_chunk_VFNP7Q3Y.globalExpect)(wrapped).toHaveBeenCalledTimes(1);
+  (0, import_chunk_VFNP7Q3Y.globalExpect)(result).toBe("hello");
+});
+(0, import_chunk_VFNP7Q3Y.test)("does not cache the result when it fails", async () => {
+  const wrapped = import_chunk_VFNP7Q3Y.vi.fn().mockRejectedValue(new Error("hello"));
+  const wrapper = (0, import_chunk_NIWBAJZV.callOnceOnSuccess)(wrapped);
+  await Promise.allSettled([wrapper(), wrapper()]);
+  await (0, import_chunk_VFNP7Q3Y.globalExpect)(wrapper()).rejects.toThrow("hello");
+  (0, import_chunk_VFNP7Q3Y.globalExpect)(wrapped).toHaveBeenCalledTimes(2);
+});

package/dist/utils/canPrompt.d.ts

@@ -0,0 +1 @@
+export declare const canPrompt: () => boolean;

package/dist/utils/canPrompt.js

@@ -0,0 +1,27 @@
+"use strict";
+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 canPrompt_exports = {};
+__export(canPrompt_exports, {
+  canPrompt: () => import_chunk_FCYHZHVW.canPrompt
+});
+module.exports = __toCommonJS(canPrompt_exports);
+var import_chunk_FCYHZHVW = require("../chunk-FCYHZHVW.js");
+var import_chunk_H4NI2RIK = require("../chunk-H4NI2RIK.js");
+var import_chunk_ICFLO5JW = require("../chunk-ICFLO5JW.js");
+var import_chunk_4VNS5WPM = require("../chunk-4VNS5WPM.js");

package/dist/utils/chmodPlusX.d.ts

@@ -0,0 +1 @@
+export declare function chmodPlusX(file: string): void;

package/dist/utils/chmodPlusX.js

@@ -0,0 +1,25 @@
+"use strict";
+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 chmodPlusX_exports = {};
+__export(chmodPlusX_exports, {
+  chmodPlusX: () => import_chunk_TWSLDIFL.chmodPlusX
+});
+module.exports = __toCommonJS(chmodPlusX_exports);
+var import_chunk_TWSLDIFL = require("../chunk-TWSLDIFL.js");
+var import_chunk_4VNS5WPM = require("../chunk-4VNS5WPM.js");

package/dist/utils/drawBox.d.ts

@@ -0,0 +1,9 @@
+export type BoxOptions = {
+    title?: string;
+    width: number;
+    height: number;
+    str: string;
+    horizontalPadding?: number;
+    verticalPadding?: number;
+};
+export declare function drawBox({ title, width, height, str, horizontalPadding }: BoxOptions): string;

package/dist/utils/drawBox.js

@@ -0,0 +1,26 @@
+"use strict";
+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 drawBox_exports = {};
+__export(drawBox_exports, {
+  drawBox: () => import_chunk_HHG4DGHC.drawBox
+});
+module.exports = __toCommonJS(drawBox_exports);
+var import_chunk_HHG4DGHC = require("../chunk-HHG4DGHC.js");
+var import_chunk_PG5FDKSF = require("../chunk-PG5FDKSF.js");
+var import_chunk_4VNS5WPM = require("../chunk-4VNS5WPM.js");

package/dist/utils/extractPreviewFeatures.d.ts

@@ -0,0 +1,2 @@
+import type { GeneratorConfig } from '@prisma/generator';
+export declare function extractPreviewFeatures(generators: GeneratorConfig[]): string[];

package/dist/utils/extractPreviewFeatures.js

@@ -0,0 +1,28 @@
+"use strict";
+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 extractPreviewFeatures_exports = {};
+__export(extractPreviewFeatures_exports, {
+  extractPreviewFeatures: () => import_chunk_EKGEKB22.extractPreviewFeatures
+});
+module.exports = __toCommonJS(extractPreviewFeatures_exports);
+var import_chunk_EKGEKB22 = require("../chunk-EKGEKB22.js");
+var import_chunk_IOIAK7V7 = require("../chunk-IOIAK7V7.js");
+var import_chunk_PG5FDKSF = require("../chunk-PG5FDKSF.js");
+var import_chunk_MCS5ZY6Y = require("../chunk-MCS5ZY6Y.js");
+var import_chunk_4VNS5WPM = require("../chunk-4VNS5WPM.js");

package/dist/utils/formatTable.d.ts

@@ -0,0 +1,5 @@
+type FormatTableOptions = {
+    json?: boolean;
+};
+export declare function formatTable(rows: string[][], options?: FormatTableOptions): string;
+export {};

package/dist/utils/formatTable.js

@@ -0,0 +1,25 @@
+"use strict";
+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 formatTable_exports = {};
+__export(formatTable_exports, {
+  formatTable: () => import_chunk_QN6PSQY7.formatTable
+});
+module.exports = __toCommonJS(formatTable_exports);
+var import_chunk_QN6PSQY7 = require("../chunk-QN6PSQY7.js");
+var import_chunk_4VNS5WPM = require("../chunk-4VNS5WPM.js");

package/dist/utils/formatms.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Formats a time interval in milliseconds, converting it to seconds if `ms` >= 1000.
+ * Returns a string like "3ms" or "3.10s".
+ */
+export declare function formatms(ms: number): string;

package/dist/utils/formatms.js

@@ -0,0 +1,25 @@
+"use strict";
+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 formatms_exports = {};
+__export(formatms_exports, {
+  formatms: () => import_chunk_XYCIH36R.formatms
+});
+module.exports = __toCommonJS(formatms_exports);
+var import_chunk_XYCIH36R = require("../chunk-XYCIH36R.js");
+var import_chunk_4VNS5WPM = require("../chunk-4VNS5WPM.js");