tex2typst 0.3.27-beta.1 → 0.3.27

package/tests/tex-to-typst.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, test, expect } from 'vitest';
+import { tokenize_tex } from '../src/tex-tokenizer';
+import { parseTex } from '../src/tex-parser';
+import { tex2typst } from '../src/index';
+import { TypstWriterError } from '../src/typst-writer';
+import { TexNode, TexToken } from '../src/tex-types';
+import type { Tex2TypstOptions } from '../src/exposed-types';
+import { loadTestCases, TestCase } from './test-common';
+import { ConverterError } from '../src/convert';
+
+describe('options', () => {
+    it('nonStrict = false', function () {
+        const input = '\\nonExistentCommand';
+        // must throw error
+        expect(() => tex2typst(input, { nonStrict: false })).toThrowError(ConverterError);
+    });
+
+
+    it('fracToSlash = true', function () {
+        const input = '\\frac{a}{b}';
+        const expected = 'a/b';
+        const res = tex2typst(input, { fracToSlash: true });
+        expect(res).toEqual(expected);
+    });
+
+    it('fracToSlash = false', function () {
+        const input = '\\frac{a}{b}';
+        const expected = 'frac(a, b)';
+        const res = tex2typst(input, { fracToSlash: false });
+        expect(res).toEqual(expected);
+    });
+
+
+    it('nonAsciiWrapper = ""', function () {
+        const input = 'a + b = \\text{こにちは、世界}';
+        const expected = 'a + b = "こにちは、世界"';
+        const res = tex2typst(input);
+        expect(res).toEqual(expected);
+    });
+
+    it('nonAsciiWrapper = "ut"', function () {
+        const input = 'a + b = \\text{こにちは、世界}';
+        const expected = 'a + b = ut("こにちは、世界")';
+        const res = tex2typst(input, { nonAsciiWrapper: 'ut' });
+        expect(res).toEqual(expected);
+    });
+
+    it('preferShorthands = true', function () {
+        const map = new Map<string, string>([
+            ['a \\rightarrow b', 'a -> b'],
+            ['a \\to b', 'a -> b'],
+            ['a \\implies b', 'a ==> b'],
+            ['a \\iff b', 'a <==> b'],
+            ['a \\ll b', 'a << b'],
+            ['a \\gg b', 'a >> b'],
+
+        ]);
+        for(const [input, expected] of map.entries()) {
+            const res = tex2typst(input, { preferShorthands: true });
+            expect(res).toEqual(expected);
+        }
+    });
+
+    it('preferShorthands = false', function () {
+        const map = new Map<string, string>([
+            ['a \\rightarrow b', 'a arrow.r b'],
+            ['a \\to b', 'a arrow.r b'],
+            ['a \\implies b', 'a arrow.r.double.long b'],
+            ['a \\iff b', 'a arrow.l.r.double.long b'],
+            ['a \\ll b', 'a lt.double b'],
+            ['a \\gg b', 'a gt.double b'],
+
+        ]);
+        for(const [input, expected] of map.entries()) {
+            const res = tex2typst(input, { preferShorthands: false });
+            expect(res).toEqual(expected);
+        }
+    });
+
+    it ('customTexMacros', function () {
+        const input = '\\myop y=\\sgn(x)';
+        const expected = 'op("myop") y = op("sgn")(x)';
+        const res = tex2typst(input, { customTexMacros: {
+            '\\myop': '\\operatorname{myop}',
+            '\\sgn': '\\operatorname{sgn}',
+        } });
+        expect(res).toEqual(expected);
+    });
+
+    it ('customTexMacros 2', function () {
+        const input = '123 \\foo 456';
+        const expected = '123 root(3, x) 456';
+        const res = tex2typst(input, { customTexMacros: {
+            '\\foo': '\\sqrt[3]{x}',
+        } });
+        expect(res).toEqual(expected);
+    });
+});
+
+
+const caseFiles = ["struct-tex2typst.yaml", "symbol.yml", "struct-bidirection.yaml", "integration-tex2typst.yaml"];
+
+caseFiles.forEach((ymlFilename) => {
+  const suite = loadTestCases(ymlFilename);
+  describe(ymlFilename, () => {
+    suite.cases.forEach((c: TestCase) => {
+      test(c.title, function() {
+        const {tex, typst} = c;
+        let tokens: null | TexToken[] = null;
+        let tex_node: null | TexNode = null;
+        let result: null | string = null;
+        try {
+          const settings: Tex2TypstOptions = {
+            nonStrict: c.nonStrict? c.nonStrict: false,
+            preferShorthands: c.preferShorthands !== undefined? c.preferShorthands: true,
+            inftyToOo: c.inftyToOo !== undefined? c.inftyToOo: false,
+            customTexMacros: c.customTexMacros? c.customTexMacros: {},
+          };
+          tokens = tokenize_tex(tex);
+          tex_node = parseTex(tex, settings.customTexMacros!);
+          result = tex2typst(tex, settings);
+          if (result !== typst) {
+            console.log(`====== 😭 Wrong ======`);
+            console.log(tex);
+            console.log(tokens);
+            console.dir(tex_node, {depth: null});
+          }
+          expect(result).toBe(typst);
+        } catch (e) {
+          console.log(`====== 😭 Error ======`);
+          if (e instanceof TypstWriterError) {
+            console.log(e.node);
+          }
+          if (tex_node !== null) {
+            console.dir(tex_node, {depth: null});
+          }
+          console.log(tex);
+          throw e;
+        }
+      })
+    });
+  });
+});

package/tests/typst-parser.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from 'vitest';
+import { tokenize_typst } from '../src/typst-tokenizer';
+import { TypstParser } from '../src/typst-parser';
+import { TypstFraction, TypstFuncCall, TypstGroup, TypstLeftright, TypstSupsub, TypstTerminal, TypstToken, TypstTokenType } from '../src/typst-types';
+
+
+describe('typst-tokenizer', () => {
+    it('a + b', function () {
+        const res = tokenize_typst('a + b');
+        expect(res).toEqual([
+            new TypstToken(TypstTokenType.ELEMENT, 'a'),
+            new TypstToken(TypstTokenType.SPACE, ' '),
+            new TypstToken(TypstTokenType.ELEMENT, '+'),
+            new TypstToken(TypstTokenType.SPACE, ' '),
+            new TypstToken(TypstTokenType.ELEMENT, 'b'),
+        ]);
+    });
+
+    it('a (x)', function () {
+        const res = tokenize_typst('a (x)');
+        expect(res).toEqual([
+            new TypstToken(TypstTokenType.ELEMENT, 'a'),
+            new TypstToken(TypstTokenType.SPACE, ' '),
+            new TypstToken(TypstTokenType.ELEMENT, '('),
+            new TypstToken(TypstTokenType.ELEMENT, 'x'),
+            new TypstToken(TypstTokenType.ELEMENT, ')'),
+        ]);
+    });
+
+    it('f(x)', function () {
+        const res = tokenize_typst('f(x)');
+        expect(res).toEqual([
+            new TypstToken(TypstTokenType.ELEMENT, 'f'),
+            new TypstToken(TypstTokenType.ELEMENT, '('),
+            new TypstToken(TypstTokenType.ELEMENT, 'x'),
+            new TypstToken(TypstTokenType.ELEMENT, ')'),
+        ]);
+    });
+
+    it('comment', function() {
+        const res = tokenize_typst('a // comment');
+        expect(res).toEqual([
+            new TypstToken(TypstTokenType.ELEMENT, 'a'),
+            new TypstToken(TypstTokenType.SPACE, ' '),
+            new TypstToken(TypstTokenType.COMMENT, ' comment'),
+        ]);
+    })
+});
+
+describe('typst-parser', () => {
+    const parser = new TypstParser();
+    it('a + b', function () {
+        const tokens = tokenize_typst('a + b');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstGroup([
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'a')),
+            new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, '+')),
+            new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'b')),
+        ]));
+    });
+
+    it('a (x)', function () {
+        const tokens = tokenize_typst('a (x)');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstGroup([
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'a')),
+            new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+            new TypstLeftright(null, {
+                body: new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'x')),
+                left: new TypstToken(TypstTokenType.ELEMENT, '('),
+                right: new TypstToken(TypstTokenType.ELEMENT, ')')
+            })
+        ]));
+    });
+
+    it('f(x)', function () {
+        const tokens = tokenize_typst('f(x)');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstFuncCall(new TypstToken(TypstTokenType.ELEMENT, 'f'), [
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'x')),
+        ]));
+    });
+
+    it('root(x, 3)', function () {
+        const tokens = tokenize_typst('root(x, 3)');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstFuncCall(new TypstToken(TypstTokenType.SYMBOL, 'root'), [
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'x')),
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, '3')),
+        ]));
+    });
+
+    it('lim_(x arrow.r 0)', function () {
+        const tokens = tokenize_typst('lim_(x arrow.r 0)');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstSupsub({
+            base: new TypstTerminal(new TypstToken(TypstTokenType.SYMBOL, 'lim')),
+            sub: new TypstGroup([
+                new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'x')),
+                new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+                new TypstTerminal(new TypstToken(TypstTokenType.SYMBOL, 'arrow.r')),
+                new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+                new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, '0')),
+            ]),
+            sup: null,
+        }));
+    });
+
+    it('a -> b', function () {
+        const tokens = tokenize_typst('a -> b');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstGroup([
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'a')),
+            new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+            new TypstTerminal(new TypstToken(TypstTokenType.SYMBOL, 'arrow.r')),
+            new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'b')),
+        ]));
+    });
+
+    it('1/(2/3)', function () {
+        const tokens = tokenize_typst('1/(2/3)');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstFraction([
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, '1')),
+            new TypstFraction([
+                new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, '2')),
+                new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, '3')),
+            ]),
+        ]));
+    });
+});

package/tests/typst-to-tex.test.ts

@@ -0,0 +1,76 @@
+
+import { describe, it, test, expect } from 'vitest';
+import { parseTypst } from '../src/typst-parser';
+import { TexWriter } from '../src/tex-writer';
+import { convert_typst_node_to_tex } from '../src/convert';
+import { loadTestCases, TestCase  } from './test-common';
+
+
+
+describe('examples', () => {
+    it('a + b', function () {
+        const typst_node = parseTypst('a + b');
+        const tex_node = convert_typst_node_to_tex(typst_node);
+        const writer = new TexWriter();
+        writer.append(tex_node);
+        const res = writer.finalize();
+        expect(res).toEqual('a + b');
+    });
+
+    it('sqrt(x)', function () {
+        const typst_node = parseTypst('sqrt(x)');
+        const tex_node = convert_typst_node_to_tex(typst_node);
+        const writer = new TexWriter();
+        writer.append(tex_node);
+        const res = writer.finalize();
+        expect(res).toEqual('\\sqrt{x}');
+    });
+
+    it('integral_a^b f(x) dif x', function () {
+        const typst_node = parseTypst('integral_a^b f(x) dif x');
+        const tex_node = convert_typst_node_to_tex(typst_node);
+        const writer = new TexWriter();
+        writer.append(tex_node);
+        const res = writer.finalize();
+        expect(res).toEqual('\\int_a^b f(x) \\mathrm{d} x');
+    });
+
+    it('lr({a + 1/3))', function () {
+        const typst_node = parseTypst('lr({a + 1/3))');
+        const tex_node = convert_typst_node_to_tex(typst_node);
+        const writer = new TexWriter();
+        writer.append(tex_node);
+        const res = writer.finalize();
+        expect(res).toEqual('\\left\\{a + \\frac{1}{3} \\right)');
+    });
+});
+
+
+
+describe('struct-typst2tex.yaml', function () {
+    const suite = loadTestCases('struct-typst2tex.yaml');
+    suite.cases.forEach((c: TestCase) => {
+        test(c.title, function () {
+            const typst_node = parseTypst(c.typst);
+            const tex_node = convert_typst_node_to_tex(typst_node);
+            const writer = new TexWriter();
+            writer.append(tex_node);
+            const res = writer.finalize();
+            expect(res).toEqual(c.tex);
+        });
+    });
+});
+
+describe('struct-bidirection.yaml', function () {
+    const suite = loadTestCases('struct-bidirection.yaml');
+    suite.cases.forEach((c: TestCase) => {
+        test(c.title, function () {
+            const typst_node = parseTypst(c.typst);
+            const tex_node = convert_typst_node_to_tex(typst_node);
+            const writer = new TexWriter();
+            writer.append(tex_node);
+            const res = writer.finalize();
+            expect(res).toEqual(c.tex);
+        });
+    });
+});

package/tsconfig.json

@@ -25,7 +25,7 @@
     /* Modules */
     // "module": "es6",                                  /* Specify what module code is generated. */
     // "rootDir": "./",                                  /* Specify the root folder within your source files. */
-    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    "moduleResolution": "bundler",                     /* Specify how TypeScript looks up a file from a given module specifier. */
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
     // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
     // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
@@ -77,7 +77,7 @@
 
     /* Type Checking */
     "strict": true,                                      /* Enable all strict type-checking options. */
-    "noImplicitAny": false,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "noImplicitAny": false,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
     // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
     // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
@@ -101,10 +101,10 @@
     "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
   },
   "include": [
-    "src/**/*.ts"
+    "src/**/*.ts",
+    "tests/**/*.ts",
   ],
   "exclude": [
     "src/tex2typst.ts",
-    "tests/**/*"
   ]
 }