functionalscript 0.3.4 → 0.3.6

package/djs/module.f.js

@@ -0,0 +1,63 @@
+import * as list from "../types/list/module.f.js";
+const { flat, map } = 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 djs from "./serializer/module.f.js";
+const { undefinedSerialize } = djs;
+const colon = [':'];
+export const serialize = 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) {
+                    return arraySerialize(value);
+                }
+                return objectSerialize(value);
+            }
+        }
+    };
+    const arraySerialize = compose(map(f))(arrayWrap);
+    return f;
+};
+/**
+ * The standard `JSON.stringify` rules determined by
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ */
+export const stringify = sort => compose(serialize(sort))(concat);

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

@@ -0,0 +1,12 @@
+import * as result from '../../types/result/module.f.ts';
+import { type List } from '../../types/list/module.f.ts';
+import * as tokenizerT from '../tokenizer/module.f.ts';
+export type DjsModule = [readonly string[], readonly DjsConst[]];
+export type DjsConst = boolean | string | number | null | bigint | undefined | DjsModuleRef | DjsArray | DjsObject;
+type DjsModuleRef = ['aref' | 'cref', number];
+type DjsArray = ['array', readonly DjsConst[]];
+export type DjsObject = {
+    readonly [k in string]: DjsConst;
+};
+export declare const parse: (tokenList: List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>;
+export {};

package/djs/parser/module.f.js

@@ -0,0 +1,333 @@
+import * as result from "../../types/result/module.f.js";
+import { fold, first, drop, toArray, length, concat } from "../../types/list/module.f.js";
+import * as Operator from "../../types/function/operator/module.f.js";
+import * as tokenizerT from "../tokenizer/module.f.js";
+import { setReplace, at } from "../../types/map/module.f.js";
+import * as o from "../../types/object/module.f.js";
+const { fromMap } = o;
+const parseInitialOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        case 'id': {
+            switch (token.value) {
+                case 'import': return { ...state, state: 'import' };
+                case 'const': return { ...state, state: 'const' };
+                case 'export': return { ...state, state: 'export' };
+            }
+        }
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+const parseNewLineRequiredOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case '//':
+        case '/*': return state;
+        case 'nl': return { ...state, state: '' };
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const parseExportOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        case 'id': {
+            if (token.value === 'default')
+                return { ...state, state: 'exportValue', valueState: '', top: null, stack: null };
+        }
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+const parseResultOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const parseConstOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        case 'id': {
+            if (at(token.value)(state.module.refs) !== null)
+                return { state: 'error', message: 'duplicate id' };
+            let cref = ['cref', length(state.module.consts)];
+            let refs = setReplace(token.value)(cref)(state.module.refs);
+            return { ...state, state: 'const+name', module: { ...state.module, refs: refs } };
+        }
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const parseConstNameOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        case '=': return { ...state, state: 'constValue', valueState: '', top: null, stack: null };
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const parseImportOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        case 'id': {
+            if (at(token.value)(state.module.refs) !== null) {
+                return { state: 'error', message: 'duplicate id' };
+            }
+            let aref = ['aref', length(state.module.modules)];
+            let refs = setReplace(token.value)(aref)(state.module.refs);
+            return { ...state, state: 'import+name', module: { ...state.module, refs: refs } };
+        }
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const parseImportNameOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        case 'id': {
+            if (token.value === 'from')
+                return { ...state, state: 'import+from' };
+        }
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+const parseImportFromOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        case 'string': {
+            const modules = concat(state.module.modules)([token.value]);
+            return { ...state, state: 'nl', module: { ...state.module, modules: modules } };
+        }
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const addKeyToObject = obj => key => (['object', obj[1], key]);
+const addValueToObject = obj => value => (['object', setReplace(obj[2])(value)(obj[1]), '']);
+const addToArray = array => value => (['array', concat(array[1])([value])]);
+const pushKey = state => key => {
+    if (state.top?.[0] === 'object') {
+        return { ...state, valueState: '{k', top: addKeyToObject(state.top)(key), stack: state.stack };
+    }
+    return { state: 'error', message: 'error' };
+};
+const pushValue = state => value => {
+    if (state.top === null) {
+        let consts = concat(state.module.consts)([value]);
+        switch (state.state) {
+            case 'exportValue': return { ...state, state: 'result', module: { ...state.module, consts: consts } };
+            case 'constValue': return { ...state, state: 'nl', module: { ...state.module, consts: consts } };
+        }
+    }
+    if (state.top?.[0] === 'array') {
+        return { ...state, valueState: '[v', top: addToArray(state.top)(value), stack: state.stack };
+    }
+    return { ...state, valueState: '{v', top: addValueToObject(state.top)(value), stack: state.stack };
+};
+const pushRef = state => name => {
+    const ref = at(name)(state.module.refs);
+    if (ref === null)
+        return { state: 'error', message: 'const not found' };
+    return pushValue(state)(ref);
+};
+const startArray = state => {
+    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
+    return { ...state, valueState: '[', top: ['array', null], stack: newStack };
+};
+const endArray = state => {
+    const top = state.top;
+    const newState = { ...state, valueState: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
+    if (top !== null && top[0] === 'array') {
+        const array = ['array', toArray(top[1])];
+        return pushValue(newState)(array);
+    }
+    return pushValue(newState)(null);
+};
+const startObject = state => {
+    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
+    return { ...state, valueState: '{', top: ['object', null, ''], stack: newStack };
+};
+const endObject = state => {
+    const obj = state?.top !== null && state?.top[0] === 'object' ? fromMap(state.top[1]) : null;
+    const newState = { ...state, valueState: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
+    return pushValue(newState)(obj);
+};
+const tokenToValue = token => {
+    switch (token.kind) {
+        case 'null': return null;
+        case 'false': return false;
+        case 'true': return true;
+        case 'number': return parseFloat(token.value);
+        case 'string': return token.value;
+        case 'bigint': return token.value;
+        case 'undefined': return undefined;
+        default: return null;
+    }
+};
+const isValueToken = token => {
+    switch (token.kind) {
+        case 'null':
+        case 'false':
+        case 'true':
+        case 'number':
+        case 'string':
+        case 'bigint':
+        case 'undefined': return true;
+        default: return false;
+    }
+};
+const parseValueOp = token => state => {
+    if (isValueToken(token)) {
+        return pushValue(state)(tokenToValue(token));
+    }
+    switch (token.kind) {
+        case 'id': return pushRef(state)(token.value);
+        case '[': return startArray(state);
+        case '{': return startObject(state);
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const parseArrayStartOp = token => state => {
+    if (isValueToken(token)) {
+        return pushValue(state)(tokenToValue(token));
+    }
+    switch (token.kind) {
+        case 'id': return pushRef(state)(token.value);
+        case '[': return startArray(state);
+        case ']': return endArray(state);
+        case '{': return startObject(state);
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const parseArrayValueOp = token => state => {
+    switch (token.kind) {
+        case ']': return endArray(state);
+        case ',': return { ...state, valueState: '[,', top: state.top, stack: state.stack };
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const parseObjectStartOp = token => state => {
+    switch (token.kind) {
+        case 'string': return pushKey(state)(token.value);
+        case '}': return endObject(state);
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const parseObjectKeyOp = token => state => {
+    switch (token.kind) {
+        case ':': return { ...state, valueState: '{:', top: state.top, stack: state.stack };
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const parseObjectColonOp = token => state => {
+    if (isValueToken(token)) {
+        return pushValue(state)(tokenToValue(token));
+    }
+    switch (token.kind) {
+        case 'id': return pushRef(state)(token.value);
+        case '[': return startArray(state);
+        case '{': return startObject(state);
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const parseObjectNextOp = token => state => {
+    switch (token.kind) {
+        case '}': return endObject(state);
+        case ',': return { ...state, valueState: '{,', top: state.top, stack: state.stack };
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const parseObjectCommaOp = token => state => {
+    switch (token.kind) {
+        case 'string': return pushKey(state)(token.value);
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state;
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+const foldOp = token => state => {
+    switch (state.state) {
+        case '': return parseInitialOp(token)(state);
+        case 'nl': return parseNewLineRequiredOp(token)(state);
+        case 'import': return parseImportOp(token)(state);
+        case 'import+name': return parseImportNameOp(token)(state);
+        case 'import+from': return parseImportFromOp(token)(state);
+        case 'const': return parseConstOp(token)(state);
+        case 'const+name': return parseConstNameOp(token)(state);
+        case 'export': return parseExportOp(token)(state);
+        case 'result': return parseResultOp(token)(state);
+        case 'error': return { state: 'error', message: state.message };
+        case 'constValue':
+        case 'exportValue':
+            {
+                switch (state.valueState) {
+                    case '': return parseValueOp(token)(state);
+                    case '[': return parseArrayStartOp(token)(state);
+                    case '[v': return parseArrayValueOp(token)(state);
+                    case '[,': return parseValueOp(token)(state);
+                    case '{': return parseObjectStartOp(token)(state);
+                    case '{k': return parseObjectKeyOp(token)(state);
+                    case '{:': return parseObjectColonOp(token)(state);
+                    case '{v': return parseObjectNextOp(token)(state);
+                    case '{,': return parseObjectCommaOp(token)(state);
+                }
+            }
+    }
+};
+export const parse = (tokenList) => {
+    const state = fold(foldOp)({ state: '', module: { refs: null, modules: null, consts: null } })(tokenList);
+    switch (state.state) {
+        case 'result': return result.ok([toArray(state.module.modules), toArray(state.module.consts)]);
+        case 'error': return result.error(state.message);
+        default: return result.error('unexpected end');
+    }
+};

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

@@ -0,0 +1,12 @@
+declare const _default: {
+    valid: (() => void)[];
+    invalid: (() => void)[];
+    validWhiteSpaces: (() => void)[];
+    invalidModule: (() => void)[];
+    validWithConst: (() => void)[];
+    invalidWithConst: (() => void)[];
+    validWithArgs: (() => void)[];
+    invalidWithArgs: (() => void)[];
+    comments: (() => void)[];
+};
+export default _default;