feat: add string type (#147)

.changeset/wet-windows-protect.md

@@ -0,0 +1,7 @@
+---
+'@rekajs/parser': patch
+'@rekajs/types': patch
+'@rekajs/core': patch
+---
+
+Add string type

packages/core/src/expression.ts

@@ -167,6 +167,18 @@ export const computeExpression = (
     return expr.value;
   }
 
+  if (expr instanceof t.String) {
+    return expr.value
+      .map((value) => {
+        if (typeof value === 'string') {
+          return value;
+        }
+
+        return computeExpression(value, reka, env, ctx);
+      })
+      .join('');
+  }
+
   if (expr instanceof t.Val) {
     const value = expr.init
       ? computeExpression(expr.init, reka, env, {

packages/core/src/resolver.ts

@@ -222,6 +222,14 @@ export class Resolver {
     if (expr instanceof t.Val) {
       this.resolveVariable(expr, scope);
     }
+
+    if (expr instanceof t.String) {
+      expr.value.map((value) => {
+        if (t.is(value, t.Expression)) {
+          this.resolveExpr(value, scope);
+        }
+      });
+    }
   }
 
   private resolveComponent(component: t.Component, scope: Scope) {

packages/parser/src/lexer.ts

@@ -163,6 +163,9 @@ export class Lexer {
         this.state.current += 1;
         return string;
       }
+      case '`': {
+        return this.tokenize(TokenType.BACKTICK);
+      }
       case ':': {
         if (this.currentContext === tc_val_prop) {
           return this.tokenize(TokenType.KIND);

packages/parser/src/parser.ts

@@ -282,6 +282,42 @@ const jsToReka = <T extends t.ASTNode = t.ASTNode>(
           right: _convert(node.right),
         });
       }
+      case 'TemplateLiteral': {
+        const str = node.quasis.map((quasi) => quasi.value.raw).join('');
+
+        const bracesMatches = [...str.matchAll(/{{(.*?)}}/g)];
+
+        if (bracesMatches.length == 0) {
+          return t.string({
+            value: [str],
+          });
+        }
+
+        return t.string({
+          value: bracesMatches.reduce((accum, match, matchIdx) => {
+            const exprStr = match[0];
+            const { type: expr } = parseExpressionWithAcornToRekaType(
+              exprStr.substring(2, exprStr.length - 2),
+              0
+            );
+
+            const start =
+              matchIdx === 0
+                ? 0
+                : (bracesMatches[matchIdx - 1].index ?? 0) +
+                  bracesMatches[matchIdx - 1][0].length;
+
+            const innerStr = str.substring(start, match.index);
+            accum.push(innerStr);
+            accum.push(expr);
+
+            if (matchIdx === bracesMatches.length - 1) {
+              accum.push(str.substring(match.index! + exprStr.length));
+            }
+            return accum;
+          }, [] as Array<string | t.Expression>),
+        });
+      }
       default: {
         return t.Schema.fromJSON(node) as t.Type;
       }

packages/parser/src/stringifier.ts

@@ -93,6 +93,20 @@ class _Stringifier {
 
         this.writer.write(node.value.toString());
       },
+      String: (node) => {
+        this.writer.write('`');
+        node.value.forEach((strOrExpr) => {
+          if (typeof strOrExpr === 'string') {
+            this.writer.write(strOrExpr);
+            return;
+          }
+
+          this.writer.write('{{');
+          this.stringify(strOrExpr, precedence);
+          this.writer.write('}}');
+        });
+        this.writer.write('`');
+      },
       ArrayExpression: (node) => {
         this.writer.write('[');
         node.elements.forEach((element, i) => {

packages/parser/src/tests/parser.test.ts

@@ -304,4 +304,34 @@ describe('Parser', () => {
       bindable: true,
     });
   });
+  it('should be able to parse string type', () => {
+    const parsed = Parser.parseExpression(
+      '`Hello {{myVariable}} there {{1+2}}!`'
+    );
+
+    expect(parsed).toMatchObject({
+      type: 'String',
+      value: [
+        'Hello ',
+        {
+          type: 'Identifier',
+          name: 'myVariable',
+        },
+        ' there ',
+        {
+          type: 'BinaryExpression',
+          left: {
+            type: 'Literal',
+            value: 1,
+          },
+          operator: '+',
+          right: {
+            type: 'Literal',
+            value: 2,
+          },
+        },
+        '!',
+      ],
+    });
+  });
 });

packages/parser/src/tests/stringifier.test.ts

@@ -242,4 +242,24 @@ describe('Stringifier', () => {
       )
     ).toEqual(`<input value:={value} />`);
   });
+  it('should be able to stringifiy string type', () => {
+    expect(
+      Stringifier.toString(
+        t.string({
+          value: [
+            'Hello ',
+            t.identifier({
+              name: 'myVariable',
+            }),
+            ' + ',
+            t.binaryExpression({
+              left: t.literal({ value: 1 }),
+              operator: '+',
+              right: t.literal({ value: 1 }),
+            }),
+          ],
+        })
+      )
+    ).toEqual('`Hello {{myVariable}} + {{1 + 1}}`');
+  });
 });

packages/parser/src/tokens.ts

@@ -16,6 +16,7 @@ export enum TokenType {
   STAR = '*',
   DOLLAR = '$',
   AMPERSAND = '@',
+  BACKTICK = '`',
 
   NOT = '!',
   NEQ = '!=',

packages/types/scripts/generator/stringifyField.js

@@ -19,7 +19,7 @@ const fieldsToString = {
     return self.node;
   },
   array: (self) => {
-    return `${stringifyField(self.array)}[]`;
+    return `Array<${stringifyField(self.array)}>`;
   },
   map: (self) => {
     return `Record<string, ${stringifyField(self.type)}>`;

packages/types/src/generated/builder.generated.ts

@@ -24,6 +24,8 @@ export const customKind = (
 ) => new t.CustomKind(...args);
 export const literal = (...args: ConstructorParameters<typeof t.Literal>) =>
   new t.Literal(...args);
+export const string = (...args: ConstructorParameters<typeof t.String>) =>
+  new t.String(...args);
 export const identifier = (
   ...args: ConstructorParameters<typeof t.Identifier>
 ) => new t.Identifier(...args);