functionalscript 0.2.5 → 0.3.0

package/.github/workflows/ci.yml

@@ -10,14 +10,29 @@ on:
   pull_request:
 
 jobs:
-  node:
+  node20:
     runs-on: ubuntu-latest
 
     strategy:
       matrix:
-        node-version: [16, 18, 20, 22, 23]
+        node-version: [16, 18, 20]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-node@v2
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm ci
+    - run: npm run test20
+
+  node:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [22, 23]
+
     steps:
     - uses: actions/checkout@v2
     - uses: actions/setup-node@v2
@@ -41,7 +56,7 @@ jobs:
     - uses: denoland/setup-deno@v1
       with:
         deno-version: ${{ matrix.deno-version }}
-    - run: deno run --quiet --allow-read --allow-env --allow-net ./dev/test.mjs
+    - run: deno task test
 
   bun:
 
@@ -50,7 +65,7 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - run: curl https://bun.sh/install | bash
-    - run: /home/runner/.bun/bin/bun ./dev/test.mjs
+    - run: /home/runner/.bun/bin/bun ./dev/test.ts
 
   COM:
     strategy:

package/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 0.3.0
+
+- Switching to TypeScript file [PR #330] https://github.com/functionalscript/functionalscript/pull/330
+- DJS: add serializer [PR #326] https://github.com/functionalscript/functionalscript/pull/326
+
+## 0.2.6
+
+- Refactoring of a vector of bits [PR #328](https://github.com/functionalscript/functionalscript/pull/328)
+
 ## 0.2.5
 
 - new [crypto/] directory [PR #327](https://github.com/functionalscript/functionalscript/pull/327).

package/com/cpp/{module.f.mjs → module.f.ts}

@@ -1,22 +1,21 @@
-// @ts-self-types="./module.f.d.mts"
-
 /**
  * This module generates C++ code blocks, including structs, interfaces, and method headers,
  * based on a COM library of type definitions.
  */
 
-import * as types from '../types/module.f.mjs'
-import * as text from '../../text/module.f.mjs'
-import * as O from '../../types/object/module.f.mjs'
-import * as list from '../../types/list/module.f.mjs'
-import * as string from '../../types/string/module.f.mjs'
+import * as types from '../types/module.f.ts'
+import * as text from '../../text/module.f.ts'
+import * as O from '../../types/object/module.f.ts'
+import * as list from '../../types/list/module.f.ts'
+import * as string from '../../types/string/module.f.ts'
 const { join } = string
 const { paramList } = types
 const { map, flatMap, flat } = list
 const { entries } = Object
 
-/** @type {(name: string) => (body: text.Block) => text.Block} */
-const struct = name => body => [`struct ${name}`, '{', body, '};']
+const struct
+= (name: string) => (body: text.Block): text.Block =>
+    [`struct ${name}`, '{', body, '};']
 
 const baseTypeMap = {
     u8: 'uint8_t',
@@ -34,24 +33,29 @@ const baseTypeMap = {
     bool: 'bool',
 }
 
-/** @type {(t: types.BaseType) => string} */
-const baseType = t => baseTypeMap[t]
+const baseType
+    : (t: types.BaseType) => string
+    = t => baseTypeMap[t]
 
 const resultVoid = types.result('void')
 
 const namespace = text.curly('namespace')
 
-/** @type {(id: string) => string} */
-const comRef = id => `::nanocom::ref<${id}>`
+const comRef
+    : (id: string) => string
+    = id => `::nanocom::ref<${id}>`
 
-/** @type {(id: string) => string} */
-const ptr = id => `${id} const*`
+const ptr
+    : (id: string) => string
+    = id => `${id} const*`
 
-/** @type {(id: string) => string} */
-const ref = id => `${id} const&`
+const ref
+    : (id: string) => string
+    = id => `${id} const&`
 
-/** @type {(p: types.Field) => string} */
-const paramName = ([name]) => name
+const paramName
+    : (p: types.Field) => string
+    = ([name]) => name
 
 const mapParamName = map(paramName)
 
@@ -59,12 +63,15 @@ const joinComma = join(', ')
 
 /**
  * Generates the C++ code for a library.
- * @type {(name: string) => (lib: types.Library) => text.Block}
  */
-export const cpp = name => lib => {
+export const cpp
+    : (name: string) => (lib: types.Library) => text.Block
+    = name => lib => {
+
+    const interface_
+        : (t: types.Type) => string|null
+        = t => {
 
-    /** @type {(t: types.Type) => string|null} */
-    const interface_ = t => {
         if (!(t instanceof Array) || t.length !== 1) {
             return null
         }
@@ -72,8 +79,10 @@ export const cpp = name => lib => {
         return 'interface' in lib[name] ? name : null
     }
 
-    /** @type {(i: (t: string) => string) => (t: types.Type) => string} */
-    const objectType = i => t => {
+    const objectType
+        : (i: (t: string) => string) => (t: types.Type) => string
+        = i => t => {
+
         if (typeof (t) === 'string') { return baseType(t) }
         if (t.length === 2) { return `${type(t[1])} const*` }
         const [id] = t
@@ -84,28 +93,35 @@ export const cpp = name => lib => {
 
     const resultType = objectType(ptr)
 
-    /** @type {(s: types.Field) => text.Item} */
-    const field = ([name, t]) => `${type(t)} ${name};`
+    const field
+        : (s: types.Field) => text.Item
+        = ([name, t]) => `${type(t)} ${name};`
 
     const mapField = map(field)
 
-    /** @type {(s: types.Struct) => text.Block} */
-    const defStruct = s => mapField(entries(s.struct))
+    const defStruct
+        : (s: types.Struct) => text.Block
+        = s => mapField(entries(s.struct))
 
-    /** @type {(fa: types.FieldArray) => string} */
-    const cppResult = resultVoid(resultType)
+    const cppResult
+        : (fa: types.FieldArray) => string
+        = resultVoid(resultType)
 
-    /** @type {(p: types.Field) => string} */
-    const param = ([name, t]) => `${objectType(ref)(t)} ${name}`
+    const param
+        : (p: types.Field) => string
+        = ([name, t]) => `${objectType(ref)(t)} ${name}`
 
     const mapParam = map(param)
 
-    /** @type {(result: string) => (paramArrayStr: string) => (name: string) => text.Item} */
-    const methodHeader = result => paramArrayStr => name =>
-        `virtual ${result} ${name}${paramArrayStr} const noexcept = 0;`
+    const methodHeader
+        : (result: string) => (paramArrayStr: string) => (name: string) => text.Item
+        = result => paramArrayStr => name =>
+            `virtual ${result} ${name}${paramArrayStr} const noexcept = 0;`
+
+    const method
+        : (m: types.Method) => readonly text.Item[]
+        = ([name, paramArray]) => {
 
-    /** @type {(m: types.Method) => readonly text.Item[]} */
-    const method = ([name, paramArray]) => {
         const result = cppResult(paramArray)
         const paramL = paramList(paramArray)
         const paramArrayStr = `(${joinComma(mapParam(paramL))})`
@@ -125,8 +141,10 @@ export const cpp = name => lib => {
 
     const mapMethod = flatMap(method)
 
-    /** @type {(i: types.Interface) => text.Block} */
-    const defInterface = ({ guid, interface: i }) => {
+    const defInterface
+        : (i: types.Interface) => text.Block
+        = ({ guid, interface: i }) => {
+
         const g = guid.replaceAll('-', '');
         const lo = g.substring(0, 16);
         const hi = g.substring(16);
@@ -136,8 +154,10 @@ export const cpp = name => lib => {
         ])
     }
 
-    /** @type {(kv: O.Entry<types.Definition>) => text.Block} */
-    const def = ([name, d]) => 'interface' in d
+    const def
+        : (kv: O.Entry<types.Definition>) => text.Block
+        = ([name, d]) => 'interface' in d
+
         ? [
             `class ${name} : public ::nanocom::IUnknown`,
             '{',
@@ -147,8 +167,9 @@ export const cpp = name => lib => {
         ]
         : struct(name)(defStruct(d))
 
-    /** @type {(kv: O.Entry<types.Definition>) => text.Block} */
-    const forward = ([name]) => [`struct ${name};`]
+    const forward
+        : (kv: O.Entry<types.Definition>) => text.Block
+        = ([name]) => [`struct ${name};`]
 
     const e = entries(lib)
 

package/com/cpp/{test.f.mjs → test.f.ts}

@@ -1,4 +1,4 @@
-import cpp from './testlib.f.mjs'
+import cpp from './testlib.f.ts'
 
 const f = () =>
 {

package/com/cpp/testlib.f.ts

@@ -0,0 +1,8 @@
+import * as string from '../../types/string/module.f.ts'
+const { join } = string
+import * as text from '../../text/module.f.ts'
+const { flat } = text
+import library from '../types/testlib.f.ts'
+import { cpp } from './module.f.ts'
+
+export default () => join('\n')(flat('    ')(cpp('My')(library)))

package/com/cs/{module.f.mjs → module.f.ts}

@@ -1,33 +1,31 @@
-// @ts-self-types="./module.f.d.mts"
-
 /**
  * This module generates C# code blocks for COM interop from a high-level type library definition.
  *
  * The module maps type definitions (e.g., structs, interfaces, and methods) into C# constructs
  * with appropriate attributes for COM interop, such as `[StructLayout]`, `[Guid]`, and `[InterfaceType]`.
  */
-import * as types from '../types/module.f.mjs'
+import * as types from '../types/module.f.ts'
 const { result, paramList } = types
-import * as text from '../../text/module.f.mjs'
+import * as text from '../../text/module.f.ts'
 const { curly } = text
-import * as list from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.ts'
 const { flat, map, some, flatMap } = list
-import * as string from '../../types/string/module.f.mjs'
+import * as string from '../../types/string/module.f.ts'
 const { join } = string
-import * as O from '../../types/object/module.f.mjs'
+import * as O from '../../types/object/module.f.ts'
 const { entries } = Object
 
-/** @type {(v: string) => string} */
-const using = v => `using ${v};`
-
-/**
- * @type {(attributes: list.List<string>) =>
- *  (type: string) =>
- *  (name: string) =>
- *  (body: text.Block) =>
- *  list.List<text.Item>}
- */
-const typeDef = attributes => type => name => body =>
+const using
+    : (v: string) => string
+    = v => `using ${v};`
+
+const typeDef
+    :   (attributes: list.List<string>) =>
+        (type: string) =>
+        (name: string) =>
+        (body: text.Block) =>
+        list.List<text.Item>
+    = attributes => type => name => body =>
     flat([
         map(v => `[${v}]`)(attributes),
         curly(`public ${type}`)(name)(body)
@@ -49,34 +47,41 @@ const baseTypeMap = {
     usize: 'UIntPtr',
 }
 
-/** @type {(t: types.BaseType) => string} */
-const baseType = t => baseTypeMap[t]
+const baseType
+    : (t: types.BaseType) => string
+    = t => baseTypeMap[t]
 
-/** @type {(isUnsafe: boolean) => string} */
-const unsafe = isUnsafe => isUnsafe ? 'unsafe ' : ''
+const unsafe
+    : (isUnsafe: boolean) => string
+    = isUnsafe => isUnsafe ? 'unsafe ' : ''
 
-/** @type {(t: types.Type) => readonly[boolean, string]} */
-const fullType = t =>
+const fullType
+    : (t: types.Type) => readonly[boolean, string]
+    = t =>
     typeof (t) === 'string' ? [false, baseType(t)] :
         t.length === 1 ? [false, t[0]] :
             [true, `${type(t[1])}*`]
 
-/** @type {(m: types.Type) => string} */
-const type = t => fullType(t)[1]
+const type
+    : (m: types.Type) => string
+    = t => fullType(t)[1]
 
-/** @type {(f: types.Field) => string} */
-const param = ([name, t]) => `${type(t)} ${name}`
+const param
+    : (f: types.Field) => string
+    = ([name, t]) => `${type(t)} ${name}`
 
 const mapParam = map(param)
 
-/** @type {(f: types.Field) => string} */
-const field = ([name, comType]) => {
+const field
+    : (f: types.Field) => string
+    = ([name, comType]) => {
     const [isUnsafe, t] = fullType(comType)
     return `public ${unsafe(isUnsafe)}${t} ${name};`
 }
 
-/** @type {(field: types.Field) => boolean} */
-const isUnsafeField = field => fullType(field[1])[0]
+const isUnsafeField
+    : (field: types.Field) => boolean
+    = field => fullType(field[1])[0]
 
 const mapIsUnsafeField = map(isUnsafeField)
 
@@ -84,8 +89,10 @@ const resultVoid = result('void')
 
 const joinComma = join(', ')
 
-/** @type {(e: O.Entry<types.FieldArray>) => readonly string[]} */
-const method = ([name, m]) => {
+const method
+    : (e: O.Entry<types.FieldArray>) => readonly string[]
+    = ([name, m]) => {
+
     const paramAndResultList = entries(m)
     const pl = paramList(m)
     const isUnsafe = some(mapIsUnsafeField(paramAndResultList))
@@ -103,8 +110,9 @@ const mapField = map(field)
 
 const flatMapMethod = flatMap(method)
 
-/** @type {(e: O.Entry<types.Definition>) => list.List<text.Item>} */
-const def = ([n, d]) => {
+const def
+    : (e: O.Entry<types.Definition>) => list.List<text.Item>
+    = ([n, d]) => {
     return !('interface' in d) ?
         struct(n)(mapField(entries(d.struct))) :
         typeDef
@@ -127,9 +135,10 @@ const header = [
 
 /**
  * Generates the C# code for a library.
- * @type {(name: string) => (library: types.Library) => text.Block}
  */
-export const cs = name => library => {
+export const cs
+    : (name: string) => (library: types.Library) => text.Block
+    = name => library => {
     const v = flatMapDef(entries(library))
     const ns = namespace(name)(v)
     return flat([header, ns])

package/com/cs/{test.f.mjs → test.f.ts}

@@ -1,4 +1,4 @@
-import cs from './testlib.f.mjs'
+import cs from './testlib.f.ts'
 
 const f = () =>
 {
@@ -42,4 +42,4 @@ const f = () =>
     if (cs !== e) { throw cs }
 }
 
-export default f
+export default f

package/com/cs/testlib.f.ts

@@ -0,0 +1,8 @@
+import * as text from '../../text/module.f.ts'
+const { flat } = text
+import * as string from '../../types/string/module.f.ts'
+const { join } = string
+import { cs } from './module.f.ts'
+import library from '../types/testlib.f.ts'
+
+export default join('\n')(flat('    ')(cs('My')(library)))