functionalscript 0.3.4 → 0.3.5

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

@@ -0,0 +1,9 @@
+import * as list from '../../types/list/module.f.ts';
+import * as O from '../../types/object/module.f.ts';
+import * as DjsParser from '../parser/module.f.ts';
+export declare const undefinedSerialize: string[];
+type Entry = O.Entry<DjsParser.DjsConst>;
+type Entries = list.List<Entry>;
+type MapEntries = (entries: Entries) => Entries;
+export declare const djsModuleStringify: (mapEntries: MapEntries) => (djsModule: DjsParser.DjsModule) => string;
+export {};

package/djs/serializer/module.f.js

@@ -0,0 +1,81 @@
+import * as list from "../../types/list/module.f.js";
+const { flat, map, entries: listEntries, concat: listConcat, flatMap } = list;
+import * as string from "../../types/string/module.f.js";
+const { concat } = string;
+import * as O from "../../types/object/module.f.js";
+import * as f from "../../types/function/module.f.js";
+const { compose, fn } = f;
+const { entries } = Object;
+import * as bi from "../../types/bigint/module.f.js";
+const { serialize: bigintSerialize } = bi;
+import * as j from "../../json/serializer/module.f.js";
+const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j;
+import * as DjsParser from "../parser/module.f.js";
+const colon = [':'];
+export const undefinedSerialize = ['undefined'];
+const djsConstSerialize = sort => {
+    const propertySerialize = ([k, v]) => flat([
+        stringSerialize(k),
+        colon,
+        f(v)
+    ]);
+    const mapPropertySerialize = map(propertySerialize);
+    const objectSerialize = fn(entries)
+        .then(sort)
+        .then(mapPropertySerialize)
+        .then(objectWrap)
+        .result;
+    const f = value => {
+        switch (typeof value) {
+            case 'boolean': {
+                return boolSerialize(value);
+            }
+            case 'number': {
+                return numberSerialize(value);
+            }
+            case 'string': {
+                return stringSerialize(value);
+            }
+            case 'bigint': {
+                return [bigintSerialize(value)];
+            }
+            default: {
+                if (value === null) {
+                    return nullSerialize;
+                }
+                if (value === undefined) {
+                    return undefinedSerialize;
+                }
+                if (value instanceof Array) {
+                    switch (value[0]) {
+                        case 'aref': {
+                            return [`a${value[1]}`];
+                        }
+                        case 'cref': {
+                            return [`c${value[1]}`];
+                        }
+                        case 'array': {
+                            return arraySerialize(value[1]);
+                        }
+                    }
+                }
+                return objectSerialize(value);
+            }
+        }
+    };
+    const arraySerialize = compose(map(f))(arrayWrap);
+    return f;
+};
+export const djsModuleStringify = sort => djsModule => {
+    const importEntries = listEntries(djsModule[0]);
+    const importSerialize = entry => flat([['import a'], numberSerialize(entry[0]), [' from "', entry[1], '"\n']]);
+    const len = djsModule[1].length;
+    const constEntries = listEntries(djsModule[1]);
+    const moduleEntrySerialize = entry => {
+        if (entry[0] === len - 1) {
+            return listConcat(['export default '])(djsConstSerialize(sort)(entry[1]));
+        }
+        return flat([['const c'], numberSerialize(entry[0]), [' = '], djsConstSerialize(sort)(entry[1]), ['\n']]);
+    };
+    return concat(listConcat(flatMap(importSerialize)(importEntries))(flatMap(moduleEntrySerialize)(constEntries)));
+};

package/djs/test/input.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (string | number)[];
+export default _default;

package/djs/test/input.f.js

@@ -0,0 +1,4 @@
+import c from "./m.f.js";
+const a = 1;
+const b = 2;
+export default [a, b, c];

package/djs/test/m.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "text";
+export default _default;

package/djs/test/m.f.js

@@ -0,0 +1 @@
+export default "text";

package/djs/test.f.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    stringify: ({
+        sort: () => void;
+        identity: () => void;
+        stringify?: undefined;
+    } | {
+        stringify: () => void;
+        sort?: undefined;
+        identity?: undefined;
+    })[];
+};
+export default _default;

package/djs/test.f.js

@@ -0,0 +1,84 @@
+import * as json from "../json/module.f.js";
+import * as list from "../types/object/module.f.js";
+const { sort } = list;
+import * as f from "../types/function/module.f.js";
+const { identity } = f;
+import * as djs from "./module.f.js";
+export default {
+    stringify: [
+        {
+            sort: () => {
+                const r = json.setProperty("Hello")(['a'])({});
+                const x = djs.stringify(sort)(r);
+                if (x !== '{"a":"Hello"}') {
+                    throw x;
+                }
+            },
+            identity: () => {
+                const x = djs.stringify(identity)(json.setProperty("Hello")(['a'])({}));
+                if (x !== '{"a":"Hello"}') {
+                    throw x;
+                }
+            },
+        },
+        {
+            sort: () => {
+                const x = djs.stringify(sort)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
+                if (x !== '{"a":"Hello","b":12,"c":[]}') {
+                    throw x;
+                }
+            },
+            identity: () => {
+                const x = djs.stringify(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
+                if (x !== '{"c":[],"b":12,"a":"Hello"}') {
+                    throw x;
+                }
+            },
+        },
+        {
+            sort: () => {
+                const _0 = { a: { y: [24] }, c: [], b: 12 };
+                const _1 = json.setProperty("Hello")(['a', 'x'])(_0);
+                const _2 = djs.stringify(sort)(_1);
+                if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') {
+                    throw _2;
+                }
+            },
+            identity: () => {
+                const _0 = { a: { y: [24] }, c: [], b: 12 };
+                const _1 = json.setProperty("Hello")(['a', 'x'])(_0);
+                const _2 = djs.stringify(identity)(_1);
+                if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') {
+                    throw _2;
+                }
+            }
+        },
+        {
+            stringify: () => {
+                const bi = 1234567890n;
+                const result = djs.stringify(sort)(bi);
+                if (result !== '1234567890n') {
+                    throw result;
+                }
+            }
+        },
+        {
+            stringify: () => {
+                const arr = [0n, 1, 2n];
+                const result = djs.stringify(sort)(arr);
+                if (result !== '[0n,1,2n]') {
+                    throw result;
+                }
+            }
+        },
+        {
+            stringify: () => {
+                const obj = { "a": 0n, "b": 1, "c": 2n };
+                const result = djs.stringify(sort)(obj);
+                if (result !== '{"a":0n,"b":1,"c":2n}') {
+                    throw result;
+                }
+            }
+        }
+    ]
+};

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

@@ -0,0 +1,8 @@
+import * as list from '../../types/list/module.f.ts';
+import * as jsTokenizer from '../../js/tokenizer/module.f.ts';
+export type DjsToken = {
+    readonly kind: 'true' | 'false' | 'null' | 'undefined';
+} | {
+    readonly kind: '{' | '}' | ':' | ',' | '[' | ']' | '.' | '=';
+} | jsTokenizer.StringToken | jsTokenizer.NumberToken | jsTokenizer.ErrorToken | jsTokenizer.IdToken | jsTokenizer.BigIntToken | jsTokenizer.WhitespaceToken | jsTokenizer.NewLineToken | jsTokenizer.CommentToken;
+export declare const tokenize: (input: list.List<number>) => list.List<DjsToken>;

package/djs/tokenizer/module.f.js

@@ -0,0 +1,60 @@
+import * as Operator from "../../types/function/operator/module.f.js";
+import * as list from "../../types/list/module.f.js";
+const { empty, flat, stateScan } = list;
+import * as bf from "../../types/bigfloat/module.f.js";
+const { multiply } = bf;
+import * as jsTokenizer from "../../js/tokenizer/module.f.js";
+const mapToken = input => {
+    switch (input.kind) {
+        case 'id':
+        case 'bigint':
+        case '{':
+        case '}':
+        case ':':
+        case ',':
+        case '[':
+        case ']':
+        case '.':
+        case '=':
+        case 'true':
+        case 'false':
+        case 'null':
+        case 'string':
+        case 'number':
+        case 'ws':
+        case 'nl':
+        case 'undefined':
+        case '//':
+        case '/*':
+        case 'error': return [input];
+        default: return jsTokenizer.isKeywordToken(input) ? [{ kind: 'id', value: input.kind }] : [{ kind: 'error', message: 'invalid token' }];
+    }
+};
+const parseDefaultState = input => {
+    if (input === null)
+        return [empty, { kind: 'def' }];
+    switch (input.kind) {
+        case '-': return [empty, { kind: '-' }];
+        default: return [mapToken(input), { kind: 'def' }];
+    }
+};
+const parseMinusState = input => {
+    if (input === null)
+        return [[{ kind: 'error', message: 'invalid token' }], { kind: 'def' }];
+    switch (input.kind) {
+        case '-': return [[{ kind: 'error', message: 'invalid token' }], { kind: '-' }];
+        case 'bigint': return [[{ kind: 'bigint', value: -1n * input.value }], { kind: 'def' }];
+        case 'number': return [[{ kind: 'number', bf: multiply(input.bf)(-1n), value: `-${input.value}` }], { kind: 'def' }];
+        default: return [{ first: { kind: 'error', message: 'invalid token' }, tail: mapToken(input) }, { kind: 'def' }];
+    }
+};
+const scanToken = state => input => {
+    switch (state.kind) {
+        case '-': return parseMinusState(input);
+        default: return parseDefaultState(input);
+    }
+};
+export const tokenize = input => {
+    const jsTokens = jsTokenizer.tokenize(input);
+    return flat(stateScan(scanToken)({ kind: 'def' })(list.concat(jsTokens)([null])));
+};

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

@@ -0,0 +1,7 @@
+declare const _default: {
+    djs: (() => void)[];
+    id: (() => void)[];
+    keywords: (() => void)[];
+    comments: (() => void)[];
+};
+export default _default;