typia 8.0.0 → 8.0.1

package/lib/programmers/internal/check_dynamic_properties.mjs

@@ -0,0 +1,101 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { check_dynamic_key } from './check_dynamic_key.mjs';
+import { check_everything } from './check_everything.mjs';
+
+/**
+ * @internal
+ */
+const check_dynamic_properties = (props) => {
+    const length = IdentifierFactory.access(ts.factory.createCallExpression(ts.factory.createIdentifier("Object.keys"), undefined, [props.input]), "length");
+    const left = props.config.equals === true && props.dynamic.length === 0
+        ? props.config.undefined === true ||
+            props.regular.every((r) => r.meta.isRequired())
+            ? ts.factory.createStrictEquality(ExpressionFactory.number(props.regular.filter((r) => r.meta.isRequired()).length), length)
+            : ts.factory.createCallExpression(props.context.importer.internal("isBetween"), [], [
+                length,
+                ExpressionFactory.number(props.regular.filter((r) => r.meta.isRequired()).length),
+                ExpressionFactory.number(props.regular.length),
+            ])
+        : null;
+    if (left !== null &&
+        props.config.undefined === false &&
+        props.regular.every((r) => r.meta.isRequired()))
+        return left;
+    const criteria = props.config.entries
+        ? ts.factory.createCallExpression(props.config.entries, undefined, [
+            ts.factory.createCallExpression(ts.factory.createIdentifier("Object.keys"), undefined, [props.input]),
+            check_dynamic_property(props),
+        ])
+        : ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createCallExpression(ts.factory.createIdentifier("Object.keys"), undefined, [props.input]), props.config.assert ? "every" : "map"), undefined, [check_dynamic_property(props)]);
+    const right = (props.config.halt || ((elem) => elem))(props.config.assert ? criteria : check_everything(criteria));
+    return left
+        ? (props.config.undefined
+            ? ts.factory.createLogicalOr
+            : ts.factory.createLogicalAnd)(left, right)
+        : right;
+};
+/**
+ * @internal
+ */
+const check_dynamic_property = (props) => {
+    //----
+    // IF CONDITIONS
+    //----
+    // PREPARE ASSETS
+    const key = ts.factory.createIdentifier("key");
+    const value = ts.factory.createIdentifier("value");
+    const statements = [];
+    const add = (expression, output) => statements.push(ts.factory.createIfStatement(expression, ts.factory.createReturnStatement(output)));
+    const broken = { value: false };
+    // GATHER CONDITIONS
+    if (props.regular.length)
+        add(is_regular_property(props.regular), props.config.positive);
+    statements.push(StatementFactory.constant({
+        name: "value",
+        value: ts.factory.createElementAccessExpression(props.input, key),
+    }));
+    if (props.config.undefined === true)
+        add(ts.factory.createStrictEquality(ts.factory.createIdentifier("undefined"), value), props.config.positive);
+    for (const entry of props.dynamic) {
+        const condition = check_dynamic_key({
+            context: props.context,
+            metadata: entry.key,
+            input: key,
+        });
+        if (condition.kind === ts.SyntaxKind.TrueKeyword) {
+            statements.push(ts.factory.createReturnStatement(entry.expression));
+            broken.value = true;
+            break;
+        }
+        else
+            add(condition, entry.expression);
+    }
+    //----
+    // FUNCTION BODY
+    //----
+    // CLOSURE BLOCK
+    const block = ts.factory.createBlock([
+        ...statements,
+        ...(broken.value
+            ? []
+            : [
+                ts.factory.createReturnStatement(props.config.equals === true
+                    ? props.config.superfluous(value)
+                    : props.config.positive),
+            ]),
+    ], true);
+    // RETURNS
+    return ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("key")], undefined, undefined, block);
+};
+/**
+ * @internal
+ */
+const is_regular_property = (regular) => ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createArrayLiteralExpression(regular.map((entry) => ts.factory.createStringLiteral(entry.key.getSoleLiteral()))), "some"), undefined, [
+    ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("prop")], undefined, undefined, ts.factory.createStrictEquality(ts.factory.createIdentifier("key"), ts.factory.createIdentifier("prop"))),
+]);
+
+export { check_dynamic_properties };
+//# sourceMappingURL=check_dynamic_properties.mjs.map

package/lib/programmers/internal/check_dynamic_properties.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"check_dynamic_properties.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/check_everything.mjs

@@ -0,0 +1,13 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+
+/**
+ * @internal
+ */
+const check_everything = (array) => ts.factory.createCallExpression(IdentifierFactory.access(array, "every"), undefined, [
+    ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("flag", TypeFactory.keyword("boolean"))], undefined, undefined, ts.factory.createIdentifier("flag")),
+]);
+
+export { check_everything };
+//# sourceMappingURL=check_everything.mjs.map

package/lib/programmers/internal/check_everything.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"check_everything.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/check_native.mjs

@@ -0,0 +1,19 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+
+/**
+ * @internal
+ */
+const check_native = (props) => {
+    const instanceOf = ExpressionFactory.isInstanceOf(props.name, props.input);
+    return ATOMIC_LIKE.has(props.name)
+        ? ts.factory.createLogicalOr(ts.factory.createStrictEquality(ts.factory.createStringLiteral(props.name.toLowerCase()), ts.factory.createTypeOfExpression(props.input)), instanceOf)
+        : instanceOf;
+};
+/**
+ * @internal
+ */
+const ATOMIC_LIKE = new Set(["Boolean", "Number", "String"]);
+
+export { check_native };
+//# sourceMappingURL=check_native.mjs.map

package/lib/programmers/internal/check_native.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"check_native.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/check_number.mjs

@@ -0,0 +1,69 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { OptionPredicator } from '../helpers/OptionPredicator.mjs';
+
+/**
+ * @internal
+ */
+const check_number = (props) => {
+    const base = ts.factory.createStrictEquality(ts.factory.createStringLiteral("number"), ts.factory.createTypeOfExpression(props.input));
+    const addition = props.numeric === true
+        ? OptionPredicator.finite(props.context.options)
+            ? ts.factory.createCallExpression(ts.factory.createIdentifier("Number.isFinite"), undefined, [props.input])
+            : OptionPredicator.numeric(props.context.options)
+                ? ts.factory.createLogicalNot(ts.factory.createCallExpression(ts.factory.createIdentifier("Number.isNaN"), undefined, [props.input]))
+                : null
+        : null;
+    const conditions = check_numeric_type_tags({
+        context: props.context,
+        atomic: props.atomic,
+        input: props.input,
+        addition,
+    });
+    return {
+        expected: props.atomic.getName(),
+        expression: addition !== null && conditions.length === 0
+            ? ts.factory.createLogicalAnd(base, addition)
+            : base,
+        conditions,
+    };
+};
+/**
+ * @internal
+ */
+const check_numeric_type_tags = (props) => props.atomic.tags
+    .map((row) => row.filter((tag) => !!tag.validate))
+    .filter((row) => !!row.length)
+    .map((row) => [
+    ...(props.addition === null
+        ? []
+        : row.some((tag) => tag.kind === "type" &&
+            (tag.value === "int32" ||
+                tag.value === "uint32" ||
+                tag.value === "int64" ||
+                tag.value === "uint64" ||
+                tag.value === "float")) ||
+            row.some((tag) => tag.kind === "multipleOf" && typeof tag.value === "number") ||
+            (row.some((tag) => (tag.kind === "minimum" || tag.kind === "exclusiveMinimum") &&
+                typeof tag.value === "number") &&
+                row.some((tag) => (tag.kind === "maximum" || tag.kind === "exclusiveMaximum") &&
+                    typeof tag.value === "number"))
+            ? []
+            : [
+                {
+                    expected: "number",
+                    expression: props.addition,
+                },
+            ]),
+    ...row.map((tag) => ({
+        expected: `number & ${tag.name}`,
+        expression: ExpressionFactory.transpile({
+            transformer: props.context.transformer,
+            importer: props.context.importer,
+            script: tag.validate,
+        })(props.input),
+    })),
+]);
+
+export { check_number };
+//# sourceMappingURL=check_number.mjs.map

package/lib/programmers/internal/check_number.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"check_number.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/check_object.mjs

@@ -0,0 +1,42 @@
+import ts from 'typescript';
+import { check_dynamic_properties } from './check_dynamic_properties.mjs';
+import { check_everything } from './check_everything.mjs';
+
+/**
+ * @internal
+ */
+const check_object = (props) => {
+    // PREPARE ASSETS
+    const regular = props.entries.filter((entry) => entry.key.isSoleLiteral());
+    const dynamic = props.entries.filter((entry) => !entry.key.isSoleLiteral());
+    const flags = regular.map((entry) => entry.expression);
+    // REGULAR WITHOUT DYNAMIC PROPERTIES
+    if (props.config.equals === false && dynamic.length === 0)
+        return regular.length === 0
+            ? props.config.positive
+            : reduce({
+                config: props.config,
+                expressions: flags,
+            });
+    // CHECK DYNAMIC PROPERTIES
+    flags.push(check_dynamic_properties({
+        config: props.config,
+        context: props.context,
+        input: props.input,
+        regular,
+        dynamic,
+    }));
+    return reduce({
+        config: props.config,
+        expressions: flags,
+    });
+};
+/**
+ * @internal
+ */
+const reduce = (props) => props.config.assert
+    ? props.expressions.reduce(props.config.reduce)
+    : check_everything(ts.factory.createArrayLiteralExpression(props.expressions));
+
+export { check_object };
+//# sourceMappingURL=check_object.mjs.map

package/lib/programmers/internal/check_object.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"check_object.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/check_string.mjs

@@ -0,0 +1,31 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+
+/**
+ * @internal
+ */
+const check_string = (props) => {
+    const conditions = check_string_type_tags(props);
+    return {
+        expected: props.atomic.getName(),
+        expression: ts.factory.createStrictEquality(ts.factory.createStringLiteral("string"), ts.factory.createTypeOfExpression(props.input)),
+        conditions,
+    };
+};
+/**
+ * @internal
+ */
+const check_string_type_tags = (props) => props.atomic.tags
+    .map((row) => row.filter((tag) => !!tag.validate))
+    .filter((row) => !!row.length)
+    .map((row) => row.map((tag) => ({
+    expected: `string & ${tag.name}`,
+    expression: ExpressionFactory.transpile({
+        transformer: props.context.transformer,
+        importer: props.context.importer,
+        script: tag.validate,
+    })(props.input),
+})));
+
+export { check_string };
+//# sourceMappingURL=check_string.mjs.map

package/lib/programmers/internal/check_string.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"check_string.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/check_template.mjs

@@ -0,0 +1,29 @@
+import ts from 'typescript';
+import { template_to_pattern } from './template_to_pattern.mjs';
+
+/**
+ * @internal
+ */
+const check_template = (props) => {
+    // TYPEOF STRING & TAGS
+    const conditions = [
+        ts.factory.createStrictEquality(ts.factory.createStringLiteral("string"), ts.factory.createTypeOfExpression(props.input)),
+    ];
+    // TEMPLATES
+    const internal = props.templates.map((tpl) => ts.factory.createCallExpression(ts.factory.createIdentifier(`RegExp(/${template_to_pattern({
+        top: true,
+        template: tpl.row,
+    })}/).test`), undefined, [props.input]));
+    conditions.push(internal.length === 1
+        ? internal[0]
+        : internal.reduce((x, y) => ts.factory.createLogicalOr(x, y)));
+    // COMBINATION
+    return {
+        expression: conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+        conditions: [],
+        expected: props.templates.map((tpl) => tpl.getName()).join(" | "),
+    };
+};
+
+export { check_template };
+//# sourceMappingURL=check_template.mjs.map

package/lib/programmers/internal/check_template.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"check_template.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/check_union_array_like.mjs

@@ -0,0 +1,106 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { MetadataArray } from '../../schemas/metadata/MetadataArray.mjs';
+import { MetadataArrayType } from '../../schemas/metadata/MetadataArrayType.mjs';
+import { MetadataTuple } from '../../schemas/metadata/MetadataTuple.mjs';
+
+/**
+ * @internal
+ */
+const check_union_array_like = (props) => {
+    // ONLY ONE TYPE
+    const targets = props.definitions.map(props.accessor.transform);
+    if (targets.length === 1)
+        return ts.factory.createArrowFunction(undefined, undefined, props.parameters, undefined, undefined, props.config.decoder({
+            input: props.accessor.array(props.input),
+            definition: targets[0],
+            explore: props.explore,
+        }));
+    const array = ts.factory.createIdentifier("array");
+    const top = ts.factory.createIdentifier("top");
+    const statements = [];
+    const tupleList = targets.filter((t) => t instanceof MetadataTuple);
+    const arrayList = targets.filter((t) => t instanceof MetadataArray);
+    const predicate = (meta) => ts.factory.createAsExpression(ts.factory.createArrayLiteralExpression([
+        ts.factory.createArrowFunction(undefined, undefined, [
+            IdentifierFactory.parameter("top", meta instanceof MetadataArrayType
+                ? TypeFactory.keyword("any")
+                : ts.factory.createTypeReferenceNode("any[]")),
+        ], TypeFactory.keyword("any"), undefined, props.config.checker({
+            input: ts.factory.createIdentifier("top"),
+            definition: props.accessor.element(meta),
+            explore: {
+                ...props.explore,
+                tracable: false,
+                postfix: meta instanceof MetadataArrayType ? `"[0]"` : "",
+            },
+            container: array,
+        })),
+        ts.factory.createArrowFunction(undefined, undefined, [
+            IdentifierFactory.parameter("entire", ts.factory.createTypeReferenceNode("any[]")),
+        ], TypeFactory.keyword("any"), undefined, props.config.decoder({
+            input: ts.factory.createIdentifier("entire"),
+            definition: meta,
+            explore: {
+                ...props.explore,
+                tracable: true,
+            },
+        })),
+    ], true), ts.factory.createTypeReferenceNode("const"));
+    const iterate = (props) => ts.factory.createForOfStatement(undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(props.init)], ts.NodeFlags.Const), props.from, props.if);
+    if (tupleList.length)
+        statements.push(StatementFactory.constant({
+            name: "array",
+            value: props.accessor.array(props.input),
+        }), StatementFactory.constant({
+            name: "tuplePredicators",
+            value: ts.factory.createArrayLiteralExpression(tupleList.map((x) => predicate(x)), true),
+        }), iterate({
+            init: "pred",
+            from: ts.factory.createIdentifier("tuplePredicators"),
+            if: ts.factory.createIfStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("pred[0]"), undefined, [array]), ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createIdentifier(`pred[1]`), undefined, [array]))),
+        }));
+    if (arrayList.length) {
+        if (tupleList.length === 0)
+            statements.push(StatementFactory.constant({
+                name: "array",
+                value: props.accessor.array(props.input),
+            }));
+        statements.push(StatementFactory.constant({
+            name: "top",
+            value: props.accessor.front(props.input),
+        }), ts.factory.createIfStatement(ts.factory.createStrictEquality(ExpressionFactory.number(0), props.accessor.size(props.input)), ts.isReturnStatement(props.config.empty)
+            ? props.config.empty
+            : ts.factory.createReturnStatement(props.config.empty)), StatementFactory.constant({
+            name: "arrayPredicators",
+            value: ts.factory.createArrayLiteralExpression(arrayList.map((x) => predicate(x)), true),
+        }), StatementFactory.constant({
+            name: "passed",
+            value: ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createIdentifier("arrayPredicators"), "filter"), undefined, [
+                ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("pred")], undefined, undefined, ts.factory.createCallExpression(ts.factory.createIdentifier("pred[0]"), undefined, [top])),
+            ]),
+        }), ts.factory.createIfStatement(ts.factory.createStrictEquality(ExpressionFactory.number(1), ts.factory.createIdentifier("passed.length")), ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createElementAccessExpression(ts.factory.createNonNullExpression(ts.factory.createIdentifier("passed[0]")), 1), undefined, [array])), ts.factory.createIfStatement(ts.factory.createLessThan(ExpressionFactory.number(1), ts.factory.createIdentifier("passed.length")), iterate({
+            init: "pred",
+            from: ts.factory.createIdentifier("passed"),
+            if: ts.factory.createIfStatement(ts.factory.createCallExpression(IdentifierFactory.access(array, "every"), undefined, [
+                ts.factory.createArrowFunction(undefined, undefined, [
+                    IdentifierFactory.parameter("value", TypeFactory.keyword("any")),
+                ], undefined, undefined, ts.factory.createStrictEquality(props.config.success, ts.factory.createCallExpression(ts.factory.createIdentifier("pred[0]"), undefined, [ts.factory.createIdentifier("value")]))),
+            ]), ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createIdentifier(`pred[1]`), undefined, [ts.factory.createIdentifier("array")]))),
+        }))));
+    }
+    statements.push(props.config.failure({
+        input: props.input,
+        expected: `(${targets
+            .map((t) => props.accessor.name(t, props.accessor.element(t)))
+            .join(" | ")})`,
+        explore: props.explore,
+    }));
+    return ts.factory.createArrowFunction(undefined, undefined, props.parameters, undefined, undefined, ts.factory.createBlock(statements, true));
+};
+
+export { check_union_array_like };
+//# sourceMappingURL=check_union_array_like.mjs.map

package/lib/programmers/internal/check_union_array_like.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"check_union_array_like.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/decode_union_object.mjs

@@ -0,0 +1,56 @@
+import ts from 'typescript';
+
+/**
+ * @internal
+ */
+const decode_union_object = (props) => ts.factory.createCallExpression(ts.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, iterate({
+    escaper: props.escaper,
+    input: props.input,
+    unions: props.objects.map((object) => ({
+        type: "object",
+        is: () => props.success(props.checker({
+            input: props.input,
+            explore: props.explore,
+            object,
+        })),
+        value: () => props.decoder({
+            input: props.input,
+            explore: props.explore,
+            object,
+        }),
+    })),
+    expected: `(${props.objects.map((t) => t.name).join(" | ")})`,
+})), undefined, undefined);
+/**
+ * @internal
+ */
+const iterate = (props) => {
+    const branches = [];
+    for (const u of props.unions) {
+        const condition = u.is();
+        if (condition.kind === ts.SyntaxKind.TrueKeyword) {
+            branches.push({
+                condition: null,
+                value: u.value(),
+            });
+            break;
+        }
+        branches.push({
+            condition,
+            value: u.value(),
+        });
+    }
+    if (branches.length === 0)
+        return ts.factory.createBlock([props.escaper(props)], true);
+    else if (branches.length === 1 && branches[0].condition === null)
+        return branches[0].value;
+    const statements = branches.map((b) => b.condition !== null
+        ? ts.factory.createIfStatement(b.condition, ts.factory.createReturnStatement(b.value), undefined)
+        : ts.factory.createReturnStatement(b.value));
+    if (branches.at(-1).condition !== null)
+        statements.push(props.escaper(props));
+    return ts.factory.createBlock(statements, true);
+};
+
+export { decode_union_object };
+//# sourceMappingURL=decode_union_object.mjs.map

package/lib/programmers/internal/decode_union_object.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_union_object.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/feature_object_entries.mjs

@@ -0,0 +1,41 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { Escaper } from '../../utils/Escaper.mjs';
+
+/**
+ * @internal
+ */
+const feature_object_entries = (props) => props.object.properties.map((next) => {
+    const sole = next.key.getSoleLiteral();
+    const propInput = sole === null
+        ? ts.factory.createIdentifier("value")
+        : Escaper.variable(sole)
+            ? ts.factory.createPropertyAccessExpression(props.input, ts.factory.createIdentifier(sole))
+            : ts.factory.createElementAccessExpression(props.input, ts.factory.createStringLiteral(sole));
+    return {
+        input: propInput,
+        key: next.key,
+        meta: next.value,
+        expression: props.config.decoder({
+            input: propInput,
+            metadata: next.value,
+            explore: {
+                tracable: props.config.path || props.config.trace,
+                source: "function",
+                from: props.from ?? "object",
+                postfix: props.config.trace
+                    ? sole !== null
+                        ? IdentifierFactory.postfix(sole)
+                        : (() => {
+                            props.context.importer.internal(ACCESSOR);
+                            return `${props.context.importer.getInternalText(ACCESSOR)}(key)`;
+                        })()
+                    : "",
+            },
+        }),
+    };
+});
+const ACCESSOR = "accessExpressionAsString";
+
+export { feature_object_entries };
+//# sourceMappingURL=feature_object_entries.mjs.map

package/lib/programmers/internal/feature_object_entries.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature_object_entries.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/json_schema_alias.mjs

@@ -0,0 +1,37 @@
+import { json_schema_description } from './json_schema_description.mjs';
+import { json_schema_object } from './json_schema_object.mjs';
+import { json_schema_station } from './json_schema_station.mjs';
+import { json_schema_title } from './json_schema_title.mjs';
+
+const json_schema_alias = (props) => {
+    if (props.alias.type.value.size() === 1 &&
+        props.alias.type.value.objects.length === 1)
+        return json_schema_object({
+            components: props.components,
+            object: props.alias.type.value.objects[0],
+        });
+    const $ref = `#/components/schemas/${props.alias.type.name}`;
+    if (props.components.schemas?.[props.alias.type.name] === undefined) {
+        // TEMPORARY ASSIGNMENT
+        props.components.schemas ??= {};
+        props.components.schemas[props.alias.type.name] = {};
+        // GENERATE SCHEMA
+        const schema = json_schema_station({
+            blockNever: props.blockNever,
+            components: props.components,
+            attribute: {
+                deprecated: props.alias.type.jsDocTags.some((tag) => tag.name === "deprecated") ||
+                    undefined,
+                title: json_schema_title(props.alias.type),
+                description: json_schema_description(props.alias.type),
+            },
+            metadata: props.alias.type.value,
+        });
+        if (schema !== null)
+            Object.assign(props.components.schemas[props.alias.type.name], schema);
+    }
+    return [{ $ref }];
+};
+
+export { json_schema_alias };
+//# sourceMappingURL=json_schema_alias.mjs.map

package/lib/programmers/internal/json_schema_alias.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_schema_alias.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/json_schema_array.mjs

@@ -0,0 +1,35 @@
+import { json_schema_plugin } from './json_schema_plugin.mjs';
+import { json_schema_station } from './json_schema_station.mjs';
+
+const json_schema_array = (props) => {
+    const factory = () => json_schema_plugin({
+        schema: {
+            type: "array",
+            items: json_schema_station({
+                blockNever: false,
+                components: props.components,
+                metadata: props.array.type.value,
+                attribute: {},
+            }),
+        },
+        tags: props.array.tags,
+    });
+    if (props.array.type.recursive === true) {
+        const out = () => [
+            {
+                $ref: `#/components/schemas/${props.array.type.name}`,
+            },
+        ];
+        if (props.components.schemas?.[props.array.type.name] !== undefined)
+            return out();
+        props.components.schemas ??= {};
+        props.components.schemas[props.array.type.name] ??= {};
+        const oneOf = factory();
+        Object.assign(props.components.schemas[props.array.type.name], oneOf.length === 1 ? oneOf[0] : { oneOf });
+        return out();
+    }
+    return factory();
+};
+
+export { json_schema_array };
+//# sourceMappingURL=json_schema_array.mjs.map

package/lib/programmers/internal/json_schema_array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_schema_array.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/json_schema_bigint.mjs

@@ -0,0 +1,11 @@
+import { json_schema_plugin } from './json_schema_plugin.mjs';
+
+const json_schema_bigint = (atomic) => json_schema_plugin({
+    schema: {
+        type: "integer",
+    },
+    tags: atomic.tags,
+});
+
+export { json_schema_bigint };
+//# sourceMappingURL=json_schema_bigint.mjs.map

package/lib/programmers/internal/json_schema_bigint.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_schema_bigint.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/internal/json_schema_boolean.mjs

@@ -0,0 +1,11 @@
+import { json_schema_plugin } from './json_schema_plugin.mjs';
+
+const json_schema_boolean = (atomic) => json_schema_plugin({
+    schema: {
+        type: "boolean",
+    },
+    tags: atomic.tags,
+});
+
+export { json_schema_boolean };
+//# sourceMappingURL=json_schema_boolean.mjs.map