@prisma/ts-builders 6.6.0-dev.100

package/dist/Class.test.js

@@ -0,0 +1,56 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_Class = require("./Class");
+var import_GenericParameter = require("./GenericParameter");
+var import_Method = require("./Method");
+var import_NamedType = require("./NamedType");
+var import_Property = require("./Property");
+var import_stringify = require("./stringify");
+const A = (0, import_NamedType.namedType)("A");
+(0, import_vitest.test)("empty", () => {
+  const obj = (0, import_Class.classDeclaration)("MyClass");
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "class MyClass {}
+    "
+  `);
+});
+(0, import_vitest.test)("with property", () => {
+  const obj = (0, import_Class.classDeclaration)("SomeClass").add((0, import_Property.property)("foo", A));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "class SomeClass {
+      foo: A
+    }"
+  `);
+});
+(0, import_vitest.test)("with method", () => {
+  const obj = (0, import_Class.classDeclaration)("MyClass").add((0, import_Method.method)("doThing"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "class MyClass {
+      doThing(): void
+    }"
+  `);
+});
+(0, import_vitest.test)("with generic parameter", () => {
+  const obj = (0, import_Class.classDeclaration)("SomeClass").addGenericParameter((0, import_GenericParameter.genericParameter)("T").extends((0, import_NamedType.namedType)("U"))).add((0, import_Property.property)("foo", A));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "class SomeClass<T extends U> {
+      foo: A
+    }"
+  `);
+});
+(0, import_vitest.test)("extending the type", () => {
+  const obj = (0, import_Class.classDeclaration)("SomeClass").extends((0, import_NamedType.namedType)("Foo")).add((0, import_Property.property)("foo", A));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "class SomeClass extends Foo {
+      foo: A
+    }"
+  `);
+});
+(0, import_vitest.test)("extending multiple types", () => {
+  const obj = (0, import_Class.classDeclaration)("SomeClass").extends((0, import_NamedType.namedType)("Foo")).extends((0, import_NamedType.namedType)("Bar")).add((0, import_Property.property)("foo", A));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "class SomeClass extends Foo, Bar {
+      foo: A
+    }"
+  `);
+});

package/dist/Class.test.mjs

@@ -0,0 +1,55 @@
+import { expect, test } from "vitest";
+import { classDeclaration } from "./Class";
+import { genericParameter } from "./GenericParameter";
+import { method } from "./Method";
+import { namedType } from "./NamedType";
+import { property } from "./Property";
+import { stringify } from "./stringify";
+const A = namedType("A");
+test("empty", () => {
+  const obj = classDeclaration("MyClass");
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "class MyClass {}
+    "
+  `);
+});
+test("with property", () => {
+  const obj = classDeclaration("SomeClass").add(property("foo", A));
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "class SomeClass {
+      foo: A
+    }"
+  `);
+});
+test("with method", () => {
+  const obj = classDeclaration("MyClass").add(method("doThing"));
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "class MyClass {
+      doThing(): void
+    }"
+  `);
+});
+test("with generic parameter", () => {
+  const obj = classDeclaration("SomeClass").addGenericParameter(genericParameter("T").extends(namedType("U"))).add(property("foo", A));
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "class SomeClass<T extends U> {
+      foo: A
+    }"
+  `);
+});
+test("extending the type", () => {
+  const obj = classDeclaration("SomeClass").extends(namedType("Foo")).add(property("foo", A));
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "class SomeClass extends Foo {
+      foo: A
+    }"
+  `);
+});
+test("extending multiple types", () => {
+  const obj = classDeclaration("SomeClass").extends(namedType("Foo")).extends(namedType("Bar")).add(property("foo", A));
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "class SomeClass extends Foo, Bar {
+      foo: A
+    }"
+  `);
+});

package/dist/ConstDeclaration.d.ts

@@ -0,0 +1,16 @@
+import { BasicBuilder } from './BasicBuilder';
+import { DocComment } from './DocComment';
+import { TypeBuilder } from './TypeBuilder';
+import { ValueBuilder } from './ValueBuilder';
+import { Writer } from './Writer';
+export declare class ConstDeclaration implements BasicBuilder {
+    readonly name: string;
+    readonly type?: TypeBuilder | undefined;
+    private docComment?;
+    private value?;
+    constructor(name: string, type?: TypeBuilder | undefined);
+    setDocComment(docComment: DocComment): this;
+    setValue(value: ValueBuilder): this;
+    write(writer: Writer): void;
+}
+export declare function constDeclaration(name: string, type?: TypeBuilder): ConstDeclaration;

package/dist/ConstDeclaration.js

@@ -0,0 +1,60 @@
+"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 ConstDeclaration_exports = {};
+__export(ConstDeclaration_exports, {
+  ConstDeclaration: () => ConstDeclaration,
+  constDeclaration: () => constDeclaration
+});
+module.exports = __toCommonJS(ConstDeclaration_exports);
+class ConstDeclaration {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+  }
+  docComment;
+  value;
+  setDocComment(docComment) {
+    this.docComment = docComment;
+    return this;
+  }
+  setValue(value) {
+    this.value = value;
+    return this;
+  }
+  write(writer) {
+    if (this.docComment) {
+      writer.write(this.docComment);
+    }
+    writer.write("const ").write(this.name);
+    if (this.type) {
+      writer.write(": ").write(this.type);
+    }
+    if (this.value) {
+      writer.write(" = ").write(this.value);
+    }
+  }
+}
+function constDeclaration(name, type) {
+  return new ConstDeclaration(name, type);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConstDeclaration,
+  constDeclaration
+});

package/dist/ConstDeclaration.mjs

@@ -0,0 +1,35 @@
+class ConstDeclaration {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+  }
+  docComment;
+  value;
+  setDocComment(docComment) {
+    this.docComment = docComment;
+    return this;
+  }
+  setValue(value) {
+    this.value = value;
+    return this;
+  }
+  write(writer) {
+    if (this.docComment) {
+      writer.write(this.docComment);
+    }
+    writer.write("const ").write(this.name);
+    if (this.type) {
+      writer.write(": ").write(this.type);
+    }
+    if (this.value) {
+      writer.write(" = ").write(this.value);
+    }
+  }
+}
+function constDeclaration(name, type) {
+  return new ConstDeclaration(name, type);
+}
+export {
+  ConstDeclaration,
+  constDeclaration
+};

package/dist/ConstDeclaration.test.d.ts

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

package/dist/ConstDeclaration.test.js

@@ -0,0 +1,19 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_ConstDeclaration = require("./ConstDeclaration");
+var import_DocComment = require("./DocComment");
+var import_NamedType = require("./NamedType");
+var import_stringify = require("./stringify");
+const A = (0, import_NamedType.namedType)("A");
+(0, import_vitest.test)("basic", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_ConstDeclaration.constDeclaration)("B", A))).toMatchInlineSnapshot(`"const B: A"`);
+});
+(0, import_vitest.test)("with doc comment", () => {
+  const decl = (0, import_ConstDeclaration.constDeclaration)("B", A).setDocComment((0, import_DocComment.docComment)("Some important value"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(decl)).toMatchInlineSnapshot(`
+    "/**
+     * Some important value
+     */
+    const B: A"
+  `);
+});

package/dist/ConstDeclaration.test.mjs

@@ -0,0 +1,18 @@
+import { expect, test } from "vitest";
+import { constDeclaration } from "./ConstDeclaration";
+import { docComment } from "./DocComment";
+import { namedType } from "./NamedType";
+import { stringify } from "./stringify";
+const A = namedType("A");
+test("basic", () => {
+  expect(stringify(constDeclaration("B", A))).toMatchInlineSnapshot(`"const B: A"`);
+});
+test("with doc comment", () => {
+  const decl = constDeclaration("B", A).setDocComment(docComment("Some important value"));
+  expect(stringify(decl)).toMatchInlineSnapshot(`
+    "/**
+     * Some important value
+     */
+    const B: A"
+  `);
+});

package/dist/DocComment.d.ts

@@ -0,0 +1,11 @@
+import { BasicBuilder } from './BasicBuilder';
+import { Writer } from './Writer';
+export declare class DocComment implements BasicBuilder {
+    readonly lines: string[];
+    constructor(startingText?: string);
+    addText(text: string): this;
+    write(writer: Writer): Writer<undefined>;
+}
+declare function docComment(strings: TemplateStringsArray, ...args: string[]): DocComment;
+declare function docComment(startingText?: string): DocComment;
+export { docComment };

package/dist/DocComment.js

@@ -0,0 +1,101 @@
+"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 DocComment_exports = {};
+__export(DocComment_exports, {
+  DocComment: () => DocComment,
+  docComment: () => docComment
+});
+module.exports = __toCommonJS(DocComment_exports);
+class DocComment {
+  lines = [];
+  constructor(startingText) {
+    if (startingText) {
+      this.addText(startingText);
+    }
+  }
+  addText(text) {
+    this.lines.push(...text.split("\n"));
+    return this;
+  }
+  write(writer) {
+    writer.writeLine("/**");
+    for (const line of this.lines) {
+      writer.writeLine(` * ${line}`);
+    }
+    writer.writeLine(" */");
+    return writer;
+  }
+}
+function docComment(firstParameter, ...args) {
+  if (typeof firstParameter === "string" || typeof firstParameter === "undefined") {
+    return new DocComment(firstParameter);
+  }
+  return docCommentTag(firstParameter, args);
+}
+function docCommentTag(strings, args) {
+  const docComment2 = new DocComment();
+  const fullText = strings.flatMap((str, i) => {
+    if (i < args.length) {
+      return [str, args[i]];
+    }
+    return [str];
+  }).join("");
+  const lines = trimEmptyLines(fullText.split("\n"));
+  if (lines.length === 0) {
+    return docComment2;
+  }
+  const indent = getIndent(lines[0]);
+  for (const line of lines) {
+    docComment2.addText(line.slice(indent));
+  }
+  return docComment2;
+}
+function trimEmptyLines(lines) {
+  const firstLine = findFirstNonEmptyLine(lines);
+  const lastLine = findLastNonEmptyLine(lines);
+  if (firstLine === -1 || lastLine === -1) {
+    return [];
+  }
+  return lines.slice(firstLine, lastLine + 1);
+}
+function findFirstNonEmptyLine(lines) {
+  return lines.findIndex((line) => !isEmptyLine(line));
+}
+function findLastNonEmptyLine(lines) {
+  let i = lines.length - 1;
+  while (i > 0 && isEmptyLine(lines[i])) {
+    i--;
+  }
+  return i;
+}
+function isEmptyLine(line) {
+  return line.trim().length === 0;
+}
+function getIndent(line) {
+  let indent = 0;
+  while (line[indent] === " ") {
+    indent++;
+  }
+  return indent;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DocComment,
+  docComment
+});

package/dist/DocComment.mjs

@@ -0,0 +1,76 @@
+class DocComment {
+  lines = [];
+  constructor(startingText) {
+    if (startingText) {
+      this.addText(startingText);
+    }
+  }
+  addText(text) {
+    this.lines.push(...text.split("\n"));
+    return this;
+  }
+  write(writer) {
+    writer.writeLine("/**");
+    for (const line of this.lines) {
+      writer.writeLine(` * ${line}`);
+    }
+    writer.writeLine(" */");
+    return writer;
+  }
+}
+function docComment(firstParameter, ...args) {
+  if (typeof firstParameter === "string" || typeof firstParameter === "undefined") {
+    return new DocComment(firstParameter);
+  }
+  return docCommentTag(firstParameter, args);
+}
+function docCommentTag(strings, args) {
+  const docComment2 = new DocComment();
+  const fullText = strings.flatMap((str, i) => {
+    if (i < args.length) {
+      return [str, args[i]];
+    }
+    return [str];
+  }).join("");
+  const lines = trimEmptyLines(fullText.split("\n"));
+  if (lines.length === 0) {
+    return docComment2;
+  }
+  const indent = getIndent(lines[0]);
+  for (const line of lines) {
+    docComment2.addText(line.slice(indent));
+  }
+  return docComment2;
+}
+function trimEmptyLines(lines) {
+  const firstLine = findFirstNonEmptyLine(lines);
+  const lastLine = findLastNonEmptyLine(lines);
+  if (firstLine === -1 || lastLine === -1) {
+    return [];
+  }
+  return lines.slice(firstLine, lastLine + 1);
+}
+function findFirstNonEmptyLine(lines) {
+  return lines.findIndex((line) => !isEmptyLine(line));
+}
+function findLastNonEmptyLine(lines) {
+  let i = lines.length - 1;
+  while (i > 0 && isEmptyLine(lines[i])) {
+    i--;
+  }
+  return i;
+}
+function isEmptyLine(line) {
+  return line.trim().length === 0;
+}
+function getIndent(line) {
+  let indent = 0;
+  while (line[indent] === " ") {
+    indent++;
+  }
+  return indent;
+}
+export {
+  DocComment,
+  docComment
+};

package/dist/DocComment.test.d.ts

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

package/dist/DocComment.test.js

@@ -0,0 +1,80 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_DocComment = require("./DocComment");
+var import_stringify = require("./stringify");
+(0, import_vitest.test)("empty", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_DocComment.docComment)())).toMatchInlineSnapshot(`
+    "/**
+     */
+    "
+  `);
+});
+(0, import_vitest.test)("one line", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_DocComment.docComment)("I am comment"))).toMatchInlineSnapshot(`
+    "/**
+     * I am comment
+     */
+    "
+  `);
+});
+(0, import_vitest.test)("multiline", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_DocComment.docComment)("first\nsecond"))).toMatchInlineSnapshot(`
+    "/**
+     * first
+     * second
+     */
+    "
+  `);
+});
+(0, import_vitest.test)("multiple addText calls", () => {
+  const comment = (0, import_DocComment.docComment)("Line 1").addText("Line 2").addText("Line 3");
+  (0, import_vitest.expect)((0, import_stringify.stringify)(comment)).toMatchInlineSnapshot(`
+    "/**
+     * Line 1
+     * Line 2
+     * Line 3
+     */
+    "
+  `);
+});
+(0, import_vitest.test)("tagged template - empty", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)(import_DocComment.docComment``)).toMatchInlineSnapshot(`
+    "/**
+     */
+    "
+  `);
+});
+(0, import_vitest.test)("tagged template - spaces only", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)(import_DocComment.docComment`    `)).toMatchInlineSnapshot(`
+    "/**
+     */
+    "
+  `);
+});
+(0, import_vitest.test)("tagged template - with content", () => {
+  const comment = import_DocComment.docComment`
+        This is a multiline comment
+           - this line should be indented
+        And this should be not
+    `;
+  (0, import_vitest.expect)((0, import_stringify.stringify)(comment)).toMatchInlineSnapshot(`
+    "/**
+     * This is a multiline comment
+     *    - this line should be indented
+     * And this should be not
+     */
+    "
+  `);
+});
+(0, import_vitest.test)("tagged template - with substitutions", () => {
+  const name = "World";
+  const comment = import_DocComment.docComment`
+    Hello, ${name}!
+  `;
+  (0, import_vitest.expect)((0, import_stringify.stringify)(comment)).toMatchInlineSnapshot(`
+    "/**
+     * Hello, World!
+     */
+    "
+  `);
+});

package/dist/DocComment.test.mjs

@@ -0,0 +1,79 @@
+import { expect, test } from "vitest";
+import { docComment } from "./DocComment";
+import { stringify } from "./stringify";
+test("empty", () => {
+  expect(stringify(docComment())).toMatchInlineSnapshot(`
+    "/**
+     */
+    "
+  `);
+});
+test("one line", () => {
+  expect(stringify(docComment("I am comment"))).toMatchInlineSnapshot(`
+    "/**
+     * I am comment
+     */
+    "
+  `);
+});
+test("multiline", () => {
+  expect(stringify(docComment("first\nsecond"))).toMatchInlineSnapshot(`
+    "/**
+     * first
+     * second
+     */
+    "
+  `);
+});
+test("multiple addText calls", () => {
+  const comment = docComment("Line 1").addText("Line 2").addText("Line 3");
+  expect(stringify(comment)).toMatchInlineSnapshot(`
+    "/**
+     * Line 1
+     * Line 2
+     * Line 3
+     */
+    "
+  `);
+});
+test("tagged template - empty", () => {
+  expect(stringify(docComment``)).toMatchInlineSnapshot(`
+    "/**
+     */
+    "
+  `);
+});
+test("tagged template - spaces only", () => {
+  expect(stringify(docComment`    `)).toMatchInlineSnapshot(`
+    "/**
+     */
+    "
+  `);
+});
+test("tagged template - with content", () => {
+  const comment = docComment`
+        This is a multiline comment
+           - this line should be indented
+        And this should be not
+    `;
+  expect(stringify(comment)).toMatchInlineSnapshot(`
+    "/**
+     * This is a multiline comment
+     *    - this line should be indented
+     * And this should be not
+     */
+    "
+  `);
+});
+test("tagged template - with substitutions", () => {
+  const name = "World";
+  const comment = docComment`
+    Hello, ${name}!
+  `;
+  expect(stringify(comment)).toMatchInlineSnapshot(`
+    "/**
+     * Hello, World!
+     */
+    "
+  `);
+});

package/dist/Export.d.ts

@@ -0,0 +1,12 @@
+import { AnyDeclarationBuilder } from './AnyDeclarationBuilder';
+import { BasicBuilder } from './BasicBuilder';
+import { DocComment } from './DocComment';
+import { Writer } from './Writer';
+export declare class Export<Decl extends AnyDeclarationBuilder> implements BasicBuilder {
+    readonly declaration: Decl;
+    private docComment?;
+    constructor(declaration: Decl);
+    setDocComment(docComment: DocComment): this;
+    write(writer: Writer): void;
+}
+export declare function moduleExport<Decl extends AnyDeclarationBuilder>(declaration: Decl): Export<Decl>;

package/dist/Export.js

@@ -0,0 +1,48 @@
+"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 Export_exports = {};
+__export(Export_exports, {
+  Export: () => Export,
+  moduleExport: () => moduleExport
+});
+module.exports = __toCommonJS(Export_exports);
+class Export {
+  constructor(declaration) {
+    this.declaration = declaration;
+  }
+  docComment;
+  setDocComment(docComment) {
+    this.docComment = docComment;
+    return this;
+  }
+  write(writer) {
+    if (this.docComment) {
+      writer.write(this.docComment);
+    }
+    writer.write("export ").write(this.declaration);
+  }
+}
+function moduleExport(declaration) {
+  return new Export(declaration);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Export,
+  moduleExport
+});