refactor(parse/insertExpressions): convert to ts

src/parse/templateElements.ts

@@ -3,8 +3,14 @@ import TemplateElementType from 'config/types';
 /**
  * This file contains all definition of abstract syntax for ractive template returned
  * by converters functions.
- *
  * @todo change name to abstract something?
+ *
+ * @see https://github.com/ractivejs/template-spec
+ *
+ * @todo consider to add an enum to store key value
+ *
+ * t -> type
+ * x -> expresion
  */
 
 export interface SimpleTemplateElement {
@@ -31,8 +37,18 @@ export interface BrackedTemplateElement {
   x: ReferenceTemplateElement;
 }
 
+export interface ExpressionTempleteElement {
+  // function name or param dinamic names
+  r: string[];
+
+  // body of the function function name and reference param
+  // are replaced by _{index}
+  s: string;
+}
+
 export type TemplateDefinition =
   | SimpleTemplateElement
   | ValueTemplateElement
   | ReferenceTemplateElement
-  | BrackedTemplateElement;
+  | BrackedTemplateElement
+  | ExpressionTempleteElement;

src/parse/utils/insertExpressions.js → src/parse/utils/insertExpressions.ts

@@ -1,8 +1,13 @@
 import { fromExpression } from './createFunction';
 import { isArray, isObject } from 'utils/is';
 import { keys } from 'utils/object';
+import { ExpressionTempleteElement, TemplateDefinition } from 'parse/templateElements';
 
-export default function insertExpressions(obj, expr) {
+type ExpressionRegistry = {
+  [key: string]: Function;
+};
+
+export default function insertExpressions(obj: TemplateDefinition, expr: ExpressionRegistry): void {
   keys(obj).forEach(key => {
     if (isExpression(key, obj)) return addTo(obj, expr);
 
@@ -11,15 +16,15 @@ export default function insertExpressions(obj, expr) {
   });
 }
 
-function isExpression(key, obj) {
+function isExpression(key: string, obj: any): obj is ExpressionTempleteElement {
   return key === 's' && isArray(obj.r);
 }
 
-function addTo(obj, expr) {
+function addTo(obj: ExpressionTempleteElement, expr: ExpressionRegistry): void {
   const { s, r } = obj;
   if (!expr[s]) expr[s] = fromExpression(s, r.length);
 }
 
-function hasChildren(ref) {
+function hasChildren(ref: unknown): boolean {
   return isArray(ref) || isObject(ref);
 }