Add prettier

Author: i582

.prettierignore

@@ -0,0 +1 @@
+src/tolkfiftlib.js

README.md

@@ -3,14 +3,13 @@
 **Tolk** is a next-generation language for smart contracts in TON.
 It replaces FunC with modern syntax, strong types, and built-in serialization — while generating even more efficient assembler code.
 
-**tolk-js** is a WASM wrapper for Tolk compiler. 
-[Blueprint](https://github.com/ton-org/blueprint) uses tolk-js to compile `.tolk` files, 
+**tolk-js** is a WASM wrapper for Tolk compiler.
+[Blueprint](https://github.com/ton-org/blueprint) uses tolk-js to compile `.tolk` files,
 so if you develop contracts with blueprint, you don't have to install tolk-js directly.
 However, you can use tolk-js without blueprint, it has a simple and straightforward API.
 
 tolk-js works both in Node.js and browser (does not depend on filesystem).
 
-
 ## Installation
 
 ```
@@ -19,10 +18,9 @@ yarn add @ton/tolk-js
 npm install @ton/tolk-js
 ```
 
-
 ## CLI mode
 
-Its purpose is to launch a Tolk compiler from command-line, without compiling ton repo from sources, 
+Its purpose is to launch a Tolk compiler from command-line, without compiling ton repo from sources,
 without installing apt/homebrew packages, etc. Just run
 
 ```
@@ -33,26 +31,25 @@ Output JSON will contain `fiftCode`, `codeBoc64`, `codeHashHex`, and other field
 
 There are some flags like `--cwd`, `--output-fift`, and others (run `npx @ton/tolk-js --help`).
 
-
 ## Usage example
 
 ```js
-import {runTolkCompiler, getTolkCompilerVersion} from "@ton/tolk-js"
+import {runTolkCompiler, getTolkCompilerVersion} from '@ton/tolk-js'
 
 async function compileMainTolk() {
   // for example, file `main.tolk` is saved nearby
   // fsReadCallback (below) is called for both main.tolk and all its imports
   let result = await runTolkCompiler({
     entrypointFileName: 'main.tolk',
-    fsReadCallback: path => fs.readFileSync(__dirname + '/' + path, 'utf-8')
+    fsReadCallback: path => fs.readFileSync(__dirname + '/' + path, 'utf-8'),
   })
   if (result.status === 'error') {
     throw result.message
   }
 
   console.log(result.fiftCode)
   // using result.codeBoc64, you can construct a cell
-  let codeCell = Cell.fromBoc(Buffer.from(result.codeBoc64, "base64"))[0]
+  let codeCell = Cell.fromBoc(Buffer.from(result.codeBoc64, 'base64'))[0]
   // result has several (probably useful) fields, look up TolkResultSuccess
 }
 
@@ -62,8 +59,9 @@ async function showTolkVersion() {
 }
 ```
 
-The only point to pay attention to is `fsReadCallback`. It's called for every `.tolk` file, input or imported, and you should synchronously return file contents. 
+The only point to pay attention to is `fsReadCallback`. It's called for every `.tolk` file, input or imported, and you should synchronously return file contents.
 tolk-js does not access filesystem itself, it just provides a flexible callback, so you can make it easily work if you have file contents in memory, for example:
+
 ```js
 let sources = {
   'main.tolk': 'import "utils/math.tolk"',
@@ -77,18 +75,18 @@ runTolkCompiler({
 ```
 
 The function `runTolkCompiler()` accepts the following properties (look up `TolkCompilerConfig`):
-* `entrypointFileName` — obvious
-* `fsReadCallback` — explained above
-* `optimizationLevel` (default 2) — controls Tolk compiler stack optimizer
-* `withStackComments` (default false) — Fift output will contain stack comments, if you wish to debug its output
-* `withSrcLineComments` (default false) — Fift output will contain line comments from original .tolk files
-* `experimentalOptions` (default '') — you can pass experimental compiler options here
 
+- `entrypointFileName` — obvious
+- `fsReadCallback` — explained above
+- `optimizationLevel` (default 2) — controls Tolk compiler stack optimizer
+- `withStackComments` (default false) — Fift output will contain stack comments, if you wish to debug its output
+- `withSrcLineComments` (default false) — Fift output will contain line comments from original .tolk files
+- `experimentalOptions` (default '') — you can pass experimental compiler options here
 
 ## Embedded stdlib functions
 
-Tolk standard functions (`beginCell`, `assertEnd`, and lots of others) are available out of the box *(if you worked with FunC earlier, you had to download stdlib.fc and store in your project; in Tolk, you don't need any additional files)*.
+Tolk standard functions (`beginCell`, `assertEnd`, and lots of others) are available out of the box _(if you worked with FunC earlier, you had to download stdlib.fc and store in your project; in Tolk, you don't need any additional files)_.
 
 It works, because all stdlib files are embedded into JS, placed near wasm. If you `import "@stdlib/tvm-dicts"` for example, tolk-js will handle it, `fsReadCallback` won't be called.
 
-Note, that folder `tolk-stdlib/` and files within it exist only for IDE purposes. For example, if you use blueprint or tolk-js directly, JetBrains and VS Code plugins locate this folder and auto-complete stdlib functions. 
+Note, that folder `tolk-stdlib/` and files within it exist only for IDE purposes. For example, if you use blueprint or tolk-js directly, JetBrains and VS Code plugins locate this folder and auto-complete stdlib functions.

jest.config.js

@@ -1,7 +1,7 @@
 /** @type {import('ts-jest').JestConfigWithTsJest} **/
 module.exports = {
-  testEnvironment: "node",
+  testEnvironment: 'node',
   transform: {
-    "^.+.tsx?$": ["ts-jest",{}],
+    '^.+.tsx?$': ['ts-jest', {}],
   },
-};
+}

package.json

@@ -13,7 +13,9 @@
     "stdlib:pack": "node scripts/pack-stdlib-to-object.js",
     "wasm:dist": "cp src/tolkfiftlib.js dist && cp src/tolkfiftlib.wasm.js dist",
     "stdlib:dist": "cp -r src/tolk-stdlib dist && cp src/stdlib.tolk.js dist",
-    "test": "yarn wasm:pack && yarn stdlib:pack && yarn jest"
+    "test": "yarn wasm:pack && yarn stdlib:pack && yarn jest",
+    "fmt": "prettier --write -l --cache .",
+    "fmt:check": "prettier --check --cache ."
   },
   "author": "TON Blockchain",
   "license": "MIT",
@@ -27,9 +29,31 @@
     "@types/jest": "^29.5.12",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.4",
-    "typescript": "^5.5.4"
+    "typescript": "^5.5.4",
+    "prettier": "^3.6.2"
   },
   "dependencies": {
     "arg": "^5.0.2"
+  },
+  "prettier": {
+    "arrowParens": "avoid",
+    "bracketSpacing": false,
+    "printWidth": 100,
+    "semi": false,
+    "tabWidth": 2,
+    "trailingComma": "all",
+    "useTabs": false,
+    "singleQuote": true,
+    "overrides": [
+      {
+        "files": [
+          "*.yaml",
+          "*.yml"
+        ],
+        "options": {
+          "tabWidth": 2
+        }
+      }
+    ]
   }
 }

scripts/pack-stdlib-to-object.js

@@ -4,15 +4,18 @@ let out = `// stdlib files are stored as strings in order to make it work on web
 module.exports = {\n\n`
 
 let fileNames = [
-  ...fs.readdirSync('./src/tolk-stdlib').filter(s => s.endsWith('.tolk')).sort(),
+  ...fs
+    .readdirSync('./src/tolk-stdlib')
+    .filter(s => s.endsWith('.tolk'))
+    .sort(),
 ]
 
 for (let fileName of fileNames) {
   const contents = fs.readFileSync('./src/tolk-stdlib/' + fileName, 'utf-8')
   out += `'@stdlib/${fileName}':\`${contents.replace(/`/g, '\\`')}\`,\n\n`
 }
 
-out += "};\n"
+out += '};\n'
 fs.writeFileSync('./src/stdlib.tolk.js', out)
 
 // note, that Asm.fif and similar are embedded into wasm binary,

src/cli.ts

@@ -47,7 +47,7 @@ Options:
   }
 
   if (args._.length !== 1) {
-    throw 'entrypointFileName wasn\'t specified. Run with -h to see help.'
+    throw "entrypointFileName wasn't specified. Run with -h to see help."
   }
 
   console.log(`Compiling using Tolk v${version}`)
@@ -64,14 +64,21 @@ Options:
   }
 
   if (args['--output-json']) {
-    fs.writeFileSync(args['--output-json'], JSON.stringify({
-      artifactVersion: 1,
-      tolkVersion: version,
-      fiftCode: result.fiftCode,
-      codeBoc64: result.codeBoc64,
-      codeHashHex: result.codeHashHex,
-      sourcesSnapshot: result.sourcesSnapshot,
-    }, null, 2))
+    fs.writeFileSync(
+      args['--output-json'],
+      JSON.stringify(
+        {
+          artifactVersion: 1,
+          tolkVersion: version,
+          fiftCode: result.fiftCode,
+          codeBoc64: result.codeBoc64,
+          codeHashHex: result.codeHashHex,
+          sourcesSnapshot: result.sourcesSnapshot,
+        },
+        null,
+        2,
+      ),
+    )
   }
 
   if (args['--output-fift']) {

src/index.ts

@@ -1,10 +1,10 @@
 // @ts-ignore
-import wasmModule from "./tolkfiftlib.js"
+import wasmModule from './tolkfiftlib.js'
 // @ts-ignore
-import wasmBase64 from "./tolkfiftlib.wasm.js"
+import wasmBase64 from './tolkfiftlib.wasm.js'
 // @ts-ignore
-import stdlibContents from "./stdlib.tolk.js"
-import {realpath} from "./path-utils"
+import stdlibContents from './stdlib.tolk.js'
+import {realpath} from './path-utils'
 
 let wasmBinary: Uint8Array | undefined = undefined
 
@@ -22,16 +22,16 @@ export type TolkCompilerConfig = {
 }
 
 export type TolkResultSuccess = {
-  status: "ok"
+  status: 'ok'
   fiftCode: string
   codeBoc64: string
   codeHashHex: string
   stderr: string
-  sourcesSnapshot: { filename: string, contents: string }[]
+  sourcesSnapshot: {filename: string; contents: string}[]
 }
 
 export type TolkResultError = {
-  status: "error"
+  status: 'error'
   message: string
 }
 
@@ -54,10 +54,12 @@ function copyFromCString(mod: WasmModule, inPtr: any): string {
 
 async function instantiateWasmModule() {
   if (wasmBinary === undefined) {
-    if (typeof Buffer !== 'undefined') {  // node.js
+    if (typeof Buffer !== 'undefined') {
+      // node.js
       wasmBinary = new Uint8Array(Buffer.from(wasmBase64, 'base64'))
-    } else if (typeof window !== 'undefined') {  // browser
-      const binaryString = atob(wasmBase64)      // window.atob() is fast and safe for valid base64 strings
+    } else if (typeof window !== 'undefined') {
+      // browser
+      const binaryString = atob(wasmBase64) // window.atob() is fast and safe for valid base64 strings
       wasmBinary = new Uint8Array(binaryString.length)
       for (let i = 0; i < binaryString.length; i++) {
         wasmBinary[i] = binaryString.charCodeAt(i)
@@ -77,33 +79,41 @@ export async function getTolkCompilerVersion(): Promise<string> {
   return result.tolkVersion
 }
 
-export async function runTolkCompiler(compilerConfig: TolkCompilerConfig): Promise<TolkResultSuccess | TolkResultError> {
+export async function runTolkCompiler(
+  compilerConfig: TolkCompilerConfig,
+): Promise<TolkResultSuccess | TolkResultError> {
   const mod = await instantiateWasmModule()
   const allocatedPointers = []
   const sourcesSnapshot: TolkResultSuccess['sourcesSnapshot'] = []
 
   // see tolk-wasm.cpp: typedef void (*WasmFsReadCallback)(int, char const*, char**, char**)
-  const callbackPtr = mod.addFunction(function (kind: number, dataPtr: any, destContents: any, destError: any) {
-    switch (kind) { // enum ReadCallback::Kind in C++
-      case 0:       // realpath
-        let relativeFilename = copyFromCString(mod, dataPtr)  // from `import` statement, relative to cur file
+  const callbackPtr = mod.addFunction(function (
+    kind: number,
+    dataPtr: any,
+    destContents: any,
+    destError: any,
+  ) {
+    // enum ReadCallback::Kind in C++
+    switch (kind) {
+      case 0: // realpath
+        let relativeFilename = copyFromCString(mod, dataPtr) // from `import` statement, relative to cur file
         if (!relativeFilename.endsWith('.tolk')) {
           relativeFilename += '.tolk'
         }
         allocatedPointers.push(copyToCStringPtr(mod, realpath(relativeFilename), destContents))
         break
-      case 1:       // read file
+      case 1: // read file
         try {
           const filename = copyFromCString(mod, dataPtr) // already normalized (as returned above)
           if (filename.startsWith('@stdlib/')) {
             if (filename in stdlibContents) {
               allocatedPointers.push(copyToCStringPtr(mod, stdlibContents[filename], destContents))
             } else {
-              allocatedPointers.push(copyToCStringPtr(mod, filename + " not found", destError))
+              allocatedPointers.push(copyToCStringPtr(mod, filename + ' not found', destError))
             }
           } else {
             const contents = compilerConfig.fsReadCallback(filename)
-            sourcesSnapshot.push({ filename, contents })
+            sourcesSnapshot.push({filename, contents})
             allocatedPointers.push(copyToCStringPtr(mod, contents, destContents))
           }
         } catch (err: any) {
@@ -116,7 +126,8 @@ export async function runTolkCompiler(compilerConfig: TolkCompilerConfig): Promi
     }
   }, 'viiii')
 
-  const configStr = JSON.stringify({  // undefined fields won't be present, defaults will be used, see tolk-wasm.cpp
+  // undefined fields won't be present, defaults will be used, see tolk-wasm.cpp
+  const configStr = JSON.stringify({
     entrypointFileName: compilerConfig.entrypointFileName,
     optimizationLevel: compilerConfig.optimizationLevel,
     withStackComments: compilerConfig.withStackComments,

src/path-utils.ts

@@ -87,7 +87,8 @@ export function realpath(p: string): string {
   let isAbsolute = p.charCodeAt(0) === SLASH
   let path = posixNormalize(p, !isAbsolute)
 
-  if (isAbsolute) { // posixNormalize() drops leading slash
+  if (isAbsolute) {
+    // posixNormalize() drops leading slash
     return '/' + path
   }
   return path.length === 0 ? '.' : path

tests/codegen-checks.spec.ts

@@ -1,40 +1,38 @@
-import {runTolkCompiler, getTolkCompilerVersion, TolkResultSuccess, TolkResultError} from "../src";
-import fs from "fs";
+import {runTolkCompiler, getTolkCompilerVersion, TolkResultSuccess, TolkResultError} from '../src'
+import fs from 'fs'
 
 const EXPECT_TO_CONTAIN = [
-`
+  `
   check1() PROC:<{
     NEWC
     ENDC
     CTOS
     HASHSU
   }>
-`
+`,
 ]
 
-const EXPECT_NOT_TO_CONTAIN = [
-    'HASHBU',
-]
+const EXPECT_NOT_TO_CONTAIN = ['HASHBU']
 
 describe('codegen-checks', () => {
-    let outFiftCode = ''
+  let outFiftCode = ''
+
+  beforeAll(async () => {
+    let result = (await runTolkCompiler({
+      entrypointFileName: 'codegen-checks.tolk',
+      fsReadCallback: path => fs.readFileSync(`./tests/contracts/${path}`, 'utf-8'),
+    })) as TolkResultSuccess
 
-    beforeAll(async () => {
-        let result = await runTolkCompiler({
-            entrypointFileName: "codegen-checks.tolk",
-            fsReadCallback: path => fs.readFileSync(`./tests/contracts/${path}`, 'utf-8')
-        }) as TolkResultSuccess
+    expect(result.status).toEqual('ok')
+    outFiftCode = result.fiftCode
+  })
 
-        expect(result.status).toEqual('ok')
-        outFiftCode = result.fiftCode
-    })
-    
-    it('check contains', () => {
-        for (let subFift of EXPECT_TO_CONTAIN) {
-            expect(outFiftCode).toContain(subFift.trim())
-        }
-        for (let subFift of EXPECT_NOT_TO_CONTAIN) {
-            expect(outFiftCode).not.toContain(subFift)
-        }
-    })
+  it('check contains', () => {
+    for (let subFift of EXPECT_TO_CONTAIN) {
+      expect(outFiftCode).toContain(subFift.trim())
+    }
+    for (let subFift of EXPECT_NOT_TO_CONTAIN) {
+      expect(outFiftCode).not.toContain(subFift)
+    }
+  })
 })