fez-lisp 1.6.43 → 1.6.45

package/README.md

@@ -11,6 +11,16 @@
 (|> (math:range 1 100) (array:map fezz-buzz) (from:array->string char:space) (string))
 ```
 
+```bash
+npm i fez-lisp
+```
+
+Run node in terminal
+
+```node
+require('fez-lisp').UTILS.init()
+```
+
 ## [Try it in online editor](https://at-290690.github.io/fez/)
 
 ```lisp

package/package.json

@@ -2,7 +2,7 @@
   "name": "fez-lisp",
   "description": "Lisp interpreted & compiled to JavaScript",
   "author": "AT290690",
-  "version": "1.6.43",
+  "version": "1.6.45",
   "type": "module",
   "main": "index.js",
   "keywords": [

package/src/utils.js

@@ -30,6 +30,14 @@ import { debugStackToString, startDebug, debug } from './debugger.js'
 export const logError = (error) =>
   console.log('\x1b[31m', `\n${error}\n`, '\x1b[0m')
 export const logSuccess = (output) => console.log('\x1b[32m', output, '\x1b[0m')
+export const logType = (type) => {
+  console.log('\n\x1b[34m')
+  console.log(type, '\n\x1b[0m')
+}
+export const logResult = (result) => {
+  console.log('\x1b[34m')
+  console.log(result, '\n\x1b[0m')
+}
 export const wrapInBracesString = (exp) => `(${stringifyArgs(exp)})`
 export const logExp = function (exp, ...args) {
   console.log(wrapInBracesString(exp), ...args)
@@ -365,12 +373,76 @@ export const isInputVariable = (x) =>
   x[1][TYPE] === WORD &&
   x[1][VALUE] === 'INPUT'
 
+export const init = () => {
+  import('fs').then(({ writeFileSync }) => {
+    console.log('\x1b[32m')
+    writeFileSync('main.lisp', '')
+    console.log('Added main.lisp')
+    writeFileSync('types.lisp', '')
+    console.log('Added types.lisp')
+    writeFileSync(
+      'index.js',
+      `import { compile, enhance, parse, LISP, UTILS } from 'fez-lisp'
+      import { readFileSync, writeFileSync } from 'fs'
+      export const dev = (source, types) => {
+        try {
+          const parsed = parse(source)
+          const { evaluated, type, error } = UTILS.debug(
+            parsed,
+            true,
+            types ? types : undefined
+          )
+          if (error == null) {
+            if (type) {
+              UTILS.logType(type)
+            }
+            UTILS.logResult(LISP.serialise(evaluated))
+          } else UTILS.logError(error.message)
+        } catch (error) {
+          UTILS.logError(error.message)
+        }
+      }
+      export const comp = (source) => compile(enhance(parse(source)))
+      const file = readFileSync('./main.lisp', 'utf-8')
+      switch (process.argv[2]) {
+        case 'comp':
+          writeFileSync('./main.js', 'var _ = ' + comp(file) + '\nconsole.log(_)')
+          break
+        case 'dev':
+        default:
+          dev(file, readFileSync('./types.lisp', 'utf-8'))
+          break
+      }
+`
+    )
+    console.log('Added index.js')
+    console.log(
+      `Done!
+
+Write code in main.lisp and types (if any) in types.lisp
+Run node index.js with the following flags:
+- dev (static type check and run time validations)
+- comp (compile Fez to JavaScript file main.js)
+
+If no flag is specified it defaults to dev
+
+That's it! You are all set!
+`,
+      '\x1b[0m'
+    )
+    process.exit()
+  })
+}
+
 export const UTILS = {
+  init,
   debug,
   startDebug,
   debugStackToString,
   handleUnbalancedQuotes,
   handleUnbalancedParens,
+  logType,
+  logResult,
   logError,
   logSuccess,
   formatErrorWithCallstack,