skip private properties in TypeScript classes, handle getters/setters…

… in TypeScript classes

src/Escalier.Compiler/Prelude.fs

@@ -489,7 +489,8 @@ module Prelude =
               for KeyValue(key, value) in value.Namespaces do
                 ns <- ns.AddNamespace key value
             | None -> failwith $"Couldn't find namespace: '{name}'"
-          | NamedExport { Src = src; Specifiers = specifiers } ->
+          | NamedExport { Src = Some src
+                          Specifiers = specifiers } ->
             let mutable resolvedPath = resolvePath projectRoot env.Filename src
 
             if resolvedPath.EndsWith(".js") then
@@ -530,13 +531,63 @@ module Prelude =
                 printfn $"resolvedPath = {resolvedPath}"
                 failwith "TODO: getLibExports - NamedExport"
 
-            for specifier in specifiers do
-              match specifier with
-              | Named { Name = name; Alias = alias } ->
-                // TODO: look for specifer in exportNs and add it to ns
-                printfn $"name = {name}, alias = {alias}"
+            for Named { Name = name; Alias = alias } in specifiers do
+              let mutable found = false
 
-            failwith "TODO: getExports - NamedExports"
+              let exportName =
+                match alias with
+                | Some a -> a
+                | None -> name
+
+              match exportNs.Values.TryFind name with
+              | Some binding ->
+                ns <- ns.AddBinding exportName binding
+                found <- true
+              | None -> ()
+
+              match exportNs.Schemes.TryFind name with
+              | Some scheme ->
+                ns <- ns.AddScheme exportName scheme
+                found <- true
+              | None -> ()
+
+              match exportNs.Namespaces.TryFind name with
+              | Some value ->
+                ns <- ns.AddNamespace exportName value
+                found <- true
+              | None -> ()
+
+              if found then
+                failwith $"Couldn't find export '{name}' in {resolvedPath}"
+          | NamedExport { Src = None; Specifiers = specifiers } ->
+            for Named { Name = name; Alias = alias } in specifiers do
+              let mutable found = false
+
+              let exportName =
+                match alias with
+                | Some a -> a
+                | None -> name
+
+              match env.TryFindValue name with
+              | Some binding ->
+                ns <- ns.AddBinding exportName binding
+                found <- true
+              | None -> ()
+
+              match env.TryFindScheme name with
+              | Some scheme ->
+                ns <- ns.AddScheme exportName scheme
+                found <- true
+              | None -> ()
+
+              match env.Namespace.Namespaces.TryFind name with
+              | Some value ->
+                ns <- ns.AddNamespace exportName value
+                found <- true
+              | None -> ()
+
+              if found then
+                failwith $"Couldn't find '{name}' to export"
           | ExportDefault expr ->
             match expr.Kind with
             | ExprKind.Identifier { Name = name } ->

src/Escalier.Data/Library.fs

@@ -500,6 +500,7 @@ module Syntax =
   type EnumVariant =
     { Name: string
       TypeAnn: option<TypeAnn> // Must only be an object or tuple type
+      Init: option<Expr> // Can only be a numer literal or string literal
       Span: Span }
 
   type EnumDecl =
@@ -619,6 +620,11 @@ module Syntax =
       Op: string // TODO: Use an enum for this
       Right: TypeAnn }
 
+  type ImportType =
+    { Src: string
+      Qualifier: option<Common.QualifiedIdent>
+      TypeArgs: option<list<TypeAnn>> }
+
   type TypeAnnKind =
     | Literal of Common.Literal
     | Keyword of KeywordTypeAnn
@@ -641,6 +647,7 @@ module Syntax =
     | Binary of BinaryType
     | TemplateLiteral of Common.TemplateLiteral<TypeAnn>
     | Intrinsic
+    | ImportType of ImportType
 
   [<CustomEquality; NoComparison>]
   type TypeAnn =
@@ -669,7 +676,7 @@ module Syntax =
   type ExportSpecifier = Named of Named
 
   type NamedExport =
-    { Src: string
+    { Src: option<string>
       Specifiers: list<ExportSpecifier> }
 
   type ExportAll = { Src: string }

src/Escalier.Data/Visitor.fs

@@ -340,6 +340,7 @@ module rec ExprVisitor =
         walk max
       | TypeAnnKind.TemplateLiteral { Exprs = expr } -> List.iter walk expr
       | TypeAnnKind.Intrinsic -> ()
+      | TypeAnnKind.ImportType _ -> ()
 
   let walkTypeAnnObjElem
     (visitor: SyntaxVisitor<'S>)

src/Escalier.Interop/MergeLib.fs

@@ -143,6 +143,8 @@ module MergeLib =
           if List.contains resolvedPath visitedPaths then
             return ()
           else
+            printfn $"resolvedPath = {resolvedPath}"
+
             visitedPaths <- resolvedPath :: visitedPaths
 
             let contents = File.ReadAllText(resolvedPath)
@@ -159,7 +161,7 @@ module MergeLib =
             for item in ast.Items do
               match item with
               | Import { Path = path } -> do! traverse resolvedPath path
-              | Export(Export.NamedExport { Src = src }) ->
+              | Export(Export.NamedExport { Src = Some src }) ->
                 do! traverse resolvedPath src
               | Export(Export.ExportAll { Src = src }) ->
                 do! traverse resolvedPath src