typia 13.1.1 → 13.2.0

package/native/core/programmers/iterate/stringify_dynamic_properties.go

@@ -1,219 +0,0 @@
-package iterate
-
-import (
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  shimprinter "github.com/microsoft/typescript-go/shim/printer"
-  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-)
-
-func Stringify_dynamic_properties(dynamic []nativehelpers.IExpressionEntry, regular []string, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(stringify_dynamic_properties_factory, emit...)
-  statements := []*shimast.Node{
-    f.NewIfStatement(
-      f.NewBinaryExpression(
-        nil,
-        f.NewIdentifier("undefined"),
-        nil,
-        f.NewToken(shimast.KindEqualsEqualsEqualsToken),
-        f.NewIdentifier("value"),
-      ),
-      f.NewReturnStatement(
-        f.NewStringLiteral("", shimast.TokenFlagsNone),
-      ),
-      nil,
-    ),
-  }
-
-  output := func() *shimast.Node {
-    mapped := f.NewCallExpression(
-      nativefactories.IdentifierFactory.Access(
-        nil,
-        f.NewCallExpression(
-          f.NewIdentifier("Object.entries"),
-          nil,
-          nil,
-          f.NewNodeList([]*shimast.Node{
-            f.NewIdentifier("input"),
-          }),
-          shimast.NodeFlagsNone,
-        ),
-        "map",
-      ),
-      nil,
-      nil,
-      f.NewNodeList([]*shimast.Node{
-        f.NewArrowFunction(
-          nil,
-          nil,
-          f.NewNodeList([]*shimast.Node{
-            nativefactories.IdentifierFactory.Parameter(
-              stringify_dynamic_properties_binding_pattern(emit...),
-              f.NewTypeReferenceNode(
-                f.NewIdentifier("[string, any]"),
-                nil,
-              ),
-              nil,
-            ),
-          }),
-          nil,
-          nil,
-          f.NewToken(shimast.KindEqualsGreaterThanToken),
-          f.NewBlock(
-            f.NewNodeList(statements),
-            false,
-          ),
-        ),
-      }),
-      shimast.NodeFlagsNone,
-    )
-    filtered := f.NewCallExpression(
-      nativefactories.IdentifierFactory.Access(nil, mapped, "filter"),
-      nil,
-      nil,
-      f.NewNodeList([]*shimast.Node{
-        f.NewArrowFunction(
-          nil,
-          nil,
-          f.NewNodeList([]*shimast.Node{
-            nativefactories.IdentifierFactory.Parameter("str", nil, nil),
-          }),
-          nil,
-          nil,
-          f.NewToken(shimast.KindEqualsGreaterThanToken),
-          f.NewBinaryExpression(
-            nil,
-            f.NewStringLiteral("", shimast.TokenFlagsNone),
-            nil,
-            f.NewToken(shimast.KindExclamationEqualsEqualsToken),
-            f.NewIdentifier("str"),
-          ),
-        ),
-      }),
-      shimast.NodeFlagsNone,
-    )
-    return f.NewCallExpression(
-      nativefactories.IdentifierFactory.Access(nil, filtered, "join"),
-      nil,
-      nil,
-      f.NewNodeList([]*shimast.Node{
-        f.NewStringLiteral(",", shimast.TokenFlagsNone),
-      }),
-      shimast.NodeFlagsNone,
-    )
-  }
-
-  if len(regular) != 0 {
-    elements := make([]*shimast.Node, 0, len(regular))
-    for _, key := range regular {
-      elements = append(elements, f.NewStringLiteral(key, shimast.TokenFlagsNone))
-    }
-    statements = append(statements, f.NewIfStatement(
-      f.NewCallExpression(
-        nativefactories.IdentifierFactory.Access(
-          nil,
-          f.NewArrayLiteralExpression(
-            f.NewNodeList(elements),
-            false,
-          ),
-          "some",
-        ),
-        nil,
-        nil,
-        f.NewNodeList([]*shimast.Node{
-          f.NewArrowFunction(
-            nil,
-            nil,
-            f.NewNodeList([]*shimast.Node{
-              nativefactories.IdentifierFactory.Parameter("regular", nil, nil),
-            }),
-            nil,
-            nil,
-            f.NewToken(shimast.KindEqualsGreaterThanToken),
-            f.NewBinaryExpression(
-              nil,
-              f.NewIdentifier("regular"),
-              nil,
-              f.NewToken(shimast.KindEqualsEqualsEqualsToken),
-              f.NewIdentifier("key"),
-            ),
-          ),
-        }),
-        shimast.NodeFlagsNone,
-      ),
-      f.NewReturnStatement(
-        f.NewStringLiteral("", shimast.TokenFlagsNone),
-      ),
-      nil,
-    ))
-  }
-
-  simple := len(dynamic) == 1 &&
-    dynamic[0].Key.Size() == 1 &&
-    len(dynamic[0].Key.Atomics) != 0 &&
-    dynamic[0].Key.Atomics[0].Type == "string"
-  if simple {
-    statements = append(statements, stringify_dynamic_properties_stringify(dynamic[0], emit...))
-    return output()
-  }
-
-  for _, entry := range dynamic {
-    statements = append(statements, f.NewIfStatement(
-      f.NewCallExpression(
-        f.NewIdentifier("RegExp(/"+metadata_to_pattern(struct {
-          top      bool
-          metadata *nativemetadata.MetadataSchema
-        }{
-          top:      true,
-          metadata: entry.Key,
-        })+"/).test"),
-        nil,
-        nil,
-        f.NewNodeList([]*shimast.Node{
-          f.NewIdentifier("key"),
-        }),
-        shimast.NodeFlagsNone,
-      ),
-      stringify_dynamic_properties_stringify(entry, emit...),
-      nil,
-    ))
-  }
-  statements = append(statements, f.NewReturnStatement(
-    f.NewStringLiteral("", shimast.TokenFlagsNone),
-  ))
-  return output()
-}
-
-func stringify_dynamic_properties_stringify(entry nativehelpers.IExpressionEntry, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(stringify_dynamic_properties_factory, emit...)
-  return f.NewReturnStatement(
-    nativefactories.TemplateFactory.Generate([]*shimast.Node{
-      f.NewCallExpression(
-        f.NewIdentifier("JSON.stringify"),
-        nil,
-        f.NewNodeList(nil),
-        f.NewNodeList([]*shimast.Node{
-          f.NewIdentifier("key"),
-        }),
-        shimast.NodeFlagsNone,
-      ),
-      f.NewStringLiteral(":", shimast.TokenFlagsNone),
-      entry.Expression,
-    }),
-  )
-}
-
-func stringify_dynamic_properties_binding_pattern(emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(stringify_dynamic_properties_factory, emit...)
-  return f.NewBindingPattern(
-    shimast.KindArrayBindingPattern,
-    f.NewNodeList([]*shimast.Node{
-      f.NewBindingElement(nil, nil, f.NewIdentifier("key"), nil),
-      f.NewBindingElement(nil, nil, f.NewIdentifier("value"), nil),
-    }),
-  )
-}
-
-var stringify_dynamic_properties_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

package/native/core/programmers/iterate/stringify_native.go

@@ -1,14 +0,0 @@
-package iterate
-
-import (
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  shimprinter "github.com/microsoft/typescript-go/shim/printer"
-  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-)
-
-var stringify_native_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
-func Stringify_native(emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(stringify_native_factory, emit...)
-  return f.NewStringLiteral("{}", shimast.TokenFlagsNone)
-}

package/native/core/programmers/iterate/stringify_regular_properties.go

@@ -1,112 +0,0 @@
-package iterate
-
-import (
-  "encoding/json"
-  "sort"
-
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  shimprinter "github.com/microsoft/typescript-go/shim/printer"
-  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-)
-
-type Stringify_regular_propertiesProps struct {
-  Regular []nativehelpers.IExpressionEntry
-  Dynamic []nativehelpers.IExpressionEntry
-  Emit    *shimprinter.EmitContext
-}
-
-func Stringify_regular_properties(props Stringify_regular_propertiesProps) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(stringify_regular_properties_factory, props.Emit)
-  output := []*shimast.Node{}
-
-  sort.Slice(props.Regular, func(i int, j int) bool {
-    return stringify_regular_properties_sequence(props.Regular[i].Meta) < stringify_regular_properties_sequence(props.Regular[j].Meta)
-  })
-  for index, entry := range props.Regular {
-    key := entry.Key.GetSoleLiteral()
-    if key == nil {
-      continue
-    }
-    encoded, err := json.Marshal(*key)
-    if err != nil {
-      encoded = []byte("\"" + *key + "\"")
-    }
-    base := []*shimast.Node{
-      f.NewStringLiteral(string(encoded)+":", shimast.TokenFlagsNone),
-      entry.Expression,
-    }
-    if index != len(props.Regular)-1 || len(props.Dynamic) != 0 {
-      base = append(base, f.NewStringLiteral(",", shimast.TokenFlagsNone))
-    }
-
-    empty := (!entry.Meta.IsRequired() && !entry.Meta.Nullable && entry.Meta.Size() == 0) ||
-      (len(entry.Meta.Functions) != 0 && !entry.Meta.Nullable && entry.Meta.Size() == 1)
-    if empty {
-      continue
-    }
-    if !entry.Meta.IsRequired() || len(entry.Meta.Functions) != 0 || entry.Meta.Any {
-      output = append(output, nativefactories.ExpressionFactory.Conditional(
-        stringify_regular_properties_condition(entry, props.Emit),
-        f.NewStringLiteral("", shimast.TokenFlagsNone),
-        nativefactories.TemplateFactory.Generate(base),
-      ))
-    } else {
-      output = append(output, base...)
-    }
-  }
-  return output
-}
-
-func stringify_regular_properties_condition(entry nativehelpers.IExpressionEntry, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(stringify_regular_properties_factory, emit...)
-  conditions := []*shimast.Node{}
-  if !entry.Meta.IsRequired() || entry.Meta.Any {
-    conditions = append(conditions, f.NewBinaryExpression(
-      nil,
-      f.NewIdentifier("undefined"),
-      nil,
-      f.NewToken(shimast.KindEqualsEqualsEqualsToken),
-      entry.Input,
-    ))
-  }
-  if len(entry.Meta.Functions) != 0 || entry.Meta.Any {
-    conditions = append(conditions, f.NewBinaryExpression(
-      nil,
-      f.NewStringLiteral("function", shimast.TokenFlagsNone),
-      nil,
-      f.NewToken(shimast.KindEqualsEqualsEqualsToken),
-      nativefactories.ValueFactory.TYPEOF(entry.Input),
-    ))
-  }
-  return stringify_regular_properties_reduce(conditions, shimast.KindBarBarToken, emit...)
-}
-
-func stringify_regular_properties_reduce(expressions []*shimast.Node, operator shimast.Kind, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(stringify_regular_properties_factory, emit...)
-  if len(expressions) == 0 {
-    return f.NewKeywordExpression(shimast.KindFalseKeyword)
-  }
-  output := expressions[0]
-  for _, next := range expressions[1:] {
-    output = f.NewBinaryExpression(
-      nil,
-      output,
-      nil,
-      f.NewToken(operator),
-      next,
-    )
-  }
-  return output
-}
-
-func stringify_regular_properties_sequence(meta *nativemetadata.MetadataSchema) int {
-  if meta.Any || !meta.IsRequired() || len(meta.Functions) != 0 {
-    return 0
-  }
-  return 1
-}
-
-var stringify_regular_properties_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

package/native/core/schemas/metadata/MetadataApplication.go

@@ -1,41 +0,0 @@
-package metadata
-
-type IMetadataSchemaCollection struct {
-  Schemas    []*IMetadataSchema
-  Components IMetadataComponents
-}
-
-type MetadataApplication struct {
-  Schemas    []*MetadataSchema
-  Components *MetadataComponents
-}
-
-func MetadataApplication_create(props MetadataApplication) *MetadataApplication {
-  return &MetadataApplication{
-    Schemas:    props.Schemas,
-    Components: props.Components,
-  }
-}
-
-func MetadataApplication_from(app IMetadataSchemaCollection) *MetadataApplication {
-  components := MetadataComponents_from(app.Components)
-  metadatas := make([]*MetadataSchema, 0, len(app.Schemas))
-  for _, metadata := range app.Schemas {
-    metadatas = append(metadatas, MetadataSchema_from(metadata, components.Dictionary))
-  }
-  return MetadataApplication_create(MetadataApplication{
-    Schemas:    metadatas,
-    Components: components,
-  })
-}
-
-func (app *MetadataApplication) ToJSON() IMetadataSchemaCollection {
-  schemas := make([]*IMetadataSchema, 0, len(app.Schemas))
-  for _, schema := range app.Schemas {
-    schemas = append(schemas, schema.ToJSON())
-  }
-  return IMetadataSchemaCollection{
-    Schemas:    schemas,
-    Components: app.Components.ToJSON(),
-  }
-}

package/src/internal/private/__notationCapitalize.ts

@@ -1,2 +0,0 @@
-export const __notationCapitalize = (str: string) =>
-  str.length ? str[0]!.toUpperCase() + str.slice(1).toLowerCase() : str;

package/src/internal/private/__notationUnsnake.ts

@@ -1,24 +0,0 @@
-export const __notationUnsnake =
-  (props: {
-    plain: (str: string) => string;
-    snake: (str: string, index: number) => string;
-  }) =>
-  (str: string): string => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    let prefix: string = "";
-    for (let i: number = 0; i < str.length; i++) {
-      if (str[i] === "_") prefix += "_";
-      else break;
-    }
-    if (prefix.length !== 0) str = str.substring(prefix.length);
-
-    const out = (s: string) => `${prefix}${s}`;
-    if (str.length === 0) return out("");
-
-    const items: string[] = str.split("_").filter((s) => s.length !== 0);
-    return items.length === 0
-      ? out("")
-      : items.length === 1
-        ? out(props.plain(items[0]!))
-        : out(items.map(props.snake).join(""));
-  };