functionalscript 0.1.607 → 0.1.609

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Unreleased
+
+## 0.1.608

package/Cargo.lock

@@ -6,6 +6,10 @@ version = 3
 name = "nanocom"
 version = "0.2.1"
 
+[[package]]
+name = "nanvm-lib"
+version = "0.1.0"
+
 [[package]]
 name = "testrust"
 version = "0.1.0"

package/Cargo.toml

@@ -1,5 +1,7 @@
 [workspace]
+resolver = "2"
 members = [
     "com/rust/nanocom",
-    "com/test/rust"
-]
+    "com/test/rust",
+    "nanvm-lib"
+]

package/README.md

@@ -3,7 +3,7 @@
 [![NPM Version](https://img.shields.io/npm/v/functionalscript)](https://www.npmjs.com/package/functionalscript)
 [![JSR Version](https://img.shields.io/jsr/v/%40functionalscript/functionalscript)](https://jsr.io/@functionalscript/functionalscript)
 
-FunctionalScript is a purely functional programming language and a strict subset of
+FunctionalScript is a safe, purely functional programming language and a strict subset of
 [ECMAScript](https://en.wikipedia.org/wiki/ECMAScript)/[JavaScript](https://en.wikipedia.org/wiki/JavaScript). It's inspired by
 
 - [JSON](https://en.wikipedia.org/wiki/JSON) and [JSON5](https://json5.org/) as subsets of JavaScript.

package/com/rust/nanocom/src/cobject.rs

@@ -54,7 +54,7 @@ impl<T: Class> CObject<T> {
         match t.counter.fetch_sub(1, Ordering::Relaxed) {
             1 => {
                 let m = t as *const CObject<T> as *mut CObject<T>;
-                unsafe { Box::from_raw(m) };
+                let _ = unsafe { Box::from_raw(m) };
                 0
             }
             x => x - 1,

package/com/test/rust/src/lib.rs

@@ -28,19 +28,19 @@ impl _result::IMy::Ex for nanocom::CObject<My> {
         todo!()
     }
 
-    fn SetUnsafe(&self, p: *const _result::Slice, size: u32) {
+    fn SetUnsafe(&self, _p: *const _result::Slice, _size: u32) {
         todo!()
     }
 
-    fn Some(&self, p: &_result::IMy::Object) -> bool {
+    fn Some(&self, _p: &_result::IMy::Object) -> bool {
         todo!()
     }
 
-    fn GetIMy(&self, a: u16, b: i16) -> _result::IMy::Ref {
+    fn GetIMy(&self, _a: u16, _b: i16) -> _result::IMy::Ref {
         todo!()
     }
 
-    fn SetManagedStruct(&self, a: _result::ManagedStruct) {
+    fn SetManagedStruct(&self, _a: _result::ManagedStruct) {
         todo!()
     }
 }

package/dev/module.mjs

@@ -86,7 +86,7 @@ export const loadModuleMap = async () => {
                     const file = `${p}/${name}`
                     if (i.isDirectory()) {
                         await f(file)
-                    } else if (name.endsWith('.f.cjs') || name.endsWith('.f.mjs') || name.endsWith('.f.js')) {
+                    } else if (name.endsWith('.f.mjs') || name.endsWith('.f.js')) {
                         const source = await import(`../${file}`)
                         map.push([file, source.default])
                     }
@@ -179,36 +179,13 @@ const codeAdd = i => p => m => {
 }
 
 export const index = async () => {
-    {
-        const jj = './jsr.json'
-        const n = '/module.f.mjs'
-        const jsr_json = JSON.parse(await readFile(jj, { encoding: 'utf8' }))
-        const exportsA = Object.keys(await loadModuleMap())
-            .filter(v => v.endsWith(n))
-            .map(v => [v.replace(n, ''), v])
-        const exports = Object.fromEntries(exportsA)
-        await writeFile(
-            jj,
-            JSON.stringify({ ...jsr_json, exports }, null, 2))
-    }
-
-    //
-    /** @type {FolderMap} */
-    let m = {}
-    for (const k in await loadModuleMap()) {
-        const [, ...s] = k.split('/')
-        switch (s[s.length - 1]) {
-            case 'module.f.cjs': case 'module.f.mjs': case 'module.f.js':
-                m = folderMapAdd(m)(s)
-                break
-        }
-    }
-    const [e, i] = codeAdd(indent)('')(m)
-    let s =
-        '// Generated file.\n' +
-        i +
-        'export default {\n' +
-        e +
-        '}\n'
-    await writeFile('index.f.mjs', s)
+    const jj = './jsr.json'
+    const n = '/module.f.mjs'
+    const jsr_json = JSON.parse(await readFile(jj, { encoding: 'utf8' }))
+    const list = Object.keys(await loadModuleMap()).filter(v => v.endsWith(n))
+    const exportsA = list.map(v => [v.replace(n, ''), v])
+    const exports = Object.fromEntries(exportsA)
+    await writeFile(
+        jj,
+        JSON.stringify({ ...jsr_json, exports }, null, 2))
 }

package/dev/test/module.f.mjs

@@ -47,7 +47,7 @@ import * as Result from '../../types/result/module.f.mjs'
  */
 
 /** @type {(s: string) => boolean} */
-const isTest = s => s.endsWith('test.f.cjs') || s.endsWith('test.f.mjs') || s.endsWith('test.f.js')
+const isTest = s => s.endsWith('test.f.mjs') || s.endsWith('test.f.js')
 
 /**
  * @typedef {{

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

@@ -2,39 +2,59 @@ declare namespace _default {
     export { parse };
 }
 export default _default;
-export type JsonObject = {
-    readonly kind: "object";
-    readonly values: Map.Map<Djs.Unknown>;
-    readonly key: string;
-};
-export type JsonArray = {
-    readonly kind: "array";
-    readonly values: List.List<Djs.Unknown>;
-};
-export type JsonStackElement = JsonObject | JsonArray;
-export type JsonStack = List.List<JsonStackElement>;
-export type StateModule = {
-    readonly status: "module";
-    readonly stage: "module" | "." | "exports" | "=";
-};
-export type StateParse = {
-    readonly status: "" | "[" | "[v" | "[," | "{" | "{k" | "{:" | "{v" | "{,";
-    readonly top: JsonStackElement | null;
-    readonly stack: JsonStack;
-};
-export type StateResult = {
-    readonly status: "result";
-    readonly value: Djs.Unknown;
-};
-export type StateError = {
-    readonly status: "error";
+export type DjsModule = [readonly string[], readonly DjsConst[]];
+export type DjsConst = boolean | string | number | null | bigint | DjsModuleRef | DjsArray | DjsObject;
+export type DjsModuleRef = ["aref" | "cref", number];
+export type DjsArray = ["array", readonly DjsConst[]];
+export type DjsObject = { readonly [k in string]: DjsConst; };
+export type DjsStackArray = ["array", List.List<DjsConst>];
+export type DjsStackObject = ["object", Map.Map<DjsConst>, string];
+export type DjsStackElement = DjsStackArray | DjsStackObject;
+export type DjsStack = List.List<DjsStackElement>;
+export type ParserState = InitialState | NewLineRequiredState | ImportState | ConstState | ExportState | ParseValueState | ResultState | ErrorState;
+export type ModuleState = {
+    readonly refs: Map.Map<DjsModuleRef>;
+    readonly modules: List.List<string>;
+    readonly consts: List.List<DjsConst>;
+};
+export type InitialState = {
+    readonly state: "";
+    readonly module: ModuleState;
+};
+export type NewLineRequiredState = {
+    readonly state: "nl";
+    readonly module: ModuleState;
+};
+export type ImportState = {
+    readonly state: "import" | "import+name" | "import+from";
+    readonly module: ModuleState;
+};
+export type ConstState = {
+    readonly state: "const" | "const+name";
+    readonly module: ModuleState;
+};
+export type ExportState = {
+    readonly state: "export";
+    readonly module: ModuleState;
+};
+export type ParseValueState = {
+    readonly state: "constValue" | "exportValue";
+    readonly module: ModuleState;
+    readonly valueState: "" | "[" | "[v" | "[," | "{" | "{k" | "{:" | "{v" | "{,";
+    readonly top: DjsStackElement | null;
+    readonly stack: DjsStack;
+};
+export type ResultState = {
+    readonly state: "result";
+    readonly module: ModuleState;
+};
+export type ErrorState = {
+    readonly state: "error";
     readonly message: string;
 };
-export type DjsState = StateModule | StateParse | StateResult | StateError;
-/** @type {(tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<Djs.Unknown, string>} */
-declare const parse: (tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<Djs.Unknown, string>;
-import * as Map from '../../types/map/module.f.mjs';
-import * as Djs from '../module.f.mjs';
+/** @type {(tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<DjsModule, string>} */
+declare const parse: (tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<DjsModule, string>;
 import * as List from '../../types/list/module.f.mjs';
+import * as Map from '../../types/map/module.f.mjs';
 import * as tokenizerT from '../tokenizer/module.f.mjs';
 import * as Result from '../../types/result/module.f.mjs';