@ttsc/factory 0.15.9 → 0.15.11

package/lib/factory/types/createInferTypeNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createInferTypeNode.mjs","sources":["../../../src/factory/types/createInferTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,mBAAmB,GAAG,CACjC,aAAuC,KACrB,IAAI,CAAC,eAAe,EAAE,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/types/createIntersectionTypeNode.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link IntersectionTypeNode}: an `A & B` type.
+ *
+ * The constituents are joined with `&`. The printer is width-aware: when the
+ * whole intersection fits on one line it stays inline as `A & B`, and when it
+ * has to break it indents and puts each constituent on its own line with a
+ * leading `&`, including a leading `&` before the first member.
+ *
+ * Given the constituents `A` and `B`, the printer renders:
+ *
+ * ```ts
+ * A & B;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param types The constituent types.
+ * @returns The created {@link IntersectionTypeNode}.
+ */
+const createIntersectionTypeNode = (types) => make("IntersectionTypeNode", { types });
+
+export { createIntersectionTypeNode };
+//# sourceMappingURL=createIntersectionTypeNode.mjs.map

package/lib/factory/types/createIntersectionTypeNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createIntersectionTypeNode.mjs","sources":["../../../src/factory/types/createIntersectionTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,0BAA0B,GAAG,CACxC,KAA0B,KACD,IAAI,CAAC,sBAAsB,EAAE,EAAE,KAAK,EAAE;;;;"}

package/lib/factory/types/createKeywordTypeNode.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link KeywordTypeNode}: a built-in keyword type such as `string` or
+ * `number`.
+ *
+ * The kind is a keyword {@link SyntaxKind} like `StringKeyword`,
+ * `NumberKeyword`, `BooleanKeyword`, `VoidKeyword`, `AnyKeyword`, or
+ * `UnknownKeyword`. The printer emits the keyword's own source text directly,
+ * so the node renders as that single word with no surrounding tokens.
+ *
+ * Given the `StringKeyword` kind, the printer renders:
+ *
+ * ```ts
+ * string;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param kind The token kind.
+ * @returns The created {@link KeywordTypeNode}.
+ */
+const createKeywordTypeNode = (kind) => make("KeywordTypeNode", { keyword: kind });
+
+export { createKeywordTypeNode };
+//# sourceMappingURL=createKeywordTypeNode.mjs.map

package/lib/factory/types/createKeywordTypeNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createKeywordTypeNode.mjs","sources":["../../../src/factory/types/createKeywordTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,qBAAqB,GAAG,CAAC,IAAgB,KACpD,IAAI,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createLiteralTypeNode.mjs

@@ -0,0 +1,26 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link LiteralTypeNode}: a literal used in type position such as
+ * `"foo"`, `42`, `true`, or `null`.
+ *
+ * The printer emits the wrapped literal directly, so the rendered text is
+ * exactly that literal's own source. A {@link PrefixUnaryExpression} covers
+ * negative numeric literals such as `-1`, and a {@link Token} covers keyword
+ * literals such as `true`, `false`, and `null`.
+ *
+ * Given a `"foo"` string literal, the printer renders:
+ *
+ * ```ts
+ * "foo";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param literal The literal; a {@link PrefixUnaryExpression} covers negative
+ *   numeric literals such as `-1`.
+ * @returns The created {@link LiteralTypeNode}.
+ */
+const createLiteralTypeNode = (literal) => make("LiteralTypeNode", { literal });
+
+export { createLiteralTypeNode };
+//# sourceMappingURL=createLiteralTypeNode.mjs.map

package/lib/factory/types/createLiteralTypeNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLiteralTypeNode.mjs","sources":["../../../src/factory/types/createLiteralTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAUA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,qBAAqB,GAAG,CACnC,OAKS,KACW,IAAI,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/types/createMappedTypeNode.mjs

@@ -0,0 +1,44 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link MappedTypeNode}: a `{ [K in keyof T]: T[K] }` mapped type.
+ *
+ * The type parameter supplies the key variable and its `in` constraint. When
+ * `nameType` is present it adds an `as` key remap, and when `type` is present
+ * it adds the `: ValueType` value. The whole thing renders inside `{ ... }` on
+ * one line.
+ *
+ * The `readonlyToken` and `questionToken` carry optional modifier polarity. A
+ * plain `readonly` or `?` token prints as `readonly ` and `?`; a `+` or `-`
+ * token prefixes the modifier, so it prints as `+readonly`/`-readonly` and
+ * `+?`/`-?`.
+ *
+ * Given a `K in keyof T` parameter and a `T[K]` value with no modifiers, the
+ * printer renders:
+ *
+ * ```ts
+ * { [K in keyof T]: T[K] }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param readonlyToken The `readonly` modifier with optional `+`/`-` polarity,
+ *   if any.
+ * @param typeParameter The key type parameter holding the `in` constraint.
+ * @param nameType The `as` key remap type, if any.
+ * @param questionToken The optional-marker `?` with optional `+`/`-` polarity,
+ *   if any.
+ * @param type The mapped value type, if any.
+ * @param members The members, if any.
+ * @returns The created {@link MappedTypeNode}.
+ */
+const createMappedTypeNode = (readonlyToken, typeParameter, nameType, questionToken, type, members) => make("MappedTypeNode", {
+    readonlyToken,
+    typeParameter,
+    nameType,
+    questionToken,
+    type,
+    members,
+});
+
+export { createMappedTypeNode };
+//# sourceMappingURL=createMappedTypeNode.mjs.map

package/lib/factory/types/createMappedTypeNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMappedTypeNode.mjs","sources":["../../../src/factory/types/createMappedTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;MACU,oBAAoB,GAAG,CAClC,aAAgC,EAChC,aAAuC,EACvC,QAA8B,EAC9B,aAAgC,EAChC,IAA0B,EAC1B,OAA2C,KAE3C,IAAI,CAAC,gBAAgB,EAAE;IACrB,aAAa;IACb,aAAa;IACb,QAAQ;IACR,aAAa;IACb,IAAI;IACJ,OAAO;AACR,CAAA;;;;"}

package/lib/factory/types/createMethodSignature.mjs

@@ -0,0 +1,39 @@
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link MethodSignature}: a `name(params): T` method signature for an
+ * interface or type literal.
+ *
+ * Any modifiers print first, then the name, then a `?` when the question token
+ * is present, then optional type parameters as `<...>`, the parameter list, and
+ * the return type as `: Type` when present. A string name is normalized to a
+ * property name node.
+ *
+ * Given the name `greet`, one `name: string` parameter, and a `void` return
+ * type, the printer renders:
+ *
+ * ```ts
+ * greet(name: string): void
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The method name.
+ * @param questionToken The optional marker (`?`), if any.
+ * @param typeParameters The generic type parameters, if any.
+ * @param parameters The parameters.
+ * @param type The return type, if any.
+ * @returns The created {@link MethodSignature}.
+ */
+const createMethodSignature = (modifiers, name, questionToken, typeParameters, parameters, type) => make("MethodSignature", {
+    modifiers,
+    name: asPropertyName(name),
+    questionToken,
+    typeParameters,
+    parameters,
+    type,
+});
+
+export { createMethodSignature };
+//# sourceMappingURL=createMethodSignature.mjs.map

package/lib/factory/types/createMethodSignature.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMethodSignature.mjs","sources":["../../../src/factory/types/createMethodSignature.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAYA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;MACU,qBAAqB,GAAG,CACnC,SAA8C,EAC9C,IAA2B,EAC3B,aAAgC,EAChC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,KAE1B,IAAI,CAAC,iBAAiB,EAAE;IACtB,SAAS;AACT,IAAA,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;IAC1B,aAAa;IACb,cAAc;IACd,UAAU;IACV,IAAI;AACL,CAAA;;;;"}

package/lib/factory/types/createNamedTupleMember.mjs

@@ -0,0 +1,33 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NamedTupleMember}: a labeled tuple element such as `name:
+ * string`.
+ *
+ * A leading `...` prints when the rest token is present, then the label, then a
+ * `?` when the question token is present, then `: ` followed by the type. A
+ * string name is normalized to an identifier.
+ *
+ * Given the label `name` and a `string` type, the printer renders:
+ *
+ * ```ts
+ * name: string;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param dotDotDotToken The rest marker (`...`), if any.
+ * @param name The element label.
+ * @param questionToken The optional marker (`?`), if any.
+ * @param type The element type.
+ * @returns The created {@link NamedTupleMember}.
+ */
+const createNamedTupleMember = (dotDotDotToken, name, questionToken, type) => make("NamedTupleMember", {
+    dotDotDotToken,
+    name: asName(name),
+    questionToken,
+    type,
+});
+
+export { createNamedTupleMember };
+//# sourceMappingURL=createNamedTupleMember.mjs.map

package/lib/factory/types/createNamedTupleMember.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNamedTupleMember.mjs","sources":["../../../src/factory/types/createNamedTupleMember.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,sBAAsB,GAAG,CACpC,cAAiC,EACjC,IAAyB,EACzB,aAAgC,EAChC,IAAc,KAEd,IAAI,CAAC,kBAAkB,EAAE;IACvB,cAAc;AACd,IAAA,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;IAClB,aAAa;IACb,IAAI;AACL,CAAA;;;;"}

package/lib/factory/types/createNotEmittedTypeElement.mjs

@@ -0,0 +1,17 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NotEmittedTypeElement}: a placeholder type-element that
+ * carries no syntax of its own.
+ *
+ * It exists to hold position and attached comments inside a member list without
+ * contributing any text. The printer emits the empty string for it, so the
+ * rendered output is empty:
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link NotEmittedTypeElement}.
+ */
+const createNotEmittedTypeElement = () => make("NotEmittedTypeElement", {});
+
+export { createNotEmittedTypeElement };
+//# sourceMappingURL=createNotEmittedTypeElement.mjs.map

package/lib/factory/types/createNotEmittedTypeElement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNotEmittedTypeElement.mjs","sources":["../../../src/factory/types/createNotEmittedTypeElement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;AAUG;AACI,MAAM,2BAA2B,GAAG,MACzC,IAAI,CAAC,uBAAuB,EAAE,EAAE;;;;"}

package/lib/factory/types/createOptionalTypeNode.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link OptionalTypeNode}: a `T?` optional element inside a tuple
+ * type.
+ *
+ * The element type prints first, immediately followed by a `?`. This form is
+ * only valid in tuple element position, for example `[string, number?]`.
+ *
+ * Given a `string` element type, the printer renders:
+ *
+ * ```ts
+ * string?
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The element type.
+ * @returns The created {@link OptionalTypeNode}.
+ */
+const createOptionalTypeNode = (type) => make("OptionalTypeNode", { type });
+
+export { createOptionalTypeNode };
+//# sourceMappingURL=createOptionalTypeNode.mjs.map

package/lib/factory/types/createOptionalTypeNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createOptionalTypeNode.mjs","sources":["../../../src/factory/types/createOptionalTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,sBAAsB,GAAG,CAAC,IAAc,KACnD,IAAI,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createParenthesizedType.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ParenthesizedTypeNode}: a `(T)` explicitly parenthesized type.
+ *
+ * The printer always wraps the inner type in literal parentheses, so this is
+ * the way to force grouping the surrounding printer would not add on its own,
+ * for example to disambiguate a union inside a larger type.
+ *
+ * Given an `A | B` inner type, the printer renders:
+ *
+ * ```ts
+ * A | B;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The inner type to parenthesize.
+ * @returns The created {@link ParenthesizedTypeNode}.
+ */
+const createParenthesizedType = (type) => make("ParenthesizedTypeNode", { type });
+
+export { createParenthesizedType };
+//# sourceMappingURL=createParenthesizedType.mjs.map

package/lib/factory/types/createParenthesizedType.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createParenthesizedType.mjs","sources":["../../../src/factory/types/createParenthesizedType.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,uBAAuB,GAAG,CACrC,IAAc,KACY,IAAI,CAAC,uBAAuB,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createPropertySignature.mjs

@@ -0,0 +1,34 @@
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link PropertySignature}: a `name?: T` property in an interface or
+ * type literal.
+ *
+ * Any modifiers print first (for example `readonly`), then the name, then a `?`
+ * when the question token is present, then `: ` followed by the type when
+ * present. A string name is normalized to a property name node.
+ *
+ * Given the name `name`, a present question token, and a `string` type, the
+ * printer renders:
+ *
+ * ```ts
+ * name?: string
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The property name.
+ * @param questionToken The optional marker (`?`), if any.
+ * @param type The property type, if any.
+ * @returns The created {@link PropertySignature}.
+ */
+const createPropertySignature = (modifiers, name, questionToken, type) => make("PropertySignature", {
+    modifiers,
+    name: asPropertyName(name),
+    questionToken,
+    type,
+});
+
+export { createPropertySignature };
+//# sourceMappingURL=createPropertySignature.mjs.map

package/lib/factory/types/createPropertySignature.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPropertySignature.mjs","sources":["../../../src/factory/types/createPropertySignature.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,uBAAuB,GAAG,CACrC,SAA8C,EAC9C,IAA2B,EAC3B,aAAgC,EAChC,IAA0B,KAE1B,IAAI,CAAC,mBAAmB,EAAE;IACxB,SAAS;AACT,IAAA,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;IAC1B,aAAa;IACb,IAAI;AACL,CAAA;;;;"}

package/lib/factory/types/createRestTypeNode.mjs

@@ -0,0 +1,22 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link RestTypeNode}: a `...T` rest element inside a tuple type.
+ *
+ * A leading `...` prints in front of the type. This form is only valid in tuple
+ * element position, for example `[string, ...number[]]`.
+ *
+ * Given a `string[]` element type, the printer renders:
+ *
+ * ```ts
+ * ...string[]
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The rest element type.
+ * @returns The created {@link RestTypeNode}.
+ */
+const createRestTypeNode = (type) => make("RestTypeNode", { type });
+
+export { createRestTypeNode };
+//# sourceMappingURL=createRestTypeNode.mjs.map

package/lib/factory/types/createRestTypeNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRestTypeNode.mjs","sources":["../../../src/factory/types/createRestTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;AAeG;AACI,MAAM,kBAAkB,GAAG,CAAC,IAAc,KAC/C,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createTemplateLiteralType.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateLiteralTypeNode}: a ``id-${string}`` template literal
+ * type.
+ *
+ * The head supplies the leading text up to the first `${`, then each span
+ * contributes an interpolated type followed by the literal text up to the next
+ * `${` or the closing backtick. The spans print back to back, so the whole
+ * thing reads as one template string.
+ *
+ * Given the head text `id-` and a single span of `string` ending the template,
+ * the printer renders:
+ *
+ * ```ts
+ * `id-${string}`;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param head The leading text up to the first interpolation.
+ * @param templateSpans The interpolated spans.
+ * @returns The created {@link TemplateLiteralTypeNode}.
+ */
+const createTemplateLiteralType = (head, templateSpans) => make("TemplateLiteralType", { head, templateSpans });
+
+export { createTemplateLiteralType };
+//# sourceMappingURL=createTemplateLiteralType.mjs.map

package/lib/factory/types/createTemplateLiteralType.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateLiteralType.mjs","sources":["../../../src/factory/types/createTemplateLiteralType.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAOA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,yBAAyB,GAAG,CACvC,IAAkB,EAClB,aAAiD,KAEjD,IAAI,CAAC,qBAAqB,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/types/createTemplateLiteralTypeSpan.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateLiteralTypeSpan}: one interpolation of a template
+ * literal type, an interpolated type plus the literal text that follows it.
+ *
+ * The type prints first, then the trailing literal. The literal is a
+ * {@link TemplateMiddle} when another span follows and a {@link TemplateTail}
+ * when it closes the template. A span only renders meaningfully inside a
+ * template literal type; on its own it is just a fragment.
+ *
+ * Given a `number` type and a `px` tail inside a ``width:${...}`` template, the
+ * printer renders:
+ *
+ * ```ts
+ * `width:${number}px`;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The interpolated type.
+ * @param literal The trailing middle or tail literal.
+ * @returns The created {@link TemplateLiteralTypeSpan}.
+ */
+const createTemplateLiteralTypeSpan = (type, literal) => make("TemplateLiteralTypeSpan", { type, literal });
+
+export { createTemplateLiteralTypeSpan };
+//# sourceMappingURL=createTemplateLiteralTypeSpan.mjs.map

package/lib/factory/types/createTemplateLiteralTypeSpan.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateLiteralTypeSpan.mjs","sources":["../../../src/factory/types/createTemplateLiteralTypeSpan.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,6BAA6B,GAAG,CAC3C,IAAc,EACd,OAAsC,KAEtC,IAAI,CAAC,yBAAyB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/types/createThisTypeNode.mjs

@@ -0,0 +1,22 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ThisTypeNode}: the `this` type.
+ *
+ * It takes no inputs and the printer always emits the single keyword `this`,
+ * the polymorphic this-type used in fluent method return positions and type
+ * predicates.
+ *
+ * The printer renders:
+ *
+ * ```ts
+ * this;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link ThisTypeNode}.
+ */
+const createThisTypeNode = () => make("ThisTypeNode", {});
+
+export { createThisTypeNode };
+//# sourceMappingURL=createThisTypeNode.mjs.map

package/lib/factory/types/createThisTypeNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createThisTypeNode.mjs","sources":["../../../src/factory/types/createThisTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;AAeG;AACI,MAAM,kBAAkB,GAAG,MAAoB,IAAI,CAAC,cAAc,EAAE,EAAE;;;;"}

package/lib/factory/types/createTupleTypeNode.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TupleTypeNode}: a `[A, B]` tuple type.
+ *
+ * The elements print inside `[...]`, comma separated. The list is width-aware:
+ * inline it stays on one line with no trailing comma, and when it breaks each
+ * element goes on its own line with a trailing comma after the last. Elements
+ * may include named, optional, and rest members.
+ *
+ * Given the elements `string` and `number`, the printer renders:
+ *
+ * ```ts
+ * [string, number];
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param elements The tuple element types.
+ * @returns The created {@link TupleTypeNode}.
+ */
+const createTupleTypeNode = (elements) => make("TupleTypeNode", { elements });
+
+export { createTupleTypeNode };
+//# sourceMappingURL=createTupleTypeNode.mjs.map

package/lib/factory/types/createTupleTypeNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTupleTypeNode.mjs","sources":["../../../src/factory/types/createTupleTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,mBAAmB,GAAG,CACjC,QAA6B,KACX,IAAI,CAAC,eAAe,EAAE,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/types/createTypeLiteralNode.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeLiteralNode}: an inline object type such as `{ name:
+ * string }`.
+ *
+ * The members print inside `{ ... }` and may be any type element: property and
+ * method signatures, index and call signatures, and so on. The member block is
+ * width-aware, staying inline when it fits and breaking onto separate lines
+ * when it does not. The member list defaults to empty, which renders as `{}`.
+ *
+ * Given a single `name: string` property, the printer renders:
+ *
+ * ```ts
+ * { name: string }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param members The type members.
+ * @returns The created {@link TypeLiteralNode}.
+ */
+const createTypeLiteralNode = (members = []) => make("TypeLiteralNode", { members });
+
+export { createTypeLiteralNode };
+//# sourceMappingURL=createTypeLiteralNode.mjs.map

package/lib/factory/types/createTypeLiteralNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeLiteralNode.mjs","sources":["../../../src/factory/types/createTypeLiteralNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,qBAAqB,GAAG,CACnC,OAAA,GAAkC,EAAE,KAChB,IAAI,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/types/createTypeOperatorNode.mjs

@@ -0,0 +1,26 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeOperatorNode}: a prefix type operator such as `keyof T`,
+ * `typeof x`, `readonly T[]`, or `unique symbol`.
+ *
+ * The operator keyword prints first, then a space, then the operand type. In
+ * postfix and array positions the surrounding printer wraps the operator type
+ * in parentheses so the operator does not bind to the postfix instead of the
+ * operand.
+ *
+ * Given the `KeyOfKeyword` operator and a `T` operand, the printer renders:
+ *
+ * ```ts
+ * keyof T
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param operator The operator token.
+ * @param type The operand type.
+ * @returns The created {@link TypeOperatorNode}.
+ */
+const createTypeOperatorNode = (operator, type) => make("TypeOperatorNode", { operator, type });
+
+export { createTypeOperatorNode };
+//# sourceMappingURL=createTypeOperatorNode.mjs.map

package/lib/factory/types/createTypeOperatorNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeOperatorNode.mjs","sources":["../../../src/factory/types/createTypeOperatorNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;AAmBG;MACU,sBAAsB,GAAG,CACpC,QAAoB,EACpB,IAAc,KACO,IAAI,CAAC,kBAAkB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createTypeParameterDeclaration.mjs

@@ -0,0 +1,34 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeParameterDeclaration}: a generic parameter such as `T
+ * extends string = number`.
+ *
+ * Any modifiers print first (for example `const`, `in`, `out`), then the name.
+ * A constraint adds ` extends Type` and a default adds ` = Type`, each only
+ * when present. A string name is normalized to an identifier.
+ *
+ * Given the name `T`, a `string` constraint, and a `number` default, the
+ * printer renders:
+ *
+ * ```ts
+ * T extends string = number
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The parameter name.
+ * @param constraint The `extends` constraint, if any.
+ * @param defaultType The default type, if any.
+ * @returns The created {@link TypeParameterDeclaration}.
+ */
+const createTypeParameterDeclaration = (modifiers, name, constraint, defaultType) => make("TypeParameterDeclaration", {
+    modifiers,
+    name: asName(name),
+    constraint,
+    default: defaultType,
+});
+
+export { createTypeParameterDeclaration };
+//# sourceMappingURL=createTypeParameterDeclaration.mjs.map

package/lib/factory/types/createTypeParameterDeclaration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeParameterDeclaration.mjs","sources":["../../../src/factory/types/createTypeParameterDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,8BAA8B,GAAG,CAC5C,SAA8C,EAC9C,IAAyB,EACzB,UAAqB,EACrB,WAAsB,KAEtB,IAAI,CAAC,0BAA0B,EAAE;IAC/B,SAAS;AACT,IAAA,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;IAClB,UAAU;AACV,IAAA,OAAO,EAAE,WAAW;AACrB,CAAA;;;;"}

package/lib/factory/types/createTypePredicateNode.mjs

@@ -0,0 +1,35 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link TypePredicateNode}: a `x is T` type guard return type, or an
+ * `asserts x is T` / `asserts x` assertion form.
+ *
+ * A leading `asserts ` prints when the asserts modifier is present, then the
+ * parameter name, then ` is Type` when a type is present. The assertion form
+ * with no type (just `asserts x`) is produced by passing the modifier and
+ * omitting the type. A string parameter name is normalized to an identifier.
+ *
+ * Given no asserts modifier, parameter `x`, and a `string` type, the printer
+ * renders:
+ *
+ * ```ts
+ * x is string
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param assertsModifier The `asserts` modifier, if any.
+ * @param parameterName The guarded parameter name, or `this`.
+ * @param type The narrowed type, if any.
+ * @returns The created {@link TypePredicateNode}.
+ */
+const createTypePredicateNode = (assertsModifier, parameterName, type) => make("TypePredicateNode", {
+    assertsModifier,
+    parameterName: typeof parameterName === "string"
+        ? createIdentifier(parameterName)
+        : parameterName,
+    type,
+});
+
+export { createTypePredicateNode };
+//# sourceMappingURL=createTypePredicateNode.mjs.map

package/lib/factory/types/createTypePredicateNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTypePredicateNode.mjs","sources":["../../../src/factory/types/createTypePredicateNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,uBAAuB,GAAG,CACrC,eAAkC,EAClC,aAAiD,EACjD,IAA0B,KAE1B,IAAI,CAAC,mBAAmB,EAAE;IACxB,eAAe;AACf,IAAA,aAAa,EACX,OAAO,aAAa,KAAK;AACvB,UAAE,gBAAgB,CAAC,aAAa;AAChC,UAAE,aAAa;IACnB,IAAI;AACL,CAAA;;;;"}