functionalscript 0.0.341 → 0.0.344

package/commonjs/README.md

@@ -1,8 +1,10 @@
 # Common.js
 
-```ts
-// package/index.js
+## Package
+
+[package/index.js](package/index.js)
 
+```ts
 // A dictionary of packages.
 //
 // A package contains a dictionary of dependencies and a dictionary of files.
@@ -25,9 +27,13 @@ type Package = {
     // returns source of the file.
     readonly file: (localFileId: string) => string | undefined
 }
+```
 
-// module/index.js
+## Module
 
+[module/index.js](module/index.js)
+
+```ts
 // A module map is a dictionary of modules.
 //
 // A module is a compiled and initialized source file.
@@ -62,9 +68,13 @@ type ModuleId = {
 }
 
 const moduleIdToString: (moduleId: ModuleId) => string;
+```
 
-// build/index.js
+## Build
 
+[build/index.js](build/index.js)
+
+```ts
 type BuildConfig<M> = {
     readonly packageGet: PackageGet
     readonly moduleMapInterface: ModuleMapInterface<M>
@@ -81,8 +91,4 @@ type BuildState<M> = {
 }
 
 const getOrBuild: <M>(buildConfig: BuildConfig<M>) => readonly[ModuleState, M];
-
-//
-
-
 ```

package/commonjs/build/index.js

@@ -36,7 +36,13 @@ const notFound = moduleMap => [['error', ['file not found']], moduleMap]
 const getOrBuild = compile => packageGet => moduleMapInterface =>  {
     /** @typedef {typeof moduleMapInterface extends module_.MapInterface<infer M> ? M : never} M */
 
-    /** @type {(buildSet: stringSet.StringSet) => (moduleId: module_.Id) => (source: string) => (moduleMap: M) => Result<M>} */
+    /**
+     * @type {(buildSet: stringSet.StringSet) =>
+     *  (moduleId: module_.Id) =>
+     *  (source: string) =>
+     *  (moduleMap: M) =>
+     *  Result<M>}
+     */
     const build = buildSet => moduleId => {
         const moduleIdStr = module_.idToString(moduleId)
         const buildSet1 = stringSet.set(moduleIdStr)(buildSet)

package/commonjs/package/index.js

@@ -25,7 +25,10 @@ const isPackageJson = j => {
  * }} Package
  */
 
-/** @typedef {(packageId: string) => Package | undefined} Get */
+/**
+ * @note Current package has an empty string '' as a packageId.
+ * @typedef {(packageId: string) => Package | undefined} Get
+ */
 
 module.exports = {
     /** @readonly */

package/html/index.js

@@ -0,0 +1,121 @@
+const list = require('../types/list/index.js')
+const object = require('../types/object/index.js')
+const operator = require('../types/function/operator/index.js')
+const { compose } = require('../types/function/index.js')
+
+/**
+ * @typedef {|
+ *  'a' |
+ *  'b' |
+ *  'body' |
+ *  'canvas' |
+ *  'div' |
+ *  'h1' |
+ *  'h2' |
+ *  'h3' |
+ *  'h4' |
+ *  'h5' |
+ *  'h6' |
+ *  'head' |
+ *  'html' |
+ *  'label' |
+ *  'p' |
+ *  'pre' |
+ *  'script' |
+ *  'table' |
+ *  'td' |
+ *  'th' |
+ *  'title' |
+ *  'tr'
+ * } Tag
+ */
+
+/**
+ * @typedef {|
+ *  'img' |
+ *  'input' |
+ *  'link' |
+ *  'meta'
+ * } ShortTag
+ */
+
+/** @typedef {readonly[ShortTag]} ShortElement1*/
+
+/** @typedef {readonly[ShortTag, Attributes]} ShortElement2 */
+
+/** @typedef {readonly[Tag, readonly Node[]]} Element2 */
+
+/** @typedef {readonly[Tag, Attributes, Nodes]} Element3*/
+
+/** @typedef {ShortElement1 | ShortElement2 | Element2 | Element3} 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 String.fromCharCode(code)
+    }
+}
+
+const escape = compose(list.toCharCodes)(list.map(escapeCharCode))
+
+/** @type {(n: Node) => list.List<string>} */
+const node = n => typeof n === 'string' ? escape(n) : element(n)
+
+const nodes = list.flatMap(node)
+
+/** @type {(a: object.Entry<string>) => list.List<string>} */
+const attribute = ([name, value]) => list.flat([[' ', name, '="'], escape(value), ['"']])
+
+/** @type {(a: Attributes) => list.List<string>} */
+const attributes = compose(Object.entries)(list.flatMap(attribute))
+
+/** @type {(element: Element) => list.List<string>} */
+const element = e => {
+    const f = () => {
+        switch (e.length) {
+            case 1: { return [[`<`, e[0], '/>']] }
+            case 2: {
+                const [tag, a] = e
+                return a instanceof Array ?
+                    [['<', tag, '>'], nodes(a), ['</', tag, '>']] :
+                    [[`<`, tag], attributes(a), [`/>`]]
+            }
+            default: {
+                const [tag, a, ns] = e
+                return [['<', tag], attributes(a), ['>'], nodes(ns), ['</', tag, '>']]
+            }
+        }
+    }
+    return list.flat(f())
+}
+
+const html = compose(element)(list.concat(['<!DOCTYPE html>']))
+
+const htmlToString = compose(html)(list.fold(operator.concat)(''))
+
+module.exports = {
+    /** @readonly */
+    element,
+    /** @readonly */
+    html,
+    /** @readonly */
+    htmlToString,
+}

package/html/test.js

@@ -0,0 +1,13 @@
+const _ = require('./index.js')
+
+{
+    const r = _.htmlToString(['html', []])
+    if (r !== '<!DOCTYPE html><html></html>') { throw r }
+}
+
+{
+    /** @type {_.Element} */
+    const x = ['div', {}, ['<div>&amp;</div>', ['a', { href: 'hello"' }, []]]]
+    const s = _.htmlToString(x)
+    if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') { throw s }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.341",
+  "version": "0.0.344",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^17.0.35",
-    "typescript": "^4.7.2"
+    "@types/node": "^17.0.42",
+    "typescript": "^4.7.3"
   }
 }

package/test.js

@@ -1,4 +1,4 @@
-const i = require('./index.js')
+// const i = require('./index.js')
 
 require('./types/list/test.js')
 require('./types/array/test.js')
@@ -15,6 +15,7 @@ require('./types/function/compare/test.js')
 require('./types/stringSet/test.js')
 require('./commonjs/build/test.js')
 require('./types/range/test.js')
+require('./html/test.js')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }
@@ -22,53 +23,6 @@ const assert = () => { throw 'assert' }
 /** @type {(_: boolean) => void} */
 const assert_if = c => { if (c) { throw 'assert_if' } }
 
-{
-    i.parseModuleUrl('')(
-        assert,
-        e => assert_if(e.id !== 'expected' || e.params[0] !== ':'))
-}
-
-{
-    i.parseModuleUrl(':')(
-        assert,
-        e => assert_if(e.id !== 'unknownProtocol'))
-}
-
-{
-    i.parseModuleUrl('github:r')(
-        assert,
-        e => assert_if(e.id !== 'expected'))
-}
-
-{
-    i.parseModuleUrl('github:functionalscript/node-example')(
-        v => assert_if(
-            v.repo.org !== 'functionalscript' ||
-            v.repo.name !== 'node-example' ||
-            'branch' in v),
-        assert)
-}
-
-{
-    i.parseModuleUrl('github:functionalscript/node-example#main')(
-        v => assert_if(
-            v.repo.org !== 'functionalscript' ||
-            v.repo.name !== 'node-example' ||
-            !('branch' in v) ||
-            v.branch !== 'main'),
-        assert)
-}
-
-{
-    i.parseModuleUrl('github:functionalscript/node-example#4b14a7a2b11cf53f037931eb7bef240f96dcea64')(
-        v => assert_if(
-            v.repo.org !== 'functionalscript' ||
-            v.repo.name !== 'node-example' ||
-            !('commit' in v) ||
-            v.commit !== '4b14a7a2b11cf53f037931eb7bef240f96dcea64'),
-        assert)
-}
-
 {
     const c = (()=>{})['constructor']
     const f = c('return 5')

package/index.js

@@ -1,76 +0,0 @@
-/** @type {<F>(c: string, found: (before: string, after: string) => F, notFound: (c: string, source: string) => F) => (source: string) => F} */
-const splitOne = (c, found, notFound) => source => {
-    const i = source.indexOf(c)
-    return i !== -1 ? found(source.substring(0, i), source.substring(i + 1)) : notFound(c, source)
-}
-
-/** @type {<T>(f: (_: T) => boolean) => (_: Iterable<T>) => boolean} */
-const every = f => i => {
-    for (let e of i) {
-        if (!f(e)) {
-            return false
-        }
-    }
-    return true
-}
-
-/** @typedef {{org: string, name: string}} RepoId */
-/** @typedef {{repo: RepoId}} ModuleRepoId */
-/** @typedef {{repo: RepoId, branch: string}} ModuleRepoBranchId */
-/** @typedef {{repo: RepoId, commit: string}} ModuleRepoCommitId */
-/** @typedef {ModuleRepoId|ModuleRepoBranchId|ModuleRepoCommitId} ModuleId */
-
-/** @typedef {(..._: string[]) => string} GetMsg */
-/** @typedef {'expected'|'unknownProtocol'} ErrorId */
-/** @typedef {{[_ in ErrorId]: GetMsg}} ErrorMap */
-/** @typedef {{ id: ErrorId, params: string[]}} ErrorValue */
-
-/**
- * @template T
- * @typedef {<R>(v: (_: T) => R, e: (_: ErrorValue) => R) => R} Result 
- */
-
-/** @type {<T>(_: T) => Result<T>} */
-const value = v => vf => vf(v)
-
-/**
- * @typedef {<R, T>(_: (_: T) => R, e: (_: ErrorValue) => R) => R} ErrorResult
- */
-
-/** @type {(e: ErrorValue) => ErrorResult} */
-const error = e => (_, ef) => ef(e)
-
-/** @type {(id: ErrorId) => (...params: string[]) => ErrorResult} */
-const createError = id => (...params) => error({ id, params })
-
-/** @type {(_: string) => Result<ModuleId>} */
-const parseRepo = repo => {
-    const s = repo.split('/')
-    return s.length === 2 ? value({ repo: { org: s[0], name: s[1] } }) : createError('expected')('/', repo)
-}
-
-/** @type {(_: string) => boolean} */
-const isCommit = name => name.length === 40 && every(c => "0123456789ABCDEFabcdef".includes(c))(name)
-
-/** @type {(repo: string, branch: string) => Result<ModuleId>} */
-const parseRepoAndBranchCommit = (repo, branchCommit) => 
-    parseRepo(repo)(
-        ({repo}) => value(isCommit(branchCommit) ? { repo, commit: branchCommit } : { repo, branch: branchCommit }), 
-        error)
-
-const parseGitHubId = splitOne('#', parseRepoAndBranchCommit, (_, repo) => parseRepo(repo))
-
-/** @type {(protocol: string, id: string) => Result<ModuleId>} */
-const parseProtocolAndId = (protocol, id) => protocol === 'github'
-    ? parseGitHubId(id) : createError('unknownProtocol')(protocol)
-
-module.exports = {
-    every,
-    isCommit,
-    parseModuleUrl: splitOne(':', parseProtocolAndId, createError('expected')),
-    /** @type {ErrorMap} */
-    errorMap: {
-        expected: (c, s) => `expected '${c}' in '${s}'`,
-        unknownProtocol: protocol => `unknown protocol '${protocol}'`,
-    },
-}