functionalscript 0.2.5 → 0.3.0

package/out/json/module.f.d.mts

@@ -1,33 +0,0 @@
-/**
- * @typedef {{
- *  readonly [k in string]: Unknown
- * }} Object
- */
-/** @typedef {readonly Unknown[]} Array */
-/** @typedef {Object|boolean|string|number|null|Array} Unknown */
-/** @type {(value: Unknown) => (path: list.List<string>) => (src: Unknown) => Unknown} */
-export const setProperty: (value: Unknown) => (path: list.List<string>) => (src: Unknown) => Unknown;
-/** @typedef {object.Entry<Unknown>} Entry*/
-/** @typedef {(list.List<Entry>)} Entries */
-/** @typedef {(entries: Entries) => Entries} MapEntries */
-/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
-export const serialize: (mapEntries: MapEntries) => (value: Unknown) => list.List<string>;
-/**
- * The standard `JSON.stringify` rules determined by
- * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
- *
- * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
- */
-export const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
-/** @type {(value: string) => Unknown} */
-export const parse: (value: string) => Unknown;
-/** @type {(value: Unknown) => value is Object} */
-export const isObject: (value: Unknown) => value is Object;
-export type Object = { readonly [k in string]: Unknown; };
-export type Array = readonly Unknown[];
-export type Unknown = Object | boolean | string | number | null | Array;
-export type Entry = object.Entry<Unknown>;
-export type Entries = (list.List<Entry>);
-export type MapEntries = (entries: Entries) => Entries;
-import * as list from '../types/list/module.f.mjs';
-import * as object from '../types/object/module.f.mjs';

package/out/json/module.f.mjs

@@ -1,89 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as list from '../types/list/module.f.mjs';
-const { next, flat, map } = list;
-import * as string from '../types/string/module.f.mjs';
-const { concat } = string;
-import * as object from '../types/object/module.f.mjs';
-const { at } = object;
-import * as f from '../types/function/module.f.mjs';
-const { compose, fn } = f;
-const { entries } = Object;
-import * as s from './serializer/module.f.mjs';
-const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = s;
-/**
- * @typedef {{
- *  readonly [k in string]: Unknown
- * }} Object
- */
-/** @typedef {readonly Unknown[]} Array */
-/** @typedef {Object|boolean|string|number|null|Array} Unknown */
-/** @type {(value: Unknown) => (path: list.List<string>) => (src: Unknown) => Unknown} */
-export const setProperty = value => {
-    /** @type {(path: list.List<string>) => (src: Unknown) => Unknown} */
-    const f = path => src => {
-        const result = next(path);
-        if (result === null) {
-            return value;
-        }
-        const srcObject = (src === null || typeof src !== 'object' || src instanceof Array) ? {} : src;
-        const { first, tail } = result;
-        return { ...srcObject, [first]: f(tail)(at(first)(srcObject)) };
-    };
-    return f;
-};
-const colon = [':'];
-/** @typedef {object.Entry<Unknown>} Entry*/
-/** @typedef {(list.List<Entry>)} Entries */
-/** @typedef {(entries: Entries) => Entries} MapEntries */
-/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
-export const serialize = sort => {
-    /** @type {(kv: readonly[string, Unknown]) => list.List<string>} */
-    const propertySerialize = ([k, v]) => flat([
-        stringSerialize(k),
-        colon,
-        f(v)
-    ]);
-    const mapPropertySerialize = map(propertySerialize);
-    /** @type {(object: Object) => list.List<string>} */
-    const objectSerialize = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
-        .result;
-    /** @type {(value: Unknown) => list.List<string>} */
-    const f = value => {
-        switch (typeof value) {
-            case 'boolean': {
-                return boolSerialize(value);
-            }
-            case 'number': {
-                return numberSerialize(value);
-            }
-            case 'string': {
-                return stringSerialize(value);
-            }
-            default: {
-                if (value === null) {
-                    return nullSerialize;
-                }
-                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
- *
- * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
- */
-export const stringify = sort => compose(serialize(sort))(concat);
-/** @type {(value: string) => Unknown} */
-export const parse = JSON.parse;
-/** @type {(value: Unknown) => value is Object} */
-export const isObject = value => typeof value === 'object' && value !== null && !(value instanceof Array);

package/out/json/parser/module.f.d.mts

@@ -1,32 +0,0 @@
-/** @type {(tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>} */
-export const parse: (tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>;
-export type JsonObject = {
-    readonly kind: "object";
-    readonly values: map.Map<Json.Unknown>;
-    readonly key: string;
-};
-export type JsonArray = {
-    readonly kind: "array";
-    readonly values: list.List<Json.Unknown>;
-};
-export type JsonStackElement = JsonObject | JsonArray;
-export type JsonStack = list.List<JsonStackElement>;
-export type StateParse = {
-    readonly status: "" | "[" | "[v" | "[," | "{" | "{k" | "{:" | "{v" | "{,";
-    readonly top: JsonStackElement | null;
-    readonly stack: JsonStack;
-};
-export type StateResult = {
-    readonly status: "result";
-    readonly value: Json.Unknown;
-};
-export type StateError = {
-    readonly status: "error";
-    readonly message: string;
-};
-export type JsonState = StateParse | StateResult | StateError;
-import * as list from '../../types/list/module.f.mjs';
-import * as Tokenizer from '../tokenizer/module.f.mjs';
-import * as result from '../../types/result/module.f.mjs';
-import * as Json from '../module.f.mjs';
-import * as map from '../../types/map/module.f.mjs';

package/out/json/parser/module.f.mjs

@@ -1,224 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as result from '../../types/result/module.f.mjs';
-import * as list from '../../types/list/module.f.mjs';
-const { fold, first, drop, toArray } = list;
-import * as Operator from '../../types/function/operator/module.f.mjs';
-import * as Tokenizer from '../tokenizer/module.f.mjs';
-import * as map from '../../types/map/module.f.mjs';
-const { setReplace } = map;
-import * as Json from '../module.f.mjs';
-import * as o from '../../types/object/module.f.mjs';
-const { fromMap } = o;
-/**
- * @typedef {{
-* readonly kind: 'object'
-* readonly values: map.Map<Json.Unknown>
-* readonly key: string
-* }} JsonObject
-* */
-/**
- * @typedef {{
-* readonly kind: 'array'
-* readonly values: list.List<Json.Unknown>
-* }} JsonArray
-* */
-/**
- * @typedef {|
-* JsonObject |
-* JsonArray
-* } JsonStackElement
-*/
-/** @typedef {list.List<JsonStackElement>} JsonStack */
-/**
- * @typedef {{
-*  readonly status: '' | '[' | '[v' | '[,' | '{' | '{k' | '{:' | '{v' | '{,'
-*  readonly top: JsonStackElement | null
-*  readonly stack: JsonStack
-* }} StateParse
-*/
-/**
- * @typedef {{
-*  readonly status: 'result'
-*  readonly value: Json.Unknown
-* }} StateResult
-*/
-/**
- * @typedef {{
-*  readonly status: 'error'
-*  readonly message: string
-* }} StateError
-*/
-/**
- * @typedef {|
-* StateParse |
-* StateResult |
-* StateError
-* } JsonState
-*/
-/** @type {(obj: JsonObject) => (key: string) => JsonObject} */
-const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key });
-/** @type {(obj: JsonObject) => (value: Json.Unknown) => JsonObject} */
-const addValueToObject = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' });
-/** @type {(array: JsonArray) => (value: Json.Unknown) => JsonArray} */
-const addToArray = array => value => ({ kind: 'array', values: list.concat(array.values)([value]) });
-/** @type {(state: StateParse) => (key: string) => JsonState} */
-const pushKey = state => value => {
-    if (state.top?.kind === 'object') {
-        return { status: '{k', top: addKeyToObject(state.top)(value), stack: state.stack };
-    }
-    return { status: 'error', message: 'error' };
-};
-/** @type {(state: StateParse) => (value: Json.Unknown) => JsonState} */
-const pushValue = state => value => {
-    if (state.top === null) {
-        return { status: 'result', value: value };
-    }
-    if (state.top.kind === 'array') {
-        return { status: '[v', top: addToArray(state.top)(value), stack: state.stack };
-    }
-    return { status: '{v', top: addValueToObject(state.top)(value), stack: state.stack };
-};
-/** @type {(state: StateParse) => JsonState} */
-const startArray = state => {
-    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
-    return { status: '[', top: { kind: 'array', values: null }, stack: newStack };
-};
-/** @type {(state: StateParse) => JsonState} */
-const endArray = state => {
-    const array = state.top !== null ? toArray(state.top.values) : null;
-    /** @type {StateParse} */
-    const newState = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
-    return pushValue(newState)(array);
-};
-/** @type {(state: StateParse) => JsonState} */
-const startObject = state => {
-    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
-    return { status: '{', top: { kind: 'object', values: null, key: '' }, stack: newStack };
-};
-/** @type {(state: StateParse) => JsonState} */
-const endObject = state => {
-    const obj = state.top?.kind === 'object' ? fromMap(state.top.values) : null;
-    /** @type {StateParse} */
-    const newState = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
-    return pushValue(newState)(obj);
-};
-/** @type {(token: Tokenizer.JsonToken) => Json.Unknown} */
-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;
-        default: return null;
-    }
-};
-/** @type {(token: Tokenizer.JsonToken) => boolean} */
-const isValueToken = token => {
-    switch (token.kind) {
-        case 'null':
-        case 'false':
-        case 'true':
-        case 'number':
-        case 'string': return true;
-        default: return false;
-    }
-};
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseValueOp = token => state => {
-    if (isValueToken(token)) {
-        return pushValue(state)(tokenToValue(token));
-    }
-    if (token.kind === '[') {
-        return startArray(state);
-    }
-    if (token.kind === '{') {
-        return startObject(state);
-    }
-    return { status: 'error', message: 'unexpected token' };
-};
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseArrayStartOp = token => state => {
-    if (isValueToken(token)) {
-        return pushValue(state)(tokenToValue(token));
-    }
-    if (token.kind === '[') {
-        return startArray(state);
-    }
-    if (token.kind === ']') {
-        return endArray(state);
-    }
-    if (token.kind === '{') {
-        return startObject(state);
-    }
-    return { status: 'error', message: 'unexpected token' };
-};
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseArrayValueOp = token => state => {
-    if (token.kind === ']') {
-        return endArray(state);
-    }
-    if (token.kind === ',') {
-        return { status: '[,', top: state.top, stack: state.stack };
-    }
-    return { status: 'error', message: 'unexpected token' };
-};
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseObjectStartOp = token => state => {
-    if (token.kind === 'string') {
-        return pushKey(state)(token.value);
-    }
-    if (token.kind === '}') {
-        return endObject(state);
-    }
-    return { status: 'error', message: 'unexpected token' };
-};
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseObjectKeyOp = token => state => {
-    if (token.kind === ':') {
-        return { status: '{:', top: state.top, stack: state.stack };
-    }
-    return { status: 'error', message: 'unexpected token' };
-};
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseObjectNextOp = token => state => {
-    if (token.kind === '}') {
-        return endObject(state);
-    }
-    if (token.kind === ',') {
-        return { status: '{,', top: state.top, stack: state.stack };
-    }
-    return { status: 'error', message: 'unexpected token' };
-};
-/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
-const parseObjectCommaOp = token => state => {
-    if (token.kind === 'string') {
-        return pushKey(state)(token.value);
-    }
-    return { status: 'error', message: 'unexpected token' };
-};
-/** @type {Operator.Fold<Tokenizer.JsonToken, JsonState>} */
-const foldOp = token => state => {
-    switch (state.status) {
-        case 'result': return { status: 'error', message: 'unexpected token' };
-        case 'error': return { status: 'error', message: state.message };
-        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 parseValueOp(token)(state);
-        case '{v': return parseObjectNextOp(token)(state);
-        case '{,': return parseObjectCommaOp(token)(state);
-    }
-};
-/** @type {(tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>} */
-export const parse = tokenList => {
-    const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList);
-    switch (state.status) {
-        case 'result': return result.ok(state.value);
-        case 'error': return result.error(state.message);
-        default: return result.error('unexpected end');
-    }
-};

package/out/json/parser/test.f.d.mts

@@ -1,5 +0,0 @@
-declare namespace _default {
-    let valid: (() => void)[];
-    let invalid: (() => void)[];
-}
-export default _default;