functionalscript 0.6.9 → 0.6.10

package/djs/transpiler/module.f.d.ts

@@ -3,13 +3,14 @@ import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
 import type { Fs } from '../../io/module.f.ts';
+import { type ParseError } from '../parser/module.f.ts';
 export type ParseContext = {
     readonly fs: Fs;
     readonly complete: OrderedMap<djsResult>;
     readonly stack: List<string>;
-    readonly error: string | null;
+    readonly error: ParseError | null;
 };
 export type djsResult = {
     djs: djs.Unknown;
 };
-export declare const transpile: (fs: Fs) => (path: string) => Result<djs.Unknown, string>;
+export declare const transpile: (fs: Fs) => (path: string) => Result<djs.Unknown, ParseError>;

package/djs/transpiler/module.f.js

@@ -30,9 +30,9 @@ const transpileWithImports = path => parseModuleResult => context => {
 const parseModule = path => context => {
     const content = context.fs.readFileSync(path, 'utf8');
     if (content === null) {
-        return error('file not found');
+        return error({ message: 'file not found', metadata: null });
     }
-    const tokens = tokenize(stringToList(content));
+    const tokens = tokenize(stringToList(content))(path);
     return parseFromTokens(tokens);
 };
 const foldNextModuleOp = path => context => {
@@ -40,7 +40,7 @@ const foldNextModuleOp = path => context => {
         return context;
     }
     if (includes(path)(context.stack)) {
-        return { ...context, error: 'circular dependency' };
+        return { ...context, error: { message: 'circular dependency', metadata: null } };
     }
     if (at(path)(context.complete) !== null) {
         return context;

package/djs/transpiler/test.f.js

@@ -54,7 +54,7 @@ export default {
         if (result[0] !== 'error') {
             throw result;
         }
-        if (result[1] !== 'file not found') {
+        if (result[1].message !== 'file not found') {
             throw result;
         }
     },
@@ -67,7 +67,7 @@ export default {
         if (result[0] !== 'error') {
             throw result;
         }
-        if (result[1] !== 'circular dependency') {
+        if (result[1].message !== 'circular dependency') {
             throw result;
         }
     },

package/io/module.js

@@ -15,7 +15,11 @@ export const io = {
     console,
     fs,
     process,
-    asyncImport: (v) => import(__rewriteRelativeImportExtension(`${prefix}${concat(process.cwd())(v)}`)),
+    asyncImport: (v) => {
+        const s0 = v.includes(':') || v.startsWith('/') ? v : concat(process.cwd())(v);
+        const s1 = s0.startsWith(prefix) ? s0 : `${prefix}${s0}`;
+        return import(__rewriteRelativeImportExtension(s1));
+    },
     performance,
     fetch,
     tryCatch: f => {

package/issues/31-json.f.d.ts

@@ -1 +1 @@
-type TerminalRange = readonly [number, number];
+export {};

package/issues/31-json.f.js

@@ -1,4 +1,3 @@
-"use strict";
 // JSON: https://www.json.org/json-en.html
 {
     // null, [0x09, 0x0A], 0x0D, 0x20
@@ -239,3 +238,4 @@
     };
     const _map = map;
 }
+export {};

package/issues/demo/data/data.f.js

@@ -0,0 +1,12 @@
+import shared from "./shared.f.js"
+
+// comment
+const s = "Hello, world!"
+
+export default {
+  "a": shared,
+  "b": shared,
+  "s": s,
+  d: -24n,
+  x: undefined,
+}

package/issues/demo/data/shared.f.js

@@ -0,0 +1,3 @@
+export default {
+    "name": "shared object"
+}

package/issues/demo/fs/app.js

@@ -0,0 +1,4 @@
+import math from "./math.f.js"
+
+const add2 = math.add(2)
+console.log("5 ===", add2(3))

package/issues/demo/fs/math.f.js

@@ -0,0 +1,4 @@
+export default {
+  add: a => b => a + b,
+  mul: a => b => a * b,
+}

package/issues/demo/test/test.f.js

@@ -0,0 +1,13 @@
+const arrayOfTests = [
+  () => {
+    if (2 + 2 !== 4) throw "It's the end of the world as we know it!"
+  },
+  () => {
+    if (2n + 2n !== 4n) throw "It's the end of the world as we know it!"
+  }
+]
+
+export default {
+  arrayOfTests,
+  generatingTests: () => arrayOfTests,
+}

package/js/tokenizer/module.f.d.ts

@@ -79,8 +79,20 @@ export type CommentToken = {
     readonly kind: '//' | '/*';
     readonly value: string;
 };
-export type JsToken = KeywordToken | TrueToken | FalseToken | NullToken | WhitespaceToken | NewLineToken | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | UndefinedToken | OperatorToken | CommentToken;
+export type EofToken = {
+    readonly kind: 'eof';
+};
+export type JsToken = KeywordToken | TrueToken | FalseToken | NullToken | WhitespaceToken | NewLineToken | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | UndefinedToken | OperatorToken | CommentToken | EofToken;
+export type TokenMetadata = {
+    readonly path: string;
+    readonly line: number;
+    readonly column: number;
+};
+export type JsTokenWithMetadata = {
+    readonly token: JsToken;
+    readonly metadata: TokenMetadata;
+};
 type ErrorMessage = '" are missing' | 'unescaped character' | 'invalid hex value' | 'unexpected character' | 'invalid number' | 'invalid token' | '*\/ expected' | 'unterminated string literal' | 'eof';
 export declare const isKeywordToken: (token: JsToken) => boolean;
-export declare const tokenize: (input: list.List<number>) => list.List<JsToken>;
+export declare const tokenize: (input: list.List<number>) => (path: string) => list.List<JsTokenWithMetadata>;
 export {};

package/js/tokenizer/module.f.js

@@ -6,7 +6,7 @@ import * as map from "../../types/ordered_map/module.f.js";
 const { at } = map;
 import * as _range from "../../types/range/module.f.js";
 const { one } = _range;
-const { empty, stateScan, flat, toArray, reduce: listReduce, scan } = list;
+const { empty, stateScan, flat, toArray, reduce: listReduce, scan, map: listMap } = list;
 const { fromCharCode } = String;
 import * as ascii from "../../text/ascii/module.f.js";
 const { range } = ascii;
@@ -449,7 +449,7 @@ const parseWhitespaceStateOp = create(parseWhitespaceDefault)([
     rangeSetFunc(rangeSetWhiteSpace)(state => () => [empty, state]),
     rangeSetFunc(rangeSetNewLine)(() => () => [empty, { kind: 'nl' }])
 ]);
-const parseNewLineDefault = state => input => {
+const parseNewLineDefault = _ => input => {
     const next = tokenizeOp({ kind: 'initial' })(input);
     return [{ first: { kind: 'nl' }, tail: next[0] }, next[1]];
 };
@@ -478,30 +478,43 @@ const tokenizeCharCodeOp = state => {
 };
 const tokenizeEofOp = state => {
     switch (state.kind) {
-        case 'initial': return [empty, { kind: 'eof' }];
-        case 'id': return [[idToToken(state.value)], { kind: 'eof' }];
+        case 'initial': return [[{ kind: 'eof' }], { kind: 'eof' }];
+        case 'id': return [[idToToken(state.value), { kind: 'eof' }], { kind: 'eof' }];
         case 'string':
         case 'escapeChar':
-        case 'unicodeChar': return [[{ kind: 'error', message: '" are missing' }], { kind: 'eof' }];
-        case 'invalidNumber': return [[{ kind: 'error', message: 'invalid number' }], { kind: 'eof' }];
+        case 'unicodeChar': return [[{ kind: 'error', message: '" are missing' }, { kind: 'eof' }], { kind: 'eof' }];
+        case 'invalidNumber': return [[{ kind: 'error', message: 'invalid number' }, { kind: 'eof' }], { kind: 'eof' }];
         case 'number':
             switch (state.numberKind) {
                 case '.':
                 case 'e':
                 case 'e+':
-                case 'e-': return [[{ kind: 'error', message: 'invalid number' }], { kind: 'eof', }];
+                case 'e-': return [[{ kind: 'error', message: 'invalid number' }, { kind: 'eof' }], { kind: 'eof', }];
             }
-            return [[bufferToNumberToken(state)], { kind: 'eof' }];
-        case 'op': return [[getOperatorToken(state.value)], { kind: 'eof' }];
-        case '//': return [[{ kind: '//', value: state.value }], { kind: 'eof' }];
+            return [[bufferToNumberToken(state), { kind: 'eof' }], { kind: 'eof' }];
+        case 'op': return [[getOperatorToken(state.value), { kind: 'eof' }], { kind: 'eof' }];
+        case '//': return [[{ kind: '//', value: state.value }, { kind: 'eof' }], { kind: 'eof' }];
         case '/*':
-        case '/**': return [[{ kind: 'error', message: '*/ expected' }], { kind: 'eof', }];
-        case 'ws': return [[{ kind: 'ws' }], { kind: 'eof' }];
-        case 'nl': return [[{ kind: 'nl' }], { kind: 'eof' }];
-        case 'eof': return [[{ kind: 'error', message: 'eof' }], state];
+        case '/**': return [[{ kind: 'error', message: '*/ expected' }, { kind: 'eof' }], { kind: 'eof', }];
+        case 'ws': return [[{ kind: 'ws' }, { kind: 'eof' }], { kind: 'eof' }];
+        case 'nl': return [[{ kind: 'nl' }, { kind: 'eof' }], { kind: 'eof' }];
+        case 'eof': return [[{ kind: 'error', message: 'eof' }, { kind: 'eof' }], state];
     }
 };
 const tokenizeOp = state => input => input === null ? tokenizeEofOp(state) : tokenizeCharCodeOp(state)(input);
-const scanTokenize = stateScan(tokenizeOp);
-const initial = scanTokenize({ kind: 'initial' });
-export const tokenize = (input) => flat(initial(flat([input, [null]])));
+const mapTokenWithMetadata = metadata => token => { return { token, metadata }; };
+const tokenizeWithPositionOp = ({ state, metadata }) => input => {
+    if (input == null) {
+        const newState = tokenizeEofOp(state);
+        return [listMap(mapTokenWithMetadata(metadata))(newState[0]), { state: newState[1], metadata }];
+    }
+    const newState = tokenizeCharCodeOp(state)(input);
+    const isNewLine = input == lf;
+    const newMetadata = { path: metadata.path, line: isNewLine ? metadata.line + 1 : metadata.line, column: isNewLine ? 1 : metadata.column + 1 };
+    return [listMap(mapTokenWithMetadata(metadata))(newState[0]), { state: newState[1], metadata: newMetadata }];
+};
+const scanTokenize = stateScan(tokenizeWithPositionOp);
+export const tokenize = input => path => {
+    const scan = scanTokenize({ state: { kind: 'initial' }, metadata: { path, line: 1, column: 1 } });
+    return flat(scan(flat([input, [null]])));
+};

package/js/tokenizer/test.f.d.ts

@@ -5,5 +5,6 @@ declare const _default: {
     id: (() => void)[];
     keywords: (() => void)[];
     comments: (() => void)[];
+    metadata: (() => void)[];
 };
 export default _default;