@ttsc/factory 0.15.9 → 0.15.11

package/lib/factory/literals/createStringLiteral.mjs

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link StringLiteral}: a quoted string literal expression.
+ *
+ * The `text` is the raw, unescaped content of the string. By default the
+ * printer wraps it in double quotes; pass `isSingleQuote` as `true` to wrap it
+ * in single quotes instead.
+ *
+ * The printer escapes the active quote character inside the content. With
+ * double quotes, an embedded `"` is emitted as `\"`; with single quotes, an
+ * embedded `'` is emitted as `\'`. The other quote character is left
+ * untouched.
+ *
+ * With `text` of `he said "hi"` and the default quoting, this prints:
+ *
+ * ```ts
+ * "he said \"hi\"";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The textual content.
+ * @param isSingleQuote When `true`, use single quotes instead of double.
+ * @returns The created {@link StringLiteral}.
+ */
+const createStringLiteral = (text, isSingleQuote) => make("StringLiteral", { text, singleQuote: isSingleQuote });
+
+export { createStringLiteral };
+//# sourceMappingURL=createStringLiteral.mjs.map

package/lib/factory/literals/createStringLiteral.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStringLiteral.mjs","sources":["../../../src/factory/literals/createStringLiteral.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;MACU,mBAAmB,GAAG,CACjC,IAAY,EACZ,aAAuB,KACL,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/literals/createStringLiteralFromNode.mjs

@@ -0,0 +1,25 @@
+import { createStringLiteral } from './createStringLiteral.mjs';
+
+/**
+ * Create a {@link StringLiteral} whose content is copied from an existing name
+ * or literal node.
+ *
+ * The `sourceNode` may be an {@link Identifier}, a {@link PrivateIdentifier}, a
+ * {@link StringLiteral}, or a {@link NumericLiteral}. Its `text` is read and
+ * handed to {@link createStringLiteral}, so the result is double-quoted by
+ * default and the quote-escaping rules of that factory apply.
+ *
+ * With a `sourceNode` identifier named `foo`, this prints:
+ *
+ * ```ts
+ * "foo";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param sourceNode The node to derive the text from.
+ * @returns The created {@link StringLiteral}.
+ */
+const createStringLiteralFromNode = (sourceNode) => createStringLiteral(sourceNode.text);
+
+export { createStringLiteralFromNode };
+//# sourceMappingURL=createStringLiteralFromNode.mjs.map

package/lib/factory/literals/createStringLiteralFromNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStringLiteralFromNode.mjs","sources":["../../../src/factory/literals/createStringLiteralFromNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,2BAA2B,GAAG,CACzC,UAA2E,KACzD,mBAAmB,CAAC,UAAU,CAAC,IAAI;;;;"}

package/lib/factory/literals/createTemplateHead.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateHead}: the opening span of a template expression, from
+ * the leading backtick up to the first `${`.
+ *
+ * The `text` is the cooked content of that span. The optional `rawText` carries
+ * the source spelling before escape processing; when omitted, the cooked text
+ * is used. A head is not a complete expression on its own, it is one piece of a
+ * larger template literal.
+ *
+ * The printer emits the opening backtick, the content, then the `${` that opens
+ * the first substitution. With `text` of `head`, this prints:
+ *
+ * ```ts
+ * `head${
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The text.
+ * @param rawText The rawText.
+ * @returns The created node.
+ */
+const createTemplateHead = (text, rawText) => make("TemplateHead", { text, rawText });
+
+export { createTemplateHead };
+//# sourceMappingURL=createTemplateHead.mjs.map

package/lib/factory/literals/createTemplateHead.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateHead.mjs","sources":["../../../src/factory/literals/createTemplateHead.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,kBAAkB,GAAG,CAChC,IAAY,EACZ,OAAgB,KACC,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/literals/createTemplateMiddle.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateMiddle}: a span of a template expression that sits
+ * between two substitutions, from one `}` to the next `${`.
+ *
+ * The `text` is the cooked content of that span. A middle span only appears in
+ * a template literal that has two or more substitutions, and it is one piece of
+ * that larger literal rather than a complete expression.
+ *
+ * The printer emits the closing `}` of the preceding substitution, the content,
+ * then the `${` that opens the next one. With `text` of `mid`, this prints:
+ *
+ * ```ts
+ * }mid${
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The text.
+ * @returns The created node.
+ */
+const createTemplateMiddle = (text) => make("TemplateMiddle", { text });
+
+export { createTemplateMiddle };
+//# sourceMappingURL=createTemplateMiddle.mjs.map

package/lib/factory/literals/createTemplateMiddle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateMiddle.mjs","sources":["../../../src/factory/literals/createTemplateMiddle.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,oBAAoB,GAAG,CAAC,IAAY,KAC/C,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/literals/createTemplateTail.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateTail}: the closing span of a template expression, from
+ * the last `}` to the trailing backtick.
+ *
+ * The `text` is the cooked content of that span. A tail closes a template
+ * literal that has at least one substitution, and it is one piece of that
+ * larger literal rather than a complete expression.
+ *
+ * The printer emits the closing `}` of the final substitution, the content,
+ * then the trailing backtick. With `text` of `tail`, this prints:
+ *
+ * ```ts
+ * }tail`
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The text.
+ * @returns The created node.
+ */
+const createTemplateTail = (text) => make("TemplateTail", { text });
+
+export { createTemplateTail };
+//# sourceMappingURL=createTemplateTail.mjs.map

package/lib/factory/literals/createTemplateTail.mjs.map

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

package/lib/factory/names/createDecorator.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link Decorator}: an `@expression` attached to a declaration.
+ *
+ * The `expression` is the decorator body, commonly an identifier or a call
+ * expression. The printer prefixes it with `@` and emits the expression as
+ * given; it does not add the surrounding declaration.
+ *
+ * With `expression` of an identifier named `deco`, this prints:
+ *
+ * ```ts
+ * @deco
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression.
+ * @returns The created {@link Decorator}.
+ */
+const createDecorator = (expression) => make("Decorator", { expression });
+
+export { createDecorator };
+//# sourceMappingURL=createDecorator.mjs.map

package/lib/factory/names/createDecorator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDecorator.mjs","sources":["../../../src/factory/names/createDecorator.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,eAAe,GAAG,CAAC,UAAsB,KACpD,IAAI,CAAC,WAAW,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/names/createFalse.mjs

@@ -0,0 +1,23 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createToken } from './createToken.mjs';
+
+/**
+ * Create the `false` keyword as a {@link Token}.
+ *
+ * This takes no arguments and wraps the `FalseKeyword` syntax kind. The printer
+ * emits the keyword as the boolean literal `false`.
+ *
+ * This prints:
+ *
+ * ```ts
+ * false;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link Token}.
+ */
+const createFalse = () => createToken(SyntaxKind.FalseKeyword);
+
+export { createFalse };
+//# sourceMappingURL=createFalse.mjs.map

package/lib/factory/names/createFalse.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFalse.mjs","sources":["../../../src/factory/names/createFalse.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,WAAW,GAAG,MAAa,WAAW,CAAC,UAAU,CAAC,YAAY;;;;"}

package/lib/factory/names/createIdentifier.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link Identifier}: a bare name reference.
+ *
+ * The `text` is stored verbatim as the identifier name, so the printer emits it
+ * exactly as given. No validation or escaping is applied, the caller is
+ * responsible for passing a valid identifier name.
+ *
+ * With `text` of `foo`, this prints:
+ *
+ * ```ts
+ * foo;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The textual content.
+ * @returns The created {@link Identifier}.
+ */
+const createIdentifier = (text) => make("Identifier", { text });
+
+export { createIdentifier };
+//# sourceMappingURL=createIdentifier.mjs.map

package/lib/factory/names/createIdentifier.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createIdentifier.mjs","sources":["../../../src/factory/names/createIdentifier.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,gBAAgB,GAAG,CAAC,IAAY,KAC3C,IAAI,CAAC,YAAY,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/names/createLoopVariable.mjs

@@ -0,0 +1,28 @@
+import { createIdentifier } from './createIdentifier.mjs';
+
+/**
+ * Create a loop variable name as a plain {@link Identifier}.
+ *
+ * The legacy compiler uses a stateful name generator that allocates a fresh,
+ * collision-free identifier. This package is stateless, so this is a simplified
+ * placeholder: it does not track or guarantee uniqueness, it always returns an
+ * identifier named `_i`.
+ *
+ * The `reservedInNestedScopes` parameter belongs to the stateful generator and
+ * is accepted for signature parity but ignored. Because the name is fixed,
+ * nested loops would collide, so the caller must rename as needed.
+ *
+ * With no arguments, this prints:
+ *
+ * ```ts
+ * _i;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param _reservedInNestedScopes Ignored; kept for signature parity.
+ * @returns The created {@link Identifier}.
+ */
+const createLoopVariable = (_reservedInNestedScopes) => createIdentifier("_i");
+
+export { createLoopVariable };
+//# sourceMappingURL=createLoopVariable.mjs.map

package/lib/factory/names/createLoopVariable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLoopVariable.mjs","sources":["../../../src/factory/names/createLoopVariable.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,kBAAkB,GAAG,CAChC,uBAAiC,KAClB,gBAAgB,CAAC,IAAI;;;;"}

package/lib/factory/names/createModifier.mjs

@@ -0,0 +1,25 @@
+import { createToken } from './createToken.mjs';
+
+/**
+ * Create a modifier {@link Token}: a keyword token such as `readonly` or
+ * `export` used in a modifier position.
+ *
+ * The `kind` is the keyword syntax kind to wrap. This forwards straight to
+ * {@link createToken}, so the result is a plain token whose source spelling the
+ * printer emits. The name documents intent, there is no extra modifier-specific
+ * behavior.
+ *
+ * With `kind` of the `readonly` keyword, this prints:
+ *
+ * ```ts
+ * readonly;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param kind The token kind.
+ * @returns The created {@link Token}.
+ */
+const createModifier = (kind) => createToken(kind);
+
+export { createModifier };
+//# sourceMappingURL=createModifier.mjs.map

package/lib/factory/names/createModifier.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createModifier.mjs","sources":["../../../src/factory/names/createModifier.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,cAAc,GAAG,CAC5B,IAAW,KACM,WAAW,CAAC,IAAI;;;;"}

package/lib/factory/names/createModifiersFromModifierFlags.mjs

@@ -0,0 +1,82 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createModifier } from './createModifier.mjs';
+
+/**
+ * Legacy `ts.ModifierFlags` bit values, kept as module-local constants (not an
+ * exported enum) so callers can pass the same numeric bitmask.
+ */
+const FLAG = {
+    Public: 1,
+    Private: 2,
+    Protected: 4,
+    Readonly: 8,
+    Override: 16,
+    Export: 32,
+    Abstract: 64,
+    Ambient: 128,
+    Static: 256,
+    Accessor: 512,
+    Async: 1024,
+    Default: 2048,
+    Const: 4096,
+    In: 8192,
+};
+/**
+ * Create an ordered list of modifier tokens from a legacy `ts.ModifierFlags`
+ * bitmask.
+ *
+ * The `flags` is read bit by bit, and one modifier token is appended for each
+ * bit that is set. The tokens come out in canonical declaration order
+ * regardless of bit order in the input, so `export` precedes `readonly` no
+ * matter how the mask was assembled. When no recognized bit is set, the result
+ * is `undefined` rather than an empty array.
+ *
+ * The legacy `out` modifier is omitted because this package's `SyntaxKind` has
+ * no `OutKeyword` member.
+ *
+ * With `flags` of `Export | Readonly`, the tokens print in order as:
+ *
+ * ```ts
+ * export readonly
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param flags The modifier flags bitmask (legacy `ts.ModifierFlags`).
+ * @returns The created modifier tokens, or `undefined` when none apply.
+ */
+const createModifiersFromModifierFlags = (flags) => {
+    const result = [];
+    if (flags & FLAG.Export)
+        result.push(createModifier(SyntaxKind.ExportKeyword));
+    if (flags & FLAG.Ambient)
+        result.push(createModifier(SyntaxKind.DeclareKeyword));
+    if (flags & FLAG.Default)
+        result.push(createModifier(SyntaxKind.DefaultKeyword));
+    if (flags & FLAG.Const)
+        result.push(createModifier(SyntaxKind.ConstKeyword));
+    if (flags & FLAG.Public)
+        result.push(createModifier(SyntaxKind.PublicKeyword));
+    if (flags & FLAG.Private)
+        result.push(createModifier(SyntaxKind.PrivateKeyword));
+    if (flags & FLAG.Protected)
+        result.push(createModifier(SyntaxKind.ProtectedKeyword));
+    if (flags & FLAG.Abstract)
+        result.push(createModifier(SyntaxKind.AbstractKeyword));
+    if (flags & FLAG.Static)
+        result.push(createModifier(SyntaxKind.StaticKeyword));
+    if (flags & FLAG.Override)
+        result.push(createModifier(SyntaxKind.OverrideKeyword));
+    if (flags & FLAG.Readonly)
+        result.push(createModifier(SyntaxKind.ReadonlyKeyword));
+    if (flags & FLAG.Accessor)
+        result.push(createModifier(SyntaxKind.AccessorKeyword));
+    if (flags & FLAG.Async)
+        result.push(createModifier(SyntaxKind.AsyncKeyword));
+    if (flags & FLAG.In)
+        result.push(createModifier(SyntaxKind.InKeyword));
+    return result.length ? result : undefined;
+};
+
+export { createModifiersFromModifierFlags };
+//# sourceMappingURL=createModifiersFromModifierFlags.mjs.map

package/lib/factory/names/createModifiersFromModifierFlags.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createModifiersFromModifierFlags.mjs","sources":["../../../src/factory/names/createModifiersFromModifierFlags.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;AAGG;AACH,MAAM,IAAI,GAAG;AACX,IAAA,MAAM,EAAE,CAAC;AACT,IAAA,OAAO,EAAE,CAAC;AACV,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,QAAQ,EAAE,CAAC;AACX,IAAA,QAAQ,EAAE,EAAE;AACZ,IAAA,MAAM,EAAE,EAAE;AACV,IAAA,QAAQ,EAAE,EAAE;AACZ,IAAA,OAAO,EAAE,GAAG;AACZ,IAAA,MAAM,EAAE,GAAG;AACX,IAAA,QAAQ,EAAE,GAAG;AACb,IAAA,KAAK,EAAE,IAAI;AACX,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,KAAK,EAAE,IAAI;AACX,IAAA,EAAE,EAAE,IAAI;CACA;AAEV;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,gCAAgC,GAAG,CAC9C,KAAa,KACsB;IACnC,MAAM,MAAM,GAAe,EAAE;AAC7B,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM;QACrB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;AACvD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO;QACtB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;AACxD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO;QACtB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;AACxD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK;QAAE,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;AAC5E,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM;QACrB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;AACvD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO;QACtB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;AACxD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,SAAS;QACxB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;AAC1D,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ;QACvB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AACzD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM;QACrB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;AACvD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ;QACvB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AACzD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ;QACvB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AACzD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ;QACvB,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AACzD,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK;QAAE,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;AAC5E,IAAA,IAAI,KAAK,GAAG,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IACtE,OAAO,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,SAAS;AAC3C;;;;"}

package/lib/factory/names/createNull.mjs

@@ -0,0 +1,23 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createToken } from './createToken.mjs';
+
+/**
+ * Create the `null` keyword as a {@link Token}.
+ *
+ * This takes no arguments and wraps the `NullKeyword` syntax kind. The printer
+ * emits the keyword as the `null` literal.
+ *
+ * This prints:
+ *
+ * ```ts
+ * null;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link Token}.
+ */
+const createNull = () => createToken(SyntaxKind.NullKeyword);
+
+export { createNull };
+//# sourceMappingURL=createNull.mjs.map

package/lib/factory/names/createNull.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNull.mjs","sources":["../../../src/factory/names/createNull.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,UAAU,GAAG,MAAa,WAAW,CAAC,UAAU,CAAC,WAAW;;;;"}

package/lib/factory/names/createPrivateIdentifier.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link PrivateIdentifier}: a class private name beginning with `#`.
+ *
+ * The `text` is the name content. The leading `#` is added automatically when
+ * it is missing, so both `secret` and `#secret` yield the same node. The
+ * printer emits the name with exactly one `#`.
+ *
+ * With `text` of `secret`, this prints:
+ *
+ * ```ts
+ * #secret;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The textual content.
+ * @returns The created {@link PrivateIdentifier}.
+ */
+const createPrivateIdentifier = (text) => make("PrivateIdentifier", { text: text.startsWith("#") ? text : `#${text}` });
+
+export { createPrivateIdentifier };
+//# sourceMappingURL=createPrivateIdentifier.mjs.map

package/lib/factory/names/createPrivateIdentifier.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPrivateIdentifier.mjs","sources":["../../../src/factory/names/createPrivateIdentifier.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,uBAAuB,GAAG,CAAC,IAAY,KAClD,IAAI,CAAC,mBAAmB,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,CAAA,CAAA,EAAI,IAAI,CAAA,CAAE,EAAE;;;;"}

package/lib/factory/names/createQualifiedName.mjs

@@ -0,0 +1,28 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link QualifiedName}: a dotted name path such as `A.b` used in type
+ * positions.
+ *
+ * The `left` is an entity name, either a single identifier or a nested
+ * qualified name, which lets you chain segments like `A.B.c`. The `right` is
+ * the final segment, accepted as a string or an {@link Identifier}; a string is
+ * wrapped into an identifier automatically. The printer joins the two sides
+ * with a dot.
+ *
+ * With `left` of `A` and `right` of `b`, this prints:
+ *
+ * ```ts
+ * A.b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param left The left-hand operand.
+ * @param right The right-hand operand.
+ * @returns The created {@link QualifiedName}.
+ */
+const createQualifiedName = (left, right) => make("QualifiedName", { left, right: asName(right) });
+
+export { createQualifiedName };
+//# sourceMappingURL=createQualifiedName.mjs.map

package/lib/factory/names/createQualifiedName.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createQualifiedName.mjs","sources":["../../../src/factory/names/createQualifiedName.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,mBAAmB,GAAG,CACjC,IAAgB,EAChB,KAA0B,KAE1B,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAe,EAAE;;;;"}

package/lib/factory/names/createSuper.mjs

@@ -0,0 +1,23 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createToken } from './createToken.mjs';
+
+/**
+ * Create the `super` keyword as a {@link Token}.
+ *
+ * This takes no arguments and wraps the `SuperKeyword` syntax kind. The printer
+ * emits the keyword as the `super` expression.
+ *
+ * This prints:
+ *
+ * ```ts
+ * super
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created node.
+ */
+const createSuper = () => createToken(SyntaxKind.SuperKeyword);
+
+export { createSuper };
+//# sourceMappingURL=createSuper.mjs.map

package/lib/factory/names/createSuper.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSuper.mjs","sources":["../../../src/factory/names/createSuper.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,WAAW,GAAG,MAAa,WAAW,CAAC,UAAU,CAAC,YAAY;;;;"}

package/lib/factory/names/createTempVariable.mjs

@@ -0,0 +1,33 @@
+import { createIdentifier } from './createIdentifier.mjs';
+
+/**
+ * Create a temporary variable name as a plain {@link Identifier}.
+ *
+ * The legacy compiler uses a stateful name generator that allocates a fresh,
+ * collision-free identifier and records it via `recordTempVariable`. This
+ * package is stateless, so this is a simplified placeholder: it does not track
+ * or guarantee uniqueness, it just returns an identifier built from a fixed
+ * `_temp` base with the optional `prefix` and `suffix` wrapped around it.
+ *
+ * The `recordTempVariable` and `reservedInNestedScopes` parameters belong to
+ * the stateful generator and are accepted for signature parity but ignored. Two
+ * calls with the same arguments produce the same name, so the caller must keep
+ * names distinct.
+ *
+ * With no arguments, this prints:
+ *
+ * ```ts
+ * _temp;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param _recordTempVariable Ignored; kept for signature parity.
+ * @param _reservedInNestedScopes Ignored; kept for signature parity.
+ * @param prefix An optional name prefix.
+ * @param suffix An optional name suffix.
+ * @returns The created {@link Identifier}.
+ */
+const createTempVariable = (_recordTempVariable, _reservedInNestedScopes, prefix, suffix) => createIdentifier(`${prefix ?? ""}_temp${suffix ?? ""}`);
+
+export { createTempVariable };
+//# sourceMappingURL=createTempVariable.mjs.map

package/lib/factory/names/createTempVariable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTempVariable.mjs","sources":["../../../src/factory/names/createTempVariable.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,kBAAkB,GAAG,CAChC,mBAA6B,EAC7B,uBAAiC,EACjC,MAAe,EACf,MAAe,KACA,gBAAgB,CAAC,CAAA,EAAG,MAAM,IAAI,EAAE,CAAA,KAAA,EAAQ,MAAM,IAAI,EAAE,CAAA,CAAE;;;;"}

package/lib/factory/names/createThis.mjs

@@ -0,0 +1,23 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createToken } from './createToken.mjs';
+
+/**
+ * Create the `this` keyword as a {@link Token}.
+ *
+ * This takes no arguments and wraps the `ThisKeyword` syntax kind. The printer
+ * emits the keyword as the `this` expression.
+ *
+ * This prints:
+ *
+ * ```ts
+ * this;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link Token}.
+ */
+const createThis = () => createToken(SyntaxKind.ThisKeyword);
+
+export { createThis };
+//# sourceMappingURL=createThis.mjs.map

package/lib/factory/names/createThis.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createThis.mjs","sources":["../../../src/factory/names/createThis.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,UAAU,GAAG,MAAa,WAAW,CAAC,UAAU,CAAC,WAAW;;;;"}

package/lib/factory/names/createToken.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link Token}: a node that wraps a single {@link SyntaxKind}.
+ *
+ * The `token` is the syntax kind to wrap, such as a punctuation or keyword
+ * kind. The printer emits the source spelling tied to that kind, so a question
+ * mark token prints as `?` and a keyword token prints as its keyword. The
+ * generic `TKind` flows through to the result type for type-safe consumers.
+ *
+ * With `token` of the question-mark kind, this prints:
+ *
+ * ```ts
+ * ?
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param token The token.
+ * @returns The created {@link Token}.
+ */
+const createToken = (token) => make("Token", { token });
+
+export { createToken };
+//# sourceMappingURL=createToken.mjs.map

package/lib/factory/names/createToken.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createToken.mjs","sources":["../../../src/factory/names/createToken.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,WAAW,GAAG,CACzB,KAAY,KACK,IAAI,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE;;;;"}

package/lib/factory/names/createTrue.mjs

@@ -0,0 +1,23 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createToken } from './createToken.mjs';
+
+/**
+ * Create the `true` keyword as a {@link Token}.
+ *
+ * This takes no arguments and wraps the `TrueKeyword` syntax kind. The printer
+ * emits the keyword as the boolean literal `true`.
+ *
+ * This prints:
+ *
+ * ```ts
+ * true;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link Token}.
+ */
+const createTrue = () => createToken(SyntaxKind.TrueKeyword);
+
+export { createTrue };
+//# sourceMappingURL=createTrue.mjs.map

package/lib/factory/names/createTrue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTrue.mjs","sources":["../../../src/factory/names/createTrue.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,UAAU,GAAG,MAAa,WAAW,CAAC,UAAU,CAAC,WAAW;;;;"}