@quenk/wml 2.14.1 → 2.15.1

package/lib/parse/test.js

@@ -112,39 +112,12 @@ exports.tests = {
           {% endif %}
         </Tag>`,
     },
-    "should parse short fun statements": {
-        input: "{% fun vue () = <View/> %}",
-    },
-    "should parse short fun statements with arguments": {
-        input: "{% fun vue (a:String, b:String, c:String) = " +
-            "<View a={{a}} b={{b}} c={{c}}/> %}",
-    },
-    "should parse short fun statements with type parameters": {
-        input: "{% fun vue [A,B:C,C] (a:A, b:B) = " + "{{ (a + b) + c }} %}",
-    },
-    "should parse extended fun statements": {
-        input: "{% fun vue () %} <View/> {% endfun %}",
-    },
-    "should parse extended fun statements with arguments": {
-        input: "{% fun vue (a:String, b:String, c:String) %}" +
-            "<View a={{a}} b={{b}} c={{c}}/> {% endfun %}",
-    },
-    "should parse extended fun statements with type parameters": {
-        input: "{% fun vue [A,B:C,C] (a:A, b:B) %} {{ ((a + b) + c) }} {% endfun %}",
-    },
     "should parse binary expressions": {
         input: "<p>{{(Styles.A  + Styles.B)}}</p>",
     },
     "should parse complicated expressions": {
         input: '<div class={{((Styles.A + " ") + Style.B)}}/>',
     },
-    "should allow for statement as child of fun": {
-        input: "{% fun sven () %} {% for a in b %} {{b}} {% endfor %} {% endfun %}",
-    },
-    "should allow if statement as child of  fun": {
-        input: "{% fun ate (o:Object) %} {% if a %} {{a}} {% else %} {{a}} " +
-            "{% endif %} {% endfun %}",
-    },
     "should allow for booleans in interpolations": {
         input: "<bool active={{true}}>{{if fun() then false else true}}</bool>",
     },
@@ -192,33 +165,9 @@ exports.tests = {
     "should allow fun application with context": {
         input: "<div>{{ <panel(@,12)> }}</div>",
     },
-    "should parse list types": {
-        input: "{% fun action [A] (s: String[], a:A[]) = {{  '${s}${a}' }} %}",
-    },
     "should allow context properties as fun application": {
         input: "<div>{{ <@action()> }}</div>",
     },
-    "should allow view statements after short fun": {
-        input: `
-
-{% fun template [A] (d: Date[A], o:A, _:String, __:A[]) = {{String(o)}}  %}
-
-{% view Results [A](Date[A]) %}
-
-  <ul>
-
-    {% for option,index in [1,3,4] %}
-
-      <li>{{option}}and{{index}}</li>
-
-    {% else %}
-
-      <p>De nada!</p>
-
-    {% endfor %}
-
-  </ul>`,
-    },
     "should allow actual code": {
         input: `
         {% import (Table) from "@quenk/wml-widgets/lib/data/table" %}
@@ -272,9 +221,6 @@ exports.tests = {
 
 </Panel>`,
     },
-    "should recognize type parameters": {
-        input: "{% fun test[A:String] (a:A) %} {{a}} {% endfun %}",
-    },
     "should allow ifs without elses": {
         input: "{% view Test (Object) %}" +
             "<div> {% if (value == true) %} <span/> {% endif %} </div>",
@@ -455,8 +401,6 @@ exports.tests = {
     "[comment] should parse html comments": `<!-- This is an html comment. -->`,
     "[comment] should parse wml comments": `{# This is a wml comment #}`,
     "[comment] should parse wml comments in statements": `{% view Name {# This is a comment! #} (Object) %} <div/> %}`,
-    "[fun] should parse multi dimensional array parameters": `
-    {% fun test (value:List[][]) %}<p/>{% endfun %}`,
     "should allow index access on context properties": `{% view Test (Object) %}
        <div>
         {% if @["type"] == 1 %}
@@ -496,5 +440,41 @@ exports.tests = {
        m-20,10 h 10
        m-20,10 h 10" />
     </svg>`,
+    "should support part statements": `
+      {% part myPart0 (Ctx) %} 
+        {% let name:String = "Me" %}
+        <h1>{{@name}}</h1>
+      {% endpart %}
+
+      {% part myPart1 (Ctx) %}<h1>{{@name}}</h1>{% endpart %}
+
+      {% part myPart2 (Ctx from "..") %}<h1>{{@name}}</h1>{% endpart %}
+
+      {% part myPart3 where name: String %}<h1>{{@name}}</h1>{% endpart %}
+
+      {% part myPart4 where name: String %}
+        {% let name:String = "Me" %}
+        <h1>{{@name}}</h1>
+      {% endpart %}
+    `,
+    "should support use statments": `
+    <div>
+      {% use part myPart %} 
+      {% use view MyView %}
+      {% use part path.to.part %}
+      {% use view path.to.View %}
+      {% use part @path.to.part %}
+      {% use view @path.to.View %}
+      {% use view SomeView(@) %}
+      {% use part path.to.part({}) %}
+      {% use part myPath with @ %}
+    </div>
+  `,
+    "should support function types with optional params": `
+     {% context FuncContext where
+        func0:  String? -> Void,
+        func1: (String, Number?) -> Void
+    %}
+  `
 };
 //# sourceMappingURL=test.js.map

package/lib/parse/test.js.map

@@ -1 +1 @@
-{"version":3,"file":"test.js","sourceRoot":"","sources":["test.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"test.js","sourceRoot":"","sources":["test.ts"],"names":[],"mappings":"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"}

package/lib/parse/test.ts

@@ -121,35 +121,6 @@ export const tests: { [key: string]: any } = {
         </Tag>`,
   },
 
-  "should parse short fun statements": {
-    input: "{% fun vue () = <View/> %}",
-  },
-
-  "should parse short fun statements with arguments": {
-    input:
-      "{% fun vue (a:String, b:String, c:String) = " +
-      "<View a={{a}} b={{b}} c={{c}}/> %}",
-  },
-
-  "should parse short fun statements with type parameters": {
-    input: "{% fun vue [A,B:C,C] (a:A, b:B) = " + "{{ (a + b) + c }} %}",
-  },
-
-  "should parse extended fun statements": {
-    input: "{% fun vue () %} <View/> {% endfun %}",
-  },
-
-  "should parse extended fun statements with arguments": {
-    input:
-      "{% fun vue (a:String, b:String, c:String) %}" +
-      "<View a={{a}} b={{b}} c={{c}}/> {% endfun %}",
-  },
-
-  "should parse extended fun statements with type parameters": {
-    input:
-      "{% fun vue [A,B:C,C] (a:A, b:B) %} {{ ((a + b) + c) }} {% endfun %}",
-  },
-
   "should parse binary expressions": {
     input: "<p>{{(Styles.A  + Styles.B)}}</p>",
   },
@@ -158,14 +129,6 @@ export const tests: { [key: string]: any } = {
     input: '<div class={{((Styles.A + " ") + Style.B)}}/>',
   },
 
-  "should allow for statement as child of fun": {
-    input: "{% fun sven () %} {% for a in b %} {{b}} {% endfor %} {% endfun %}",
-  },
-  "should allow if statement as child of  fun": {
-    input:
-      "{% fun ate (o:Object) %} {% if a %} {{a}} {% else %} {{a}} " +
-      "{% endif %} {% endfun %}",
-  },
   "should allow for booleans in interpolations": {
     input: "<bool active={{true}}>{{if fun() then false else true}}</bool>",
   },
@@ -215,33 +178,9 @@ export const tests: { [key: string]: any } = {
   "should allow fun application with context": {
     input: "<div>{{ <panel(@,12)> }}</div>",
   },
-  "should parse list types": {
-    input: "{% fun action [A] (s: String[], a:A[]) = {{  '${s}${a}' }} %}",
-  },
   "should allow context properties as fun application": {
     input: "<div>{{ <@action()> }}</div>",
   },
-  "should allow view statements after short fun": {
-    input: `
-
-{% fun template [A] (d: Date[A], o:A, _:String, __:A[]) = {{String(o)}}  %}
-
-{% view Results [A](Date[A]) %}
-
-  <ul>
-
-    {% for option,index in [1,3,4] %}
-
-      <li>{{option}}and{{index}}</li>
-
-    {% else %}
-
-      <p>De nada!</p>
-
-    {% endfor %}
-
-  </ul>`,
-  },
   "should allow actual code": {
     input: `
         {% import (Table) from "@quenk/wml-widgets/lib/data/table" %}
@@ -296,10 +235,6 @@ export const tests: { [key: string]: any } = {
 </Panel>`,
   },
 
-  "should recognize type parameters": {
-    input: "{% fun test[A:String] (a:A) %} {{a}} {% endfun %}",
-  },
-
   "should allow ifs without elses": {
     input:
       "{% view Test (Object) %}" +
@@ -533,9 +468,6 @@ export const tests: { [key: string]: any } = {
 
   "[comment] should parse wml comments in statements": `{% view Name {# This is a comment! #} (Object) %} <div/> %}`,
 
-  "[fun] should parse multi dimensional array parameters": `
-    {% fun test (value:List[][]) %}<p/>{% endfun %}`,
-
   "should allow index access on context properties": `{% view Test (Object) %}
        <div>
         {% if @["type"] == 1 %}
@@ -582,4 +514,40 @@ export const tests: { [key: string]: any } = {
        m-20,10 h 10
        m-20,10 h 10" />
     </svg>`,
+  "should support part statements": `
+      {% part myPart0 (Ctx) %} 
+        {% let name:String = "Me" %}
+        <h1>{{@name}}</h1>
+      {% endpart %}
+
+      {% part myPart1 (Ctx) %}<h1>{{@name}}</h1>{% endpart %}
+
+      {% part myPart2 (Ctx from "..") %}<h1>{{@name}}</h1>{% endpart %}
+
+      {% part myPart3 where name: String %}<h1>{{@name}}</h1>{% endpart %}
+
+      {% part myPart4 where name: String %}
+        {% let name:String = "Me" %}
+        <h1>{{@name}}</h1>
+      {% endpart %}
+    `,
+  "should support use statments": `
+    <div>
+      {% use part myPart %} 
+      {% use view MyView %}
+      {% use part path.to.part %}
+      {% use view path.to.View %}
+      {% use part @path.to.part %}
+      {% use view @path.to.View %}
+      {% use view SomeView(@) %}
+      {% use part path.to.part({}) %}
+      {% use part myPath with @ %}
+    </div>
+  `,
+  "should support function types with optional params": `
+     {% context FuncContext where
+        func0:  String? -> Void,
+        func1: (String, Number?) -> Void
+    %}
+  `
 };

package/lib/parse/wml.y

@@ -77,8 +77,9 @@ Text ({DoubleStringCharacter}*)|({SingleStringCharacter}*)
 <CONTROL>'import'                                        return 'IMPORT';
 <CONTROL>'from'                                          return 'FROM';
 <CONTROL>'as'                                            return 'AS';
-<CONTROL>'macro'                                         return 'MACRO';
-<CONTROL>'endmacro'                                      return 'ENDMACRO';
+<CONTROL>'part'                                          return 'PART';
+<CONTROL>'endpart'                                       return 'ENDPART';
+<CONTROL>'use'                                           return 'USE';
 <CONTROL>'for'                                           return 'FOR';
 <CONTROL>'endfor'                                        return 'ENDFOR';
 <CONTROL>'if'                                            return 'IF';
@@ -101,6 +102,7 @@ Text ({DoubleStringCharacter}*)|({SingleStringCharacter}*)
 <CONTROL>'where'                                         return 'WHERE';
 <CONTROL>'let'                                           return 'LET';
 <CONTROL>'to'                                            return 'TO';
+<CONTROL>'with'                                          return 'WITH';
 <CONTROL>{Constructor}                             return 'CONSTRUCTOR';
 <CONTROL>{Identifier}                              return 'IDENTIFIER';
 <CONTROL>'@'                                             return '@';
@@ -249,7 +251,7 @@ export
 
           | view_statement           
 
-          | fun_statement 
+          | part_statment 
 
           | element
             {$$ = $1; }
@@ -398,24 +400,53 @@ view_directives
             { $$ = $1.concat($2); }
           ;
 
-fun_statement
+part_statment 
+          : '{%' PART unqualified_identifier '(' view_statement_context ')' '%}' 
+             view_directives children
+            '{%' ENDPART '%}'
+            {$$ = new yy.ast.PartStatement($3, $5, $8, $9, @$); }
 
-          : '{%' FUN unqualified_identifier type_parameters parameters '%}' 
-              children 
-            '{%' ENDFUN '%}'
-            {$$ = new yy.ast.FunStatement($3, $4, $5, $7, @$); }
+          | '{%' PART unqualified_identifier '(' view_statement_context ')' '%}' 
+             children
+            '{%' ENDPART '%}'
+            {$$ = new yy.ast.PartStatement($3, $5, [], $8, @$); }
 
-          | '{%' FUN unqualified_identifier parameters '%}' 
-              children 
-            '{%' ENDFUN '%}'
-            {$$ = new yy.ast.FunStatement($3, [], $4, $6, @$); }
+          | '{%' PART unqualified_identifier '%}' 
+             view_directives children
+            '{%' ENDPART '%}'
+            {$$ = new yy.ast.PartStatement($3, undefined, $5, $6, @$); }
+
+          | '{%' PART unqualified_identifier '%}' 
+             children
+            '{%' ENDPART '%}'
+            {$$ = new yy.ast.PartStatement($3, undefined, [], $5, @$); }
+
+          | '{%' PART unqualified_identifier WHERE context_members '%}' 
+              view_directives children
+            '{%' ENDPART '%}'
+            {$$ = new yy.ast.PartStatement($3, $5, $7, $8, @$); }
+
+          | '{%' PART unqualified_identifier WHERE context_members '%}' 
+              children
+            '{%' ENDPART '%}'
+            {$$ = new yy.ast.PartStatement($3, $5, [], $7, @$); }
+          ;
 
-          | '{%' FUN unqualified_identifier type_parameters parameters '='
-              child '%}' 
-            {$$ = new yy.ast.FunStatement($3, $4, $5, [$7], @$); }
+use_statement
+          : '{%' USE PART use_target WITH expression '%}'
+            {$$ = new yy.ast.UsePartStatement($4, $6,  @$); }
 
-          | '{%' FUN unqualified_identifier parameters '=' child '%}' 
-            {$$ = new yy.ast.FunStatement($3, [], $4, [$6], @$); }
+          | '{%' USE PART use_target '%}'
+            {$$ = new yy.ast.UsePartStatement($4, undefined, @$); }
+
+          | '{%' USE VIEW use_target '%}'
+            {$$ = new yy.ast.UseViewStatement($4, @$); }
+          ;
+
+use_target
+          : (construct_expression | call_expression | member_expression 
+           | context_property | unqualified_constructor | unqualified_identifier 
+           | context_variable)
           ;
 
 type_parameters
@@ -450,6 +481,7 @@ type
             { $$ = $1;                                                  }
           ;
 
+
 grouped_type
           : '(' non_function_type ')'
             { $$ = $2;                                                  }
@@ -541,27 +573,42 @@ function_type
           | '('  ')' '->' type
             { $$ = new yy.ast.FunctionType([], $4, @$);                 }
 
-          | non_function_type '->' type                                 
+          | function_type_parameter  '->' type                                 
             { $$ = new yy.ast.FunctionType([$1], $3, @$);               }
 
-          // If we don't use grouped_type here jison will trip up on the 
-          // ambiguity that implicitly exists between the type sub rules
-          | grouped_type '->' type
+          | grouped_type '->' type                                 
             { $$ = new yy.ast.FunctionType([$1], $3, @$);               }
-
+        
           | '(' function_type_parameters ')' '->' type
             { $$ = new yy.ast.FunctionType($2, $5, @$);                 }
           ;
 
+function_type_parameter
+         : non_function_type 
+            { $$ = $1;                                                  }
+
+         | optional_function_type
+            { $$ = $1;                                                  }
+         ;
+
+optional_function_type
+         : non_function_type '?'
+            { $$ = new yy.ast.OptionalType($1, @$);                     }
+
+         | '(' function_type ')' '?'
+            { $$ = new yy.ast.OptionalType($1, @$);                     }
+
+         ;
+
 function_type_parameters
 
-          : non_function_type ',' non_function_type
+          :  function_type_parameter ',' function_type_parameter
             { $$ = [$1, $3];                                             }
 
           | '(' function_type ')' ',' '(' function_type ')'
             { $$ = [$2, $6];                                             }
 
-          | function_type_parameters ',' non_function_type
+          | function_type_parameters ',' function_type_parameter
             { $$ = $1.concat($3);                                        }
 
           | function_type_parameters ',' '(' function_type ')'
@@ -689,7 +736,7 @@ filter
           ;
 
 control
-          : (for_statement|if_statement) 
+          : (for_statement|if_statement|use_statement) 
             {$$ = $1;}
           ;
 
@@ -966,7 +1013,10 @@ member_expression_head:
            ;
 
 member_expression_tail
-          : (unqualified_identifier| unqualified_constructor|string_literal)
+          : unqualified_identifier
+          | unqualified_constructor
+          | string_literal
+          | keyword
           ;
 
 function_expression
@@ -1088,3 +1138,9 @@ binary_operator
             { $$ = $1; }
           ;
 
+keyword
+      : (IMPORT | FROM | AS | TYPE | CONTEXT | WHERE | LET | VIEW | PART |
+        ENDPART | FOR | IN | OF | TO | ENDFOR | IF | ELSE | ENDIF | USE |
+        TRUE | FALSE | INSTANCEOF | WITH)
+        {$$ = new yy.ast.UnqualifiedIdentifier($1, @$)}
+      ;

package/lib/view/frame.d.ts

@@ -47,6 +47,10 @@ declare class SetList {
  * wml ids and groups.
  */
 export interface Frame {
+    /**
+     * tree when sets is the rendered DOM content of the view
+     */
+    tree?: Content;
     /**
      * root sets the root element of a View's tree.
      */
@@ -68,37 +72,14 @@ export interface Frame {
      * this one.
      */
     view(view: View): Content;
-}
-/**
- * MultiFrame is a composite that allows more than one Frame to be rendered
- * at the same time.
- */
-export declare class MultiFrame implements Frame {
-    frames: Frame[];
-    constructor(frames?: Frame[]);
-    root(el: Content): void;
-    node(tag: string, attrs: Attrs, children: Content[]): Content;
-    widget(w: Widget, attrs: Attrs): Content;
-    view(view: View): Content;
-}
-/**
- * ViewFrame contains helper methods for retreiving elements by id or
- * group freeing the View class of such logic.
- */
-export declare class ViewFrame implements Frame {
-    nodes: SetList;
-    widgets: Map<number, Widget>;
-    groups: Map<WMLId, Index[]>;
-    ids: Map<string, number>;
-    indexes: Map<number, string>;
-    tree?: Content | undefined;
-    constructor(nodes?: SetList, widgets?: Map<number, Widget>, groups?: Map<WMLId, Index[]>, ids?: Map<string, number>, indexes?: Map<number, string>, tree?: Content | undefined);
-    _register(id: WMLId, node: Content, widget?: Widget): void;
-    _registerGroupMember(id: WMLId, node: Content, widget?: Widget): void;
-    root(el: Content): void;
-    node(tag: string, attrs: Attrs, children: Content[]): Content;
-    widget(w: Widget, attrs: Attrs): Content;
-    view(view: View): Content;
+    /**
+     * register content and widget under the specified id.
+     */
+    register(id: WMLId, node: Content, widget?: Widget): void;
+    /**
+     * registerGroupMember registers a content and widget as a member of a group.
+     */
+    registerGroupMember(id: WMLId, node: Content, widget?: Widget): void;
     /**
      * findById returns the entry stored for the specified wml element.
      */
@@ -123,5 +104,36 @@ export declare class ViewFrame implements Frame {
      * replaceByGroup allows WMLElement replaced by using a group identifier.
      */
     replaceByGroup(next: ViewFrame, id: WMLId): void;
+    /**
+     * destroy the frame.
+     *
+     * Currently a no-op but may be used in the future.
+     */
+    destroy(): void;
+}
+/**
+ * ViewFrame contains helper methods for retreiving elements by id or
+ * group freeing the View class of such logic.
+ */
+export declare class ViewFrame implements Frame {
+    nodes: SetList;
+    widgets: Map<number, Widget>;
+    groups: Map<WMLId, Index[]>;
+    ids: Map<string, number>;
+    indexes: Map<number, string>;
+    tree?: Content | undefined;
+    constructor(nodes?: SetList, widgets?: Map<number, Widget>, groups?: Map<WMLId, Index[]>, ids?: Map<string, number>, indexes?: Map<number, string>, tree?: Content | undefined);
+    register(id: WMLId, node: Content, widget?: Widget): void;
+    registerGroupMember(id: WMLId, node: Content, widget?: Widget): void;
+    root(el: Content): void;
+    node(tag: string, attrs: Attrs, children: Content[]): Content;
+    widget(w: Widget, attrs: Attrs): Content;
+    view(view: View): Content;
+    findById(id: WMLId): Maybe<Entry>;
+    findByGroup(id: WMLId): Entry[];
+    replaceByIndex(next: ViewFrame, idx: Index): void;
+    replaceById(next: ViewFrame, id: WMLId): void;
+    replaceByGroup(next: ViewFrame, id: WMLId): void;
+    destroy(): void;
 }
 export {};