functionalscript 0.2.5 → 0.3.0

package/commonjs/package/dependencies/module.f.mjs

@@ -1,22 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as json from '../../../json/module.f.mjs'
-const { isObject } = json
-import * as list from '../../../types/list/module.f.mjs'
-const { map, every } = list
-const { entries } = Object
-
-/** @typedef {readonly[string, string]} DependencyJson */
-
-/** @typedef {{readonly[k in string]: string}} DependencyMapJson */
-
-/** @typedef {DependencyMapJson|null} DependenciesJson */
-
-/** @type {(entry: json.Entry) => boolean} */
-const isDependencyJson = ([, v]) => typeof v === 'string'
-
-/** @type {(j: json.Unknown) => j is DependenciesJson} */
-export const isDependenciesJson = j => {
-    if (j === null) { return true }
-    if (!isObject(j)) { return false }
-    return every(map(isDependencyJson)(entries(j)))
-}

package/commonjs/package/module.f.mjs

@@ -1,36 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as json from '../../json/module.f.mjs'
-const { isObject } = json
-import * as dependencies from './dependencies/module.f.mjs'
-const { isDependenciesJson } = dependencies
-import * as o from '../../types/object/module.f.mjs'
-const { at } = o
-
-/**
- * @typedef {{
- *  readonly name: string
- *  readonly version: string
- *  readonly dependencies?: dependencies.DependenciesJson
- * }} PackageJson
- */
-
-/** @type {(j: json.Unknown) => j is PackageJson} */
-export const isPackageJson = j => {
-    if (!isObject(j)) { return false }
-    if (typeof j.name !== 'string') { return false }
-    if (typeof j.version !== 'string') { return false }
-    if (!isDependenciesJson(at('dependencies')(j))) { return false }
-    return true
-}
-
-/**
- * @typedef {{
- *  readonly dependency: (localPackageId: string) => string | null
- *  readonly file: (localFileId: string) => string | null
- * }} Package
- */
-
-/**
- * @note Current package has an empty string '' as a packageId.
- * @typedef {(packageId: string) => Package | null} Get
- */

package/dev/index.mjs

@@ -1,3 +0,0 @@
-import { index } from "./module.mjs"
-
-index()

package/dev/test.mjs

@@ -1,60 +0,0 @@
-import { loadModuleMap, exit, env } from './module.mjs'
-import test from './test/module.f.mjs'
-
-/** @type {(f: (s: string) => void) => (s: string) => <T>(_: T) => T} */
-const anyLog = f => s => state => {
-    f(s)
-    return state
-}
-
-/**
- * @template T
- * @typedef {readonly['ok', T]} Ok
- */
-
-/**
- * @template E
- * @typedef {readonly['error', E]} Error
- */
-
-/**
- * @template T
- * @template E
- * @typedef {Ok<T>|Error<E>} Result
- */
-
-/** @type {<T>(f: () => T) => Result<T, unknown>} */
-const tryCatch = f => {
-    // `try catch` is not allowed in FunctionalScript.
-    try {
-        return ['ok', f()]
-    } catch (e) {
-        return ['error', e]
-    }
-}
-
-/** @type {<R>(f: () => R) => <T>(state: T) => readonly[R, number, T]} Measure} */
-const measure = f => state => {
-    const b = performance.now()
-    const r = f()
-    const e = performance.now()
-    return [r, e - b, state]
-}
-
-// test runner.
-const main = async() => {
-    const moduleMap = await loadModuleMap()
-
-    const r = test({
-        moduleMap,
-        log: anyLog(console.log),
-        error: anyLog(console.error),
-        measure,
-        tryCatch,
-        env,
-        state: void 0,
-    })
-    exit(r[0])
-}
-
-main()

package/fsm/module.f.mjs

@@ -1,99 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as list from '../types/list/module.f.mjs'
-const { equal, isEmpty, fold, toArray, scan, foldScan, empty: emptyList } = list
-import * as byteSet from '../types/byte_set/module.f.mjs'
-const { toRangeMap, union: byteSetUnion, one, empty } = byteSet
-import * as sortedSet from '../types/sorted_set/module.f.mjs'
-const { intersect, union: sortedSetUnion } = sortedSet
-import * as rangeMap from '../types/range_map/module.f.mjs'
-const { merge } = rangeMap
-import * as cmp from '../types/function/compare/module.f.mjs'
-const { unsafeCmp } = cmp
-import * as operator from '../types/function/operator/module.f.mjs'
-const { strictEqual } = operator
-import * as j from '../json/module.f.mjs'
-const { stringify } = j
-import * as f from '../types/function/module.f.mjs'
-const { identity } = f
-import * as utf16 from '../text/utf16/module.f.mjs'
-const { stringToList } = utf16
-
-/** @typedef {readonly[string, byteSet.ByteSet, string]} Rule */
-
-/** @typedef {list.List<Rule>} Grammar */
-
-/**
- * @typedef {{
- *  readonly[state in string]: rangeMap.RangeMapArray<string>
- * }} Dfa
- */
-
-const stringifyIdentity = stringify(identity)
-
-/** @type {(s: string) => byteSet.ByteSet} */
-export const toRange = s => {
-    const [b, e] = toArray(stringToList(s))
-    return byteSet.range([b, e])
-}
-
-/** @type {operator.Fold<number, byteSet.ByteSet>} */
-const toUnionOp = i => bs => byteSetUnion(bs)(one(i))
-
-/** @type {(s: string) => byteSet.ByteSet} */
-export const toUnion = s => {
-    const codePoints = stringToList(s)
-    return fold(toUnionOp)(empty)(codePoints)
-}
-
-/** @type {rangeMap.Operators<sortedSet.SortedSet<string>>} */
-const mergeOp = { union: sortedSetUnion(unsafeCmp), equal: equal(strictEqual) }
-
-/** @type {(s: string) => (set: sortedSet.SortedSet<string>) => boolean} */
-const hasState = s => set => !isEmpty(intersect(unsafeCmp)([s])(set))
-
-/** @type {(set: sortedSet.SortedSet<string>) => operator.Fold<Rule, rangeMap.RangeMap<sortedSet.SortedSet<string>>>} */
-const foldOp = set => ([ruleIn, bs, ruleOut]) => rm => {
-    if (hasState(ruleIn)(set)) { return merge(mergeOp)(rm)(toRangeMap(bs)(ruleOut)) }
-    return rm
-}
-
-/** @type {operator.Scan<rangeMap.Entry<sortedSet.SortedSet<string>>, rangeMap.Entry<string>>} */
-const stringifyOp = ([sortedSet, max]) => [[stringifyIdentity(sortedSet), max], stringifyOp]
-
-const scanStringify = scan(stringifyOp)
-
-/** @type {operator.Scan<rangeMap.Entry<sortedSet.SortedSet<string>>, sortedSet.SortedSet<string>>} */
-const fetchOp = ([item, _]) => [item, fetchOp]
-
-const scanFetch = scan(fetchOp)
-
-/** @type {(grammar: Grammar) => operator.Fold<sortedSet.SortedSet<string>, Dfa>} */
-const addEntry = grammar => set => dfa => {
-    const s = stringifyIdentity(set)
-    if (s in dfa) { return dfa }
-    const setMap = fold(foldOp(set))(emptyList)(grammar)
-    const stringMap = toArray(scanStringify(setMap))
-    const newDfa = { ...dfa, [s]: stringMap }
-    const newStates = scanFetch(setMap)
-    return fold(addEntry(grammar))(newDfa)(newStates)
-}
-
-/** @type {string[]} */
-const emptyState = []
-
-const emptyStateStringify = stringifyIdentity(emptyState)
-
-const initialState = ['']
-
-const initialStateStringify = stringifyIdentity(initialState)
-
-/** @type {(grammar: Grammar) => Dfa} */
-export const dfa = grammar => addEntry(grammar)(initialState)({})
-
-const get = rangeMap.get(emptyStateStringify)
-
-/** @type {(dfa: Dfa) => operator.Fold<number, string>} */
-const runOp = dfa => input => s => get(input)(dfa[s])
-
-/** @type {(dfa: Dfa) => (input: list.List<number>) => list.List<string>} */
-export const run = dfa => input => foldScan(runOp(dfa))(initialStateStringify)(input)

package/html/module.f.mjs

@@ -1,102 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as list from '../types/list/module.f.mjs'
-const { map, flatMap, flat, concat: listConcat } = list
-import * as s from '../types/string/module.f.mjs'
-const { concat: stringConcat } = s
-import * as O from '../types/object/module.f.mjs'
-import * as f from '../types/function/module.f.mjs'
-const { compose } = f
-import * as utf16 from '../text/utf16/module.f.mjs'
-const { stringToList } = utf16
-const { fromCharCode } = String
-const { entries } = Object
-
-/** @typedef {string} Tag */
-
-// https://developer.mozilla.org/en-US/docs/Glossary/Void_element
-const voidTagList = /** @type {const} */([
-    'area',
-    'base',
-    'br',
-    'col',
-    'embed',
-    'hr',
-    'img',
-    'input',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr',
-])
-
-/** @typedef {typeof voidTagList} VoidTagList */
-
-/** @typedef {keyof voidTagList} VoidTag */
-
-/** @type {(tag: string) => boolean} */
-const isVoid = tag => voidTagList.includes(/** @type {any} */(tag))
-
-/** @typedef {readonly[Tag, ...Node[]]} Element1*/
-
-/** @typedef {readonly[Tag, Attributes, ...Node[]]} Element2 */
-
-/** @typedef {Element1 | Element2 } Element */
-
-/**
- * @typedef {{
- *  readonly[k in string]: string
- * }} Attributes
- */
-
-// /** @typedef {list.List<Node>} Nodes */
-
-/** @typedef {Element | string} Node */
-
-/**
- * https://stackoverflow.com/questions/7381974/which-characters-need-to-be-escaped-in-html
- *
- * @type {(code: number) => string}
- */
-const escapeCharCode = code => {
-    switch (code) {
-        case 0x22: return '&quot;'
-        case 0x26: return '&amp;'
-        case 0x3C: return '&lt;'
-        case 0x3E: return '&gt;'
-        default: return fromCharCode(code)
-    }
-}
-
-const escape = compose(stringToList)(map(escapeCharCode))
-
-/** @type {(n: Node) => list.List<string>} */
-const node = n => typeof n === 'string' ? escape(n) : element(n)
-
-const nodes = flatMap(node)
-
-/** @type {(a: O.Entry<string>) => list.List<string>} */
-const attribute = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']])
-
-/** @type {(a: Attributes) => list.List<string>} */
-const attributes = compose(entries)(flatMap(attribute))
-
-/** @type {(t: string) => (a: Attributes) => list.List<string>} */
-const open = t => a => flat([[`<`, t], attributes(a), [`>`]])
-
-/** @type {(t: string) => (an: readonly[Attributes, readonly Node[]]) => list.List<string>} */
-const element3 = t => ([a, n]) => {
-    const o = flat([[`<`, t], attributes(a), [`>`]])
-    return isVoid(t) ? o : flat([o, nodes(n), ['</', t, '>']])
-}
-
-/** @type {(element: Element) => list.List<string>} */
-export const element = e => {
-    const [t, a, ...n] = e
-    return element3(t)(a === undefined ? [{}, []]: typeof a === 'object' && !(a instanceof Array) ? [a, n] : [{}, [a, ...n]])
-}
-
-export const html = compose(element)(listConcat(['<!DOCTYPE html>']))
-
-export const htmlToString = compose(html)(stringConcat)