@lvce-editor/shared-process 0.16.18 → 0.16.20

package/extensions/builtin.language-basics-javascript/src/tokenizeJavaScript.js

@@ -143,6 +143,8 @@ const RE_REGEX =
 
 const RE_VARIABLE_NAME_SPECIAL = /\p{L}/u
 const RE_VARIABLE_NAME_SPECIAL_2 = /./u
+const RE_BUILTIN_CLASS =
+  /^(?:Array|Object|Promise|ArrayBuffer|URL|URLSearchParams|WebSocket|FileSystemHandle|Function|StorageEvent|MessageEvent|MessageChannel|Int32Array|Boolean|String|Error|Set|RegExp|Map|WeakMap|RangeError|Date|Headers|Response|Request|Buffer|MessagePort|FileHandle|X509Certificate|Blob|HTMLElement)\b/
 
 export const initialLineState = {
   state: State.TopLevelContent,
@@ -181,11 +183,13 @@ export const tokenizeLine = (line, lineState) => {
             case 'null':
             case 'undefined':
               token = TokenType.LanguageConstant
+              state = State.TopLevelContent
               break
             case 'import':
             case 'export':
             case 'from':
               token = TokenType.KeywordImport
+              state = State.TopLevelContent
               break
             case 'as':
             case 'switch':
@@ -202,6 +206,7 @@ export const tokenizeLine = (line, lineState) => {
             case 'continue':
             case 'while':
               token = TokenType.KeywordControl
+              state = State.TopLevelContent
               break
             case 'assert':
               if (line.includes('import')) {
@@ -209,28 +214,35 @@ export const tokenizeLine = (line, lineState) => {
               } else {
                 token = TokenType.FunctionName
               }
+              state = State.TopLevelContent
               break
             case 'async':
             case 'await':
               token = TokenType.KeywordModifier
+              state = State.TopLevelContent
               break
             case 'return':
               token = TokenType.KeywordReturn
+              state = State.TopLevelContent
               break
             case 'new':
               token = TokenType.KeywordNew
+              state = State.TopLevelContent
               break
             case 'this':
               token = TokenType.KeywordThis
+              state = State.TopLevelContent
               break
             case 'delete':
             case 'typeof':
             case 'in':
             case 'instanceof':
               token = TokenType.KeywordOperator
+              state = State.TopLevelContent
               break
             case 'function':
               token = TokenType.KeywordFunction
+              state = State.TopLevelContent
               break
             case 'Infinity':
               token = TokenType.Numeric
@@ -238,19 +250,24 @@ export const tokenizeLine = (line, lineState) => {
               break
             case 'of':
               token = TokenType.KeywordOperator
+              state = State.TopLevelContent
               break
             case 'class':
+            case 'extends':
               token = TokenType.Keyword
               state = State.AfterKeywordClass
               break
             default:
               token = TokenType.Keyword
+              state = State.TopLevelContent
               break
           }
-          state = State.TopLevelContent
         } else if ((next = part.match(RE_FUNCTION_CALL_NAME))) {
           token = TokenType.FunctionName
           state = State.TopLevelContent
+        } else if ((next = part.match(RE_BUILTIN_CLASS))) {
+          token = TokenType.Class
+          state = State.TopLevelContent
         } else if ((next = part.match(RE_VARIABLE_NAME))) {
           token = TokenType.VariableName
           state = State.TopLevelContent
@@ -451,6 +468,12 @@ export const tokenizeLine = (line, lineState) => {
         } else if ((next = part.match(RE_CURLY_OPEN))) {
           token = TokenType.Punctuation
           state = State.TopLevelContent
+        } else if ((next = part.match(RE_PUNCTUATION))) {
+          token = TokenType.Punctuation
+          state = State.TopLevelContent
+        } else if ((next = part.match(RE_ANYTHING))) {
+          token = TokenType.Text
+          state = State.TopLevelContent
         } else {
           throw new Error('no')
         }

package/extensions/builtin.language-basics-less/src/tokenizeLess.js

@@ -125,6 +125,8 @@ const RE_STRING_SINGLE_QUOTE_CONTENT = /^[^']+/
 const RE_SINGLE_QUOTE = /^'/
 const RE_ANYTHING_BUT_CURLY = /^[^\{\}]+/s
 const RE_LINE_COMMENT = /\/\/.*/
+const RE_NESTED_SELECTOR = /^[\w\.\-\s]+(?=\s*(?:\{|,))/
+const RE_AMPERSAND = /^\&/
 
 /**
  * @param {string} line
@@ -205,9 +207,13 @@ export const tokenizeLine = (line, lineState) => {
         if ((next = part.match(RE_WHITESPACE))) {
           token = TokenType.Whitespace
           state = State.AfterSelector
+        } else if ((next = part.match(RE_AMPERSAND))) {
+          token = TokenType.Punctuation
+          state = State.AfterSelector
         } else if ((next = part.match(RE_CURLY_OPEN))) {
           token = TokenType.CurlyOpen
           state = State.InsideSelector
+          stack.push(State.InsideSelector)
         } else if ((next = part.match(RE_SELECTOR_CLASS))) {
           token = TokenType.CssSelectorClass
           state = State.AfterSelector
@@ -297,6 +303,16 @@ export const tokenizeLine = (line, lineState) => {
         if ((next = part.match(RE_WHITESPACE))) {
           token = TokenType.Whitespace
           state = State.InsideSelector
+        } else if ((next = part.match(RE_AMPERSAND))) {
+          token = TokenType.Punctuation
+          state = State.InsideSelector
+        } else if ((next = part.match(RE_NESTED_SELECTOR))) {
+          if (next[0].startsWith('.')) {
+            token = TokenType.CssSelectorClass
+          } else {
+            token = TokenType.CssSelector
+          }
+          state = State.AfterSelector
         } else if ((next = part.match(RE_PROPERTY_NAME))) {
           token = TokenType.CssPropertyName
           state = State.AfterPropertyName
@@ -318,7 +334,7 @@ export const tokenizeLine = (line, lineState) => {
           state = State.InsideSelector
         } else if ((next = part.match(RE_CURLY_CLOSE))) {
           token = TokenType.CurlyClose
-          state = State.TopLevelContent
+          state = stack.pop() || State.TopLevelContent
         } else {
           throw new Error('no')
         }

package/extensions/builtin.language-basics-wgsl/README.md

@@ -0,0 +1,16 @@
+# Language Basics Wgsl
+
+Wgsl syntax highlighting for Lvce Editor.
+
+## Contributing
+
+```sh
+git clone git@github.com:lvce-editor/language-basics-wgsl.git &&
+cd language-basics-wgsl &&
+npm ci &&
+npm test
+```
+
+## Gitpod
+
+[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/lvce-editor/language-basics-wgsl)

package/extensions/builtin.language-basics-wgsl/extension.json

@@ -0,0 +1,13 @@
+{
+  "id": "builtin.language-basics-wgsl",
+  "name": "Language Basics WGSL",
+  "description": "Provides syntax highlighting and bracket matching in WebGPU Shader Language files.",
+  "languages": [
+    {
+      "id": "wgsl",
+      "extensions": [".wgsl"],
+      "tokenize": "src/tokenizeWgsl.js",
+      "configuration": "languageConfiguration.json"
+    }
+  ]
+}

package/extensions/builtin.language-basics-wgsl/languageConfiguration.json

@@ -0,0 +1,21 @@
+{
+  "comments": {
+    "blockComment": ["/*", "*/"]
+  },
+  "brackets": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  "autoClosingPairs": [
+    { "open": "{", "close": "}", "notIn": ["string", "comment"] },
+    { "open": "[", "close": "]", "notIn": ["string", "comment"] },
+    { "open": "(", "close": ")", "notIn": ["string", "comment"] },
+    { "open": "\"", "close": "\"", "notIn": ["string", "comment"] },
+    { "open": "'", "close": "'", "notIn": ["string", "comment"] }
+  ],
+  "indentationRules": {
+    "increaseIndentPattern": "(^.*\\{[^}]*$)",
+    "decreaseIndentPattern": "^\\s*\\}"
+  }
+}

package/extensions/builtin.language-basics-wgsl/src/tokenizeWgsl.js

@@ -0,0 +1,226 @@
+/**
+ * @enum number
+ */
+export const State = {
+  TopLevelContent: 1,
+  AfterKeywordDeclaration: 2,
+  AfterKeywordStruct: 3,
+}
+
+/**
+ * @enum number
+ */
+export const TokenType = {
+  Whitespace: 2,
+  Punctuation: 3,
+  CurlyOpen: 6,
+  CurlyClose: 7,
+  PropertyColon: 8,
+  Variable: 10,
+  None: 57,
+  Unknown: 881,
+  Numeric: 883,
+  NewLine: 884,
+  Comment: 885,
+  Text: 887,
+  FuntionName: 890,
+  String: 891,
+  KeywordImport: 892,
+  Keyword: 123,
+  KeywordControl: 124,
+  KeywordReturn: 125,
+  Type: 126,
+}
+
+export const TokenMap = {
+  [TokenType.Whitespace]: 'Whitespace',
+  [TokenType.Punctuation]: 'Punctuation',
+  [TokenType.CurlyOpen]: 'Punctuation',
+  [TokenType.CurlyClose]: 'Punctuation',
+  [TokenType.PropertyColon]: 'Punctuation',
+  [TokenType.Variable]: 'VariableName',
+  [TokenType.None]: 'None',
+  [TokenType.Unknown]: 'Unknown',
+  [TokenType.Numeric]: 'Numeric',
+  [TokenType.NewLine]: 'NewLine',
+  [TokenType.Comment]: 'Comment',
+  [TokenType.Text]: 'Text',
+  [TokenType.FuntionName]: 'Function',
+  [TokenType.String]: 'String',
+  [TokenType.KeywordImport]: 'KeywordImport',
+  [TokenType.Keyword]: 'Keyword',
+  [TokenType.KeywordControl]: 'KeywordControl',
+  [TokenType.KeywordReturn]: 'KeywordReturn',
+  [TokenType.Type]: 'Type',
+}
+
+const RE_WHITESPACE = /^\s+/
+const RE_CURLY_OPEN = /^\{/
+const RE_CURLY_CLOSE = /^\}/
+const RE_PROPERTY_NAME = /^[a-zA-Z\-\w]+/
+const RE_COLON = /^:/
+const RE_SEMICOLON = /^;/
+const RE_COMMA = /^,/
+const RE_ANYTHING = /^.+/s
+const RE_NUMERIC = /^\-?(([0-9]+\.?[0-9]*)|(\.[0-9]+))/
+const RE_BLOCK_COMMENT_START = /^\/\*/
+const RE_BLOCK_COMMENT_END = /^\*\//
+const RE_BLOCK_COMMENT_CONTENT = /^.+?(?=\*\/|$)/s
+const RE_ROUND_OPEN = /^\(/
+const RE_ROUND_CLOSE = /^\)/
+const RE_PSEUDO_SELECTOR_CONTENT = /^[^\)]+/
+const RE_SQUARE_OPEN = /^\[/
+const RE_SQUARE_CLOSE = /^\]/
+const RE_ATTRIBUTE_SELECTOR_CONTENT = /^[^\]]+/
+const RE_QUERY = /^@[a-z\-]+/
+const RE_STAR = /^\*/
+const RE_QUERY_NAME = /^[a-zA-Z\w\-\d\_]+/
+const RE_QUERY_CONTENT = /^[^\)]+/
+const RE_COMBINATOR = /^[\+\>\~]/
+const RE_FUNCTION = /^[a-zA-Z][a-zA-Z\-]+(?=\()/
+const RE_VARIABLE_NAME = /^[a-zA-Z\w\-\_\d]+/
+const RE_PERCENT = /^\%/
+const RE_OPERATOR = /^[\-\/\*\+]/
+const RE_DOUBLE_QUOTE = /^"/
+const RE_STRING_DOUBLE_QUOTE_CONTENT = /^[^"]+/
+const RE_STRING_SINGLE_QUOTE_CONTENT = /^[^']+/
+const RE_SINGLE_QUOTE = /^'/
+const RE_ANYTHING_BUT_CURLY = /^[^\{\}]+/s
+const RE_LINE_COMMENT = /^\/\/.*/s
+const RE_KEYWORD =
+  /^(?:var|let|fn|for|struct|vec2|f32|if|elseif|else|mat4x4|vec4|return)\b/
+
+const RE_PUNCTUATION = /^[\{\}\[\]\(\)\.\;\<\>\=\+\-\:\*\/\&>\?\@\<\>\,]/
+
+export const initialLineState = {
+  state: State.TopLevelContent,
+  tokens: [],
+  stack: [],
+}
+
+/**
+ * @param {any} lineStateA
+ * @param {any} lineStateB
+ */
+export const isEqualLineState = (lineStateA, lineStateB) => {
+  return lineStateA.state === lineStateB.state
+}
+
+export const hasArrayReturn = true
+
+/**
+ * @param {string} line
+ * @param {any} lineState
+ */
+export const tokenizeLine = (line, lineState) => {
+  let next = null
+  let index = 0
+  let tokens = []
+  let token = TokenType.None
+  let state = lineState.state
+  const stack = lineState.stack
+  while (index < line.length) {
+    const part = line.slice(index)
+    switch (state) {
+      case State.TopLevelContent:
+        if ((next = part.match(RE_WHITESPACE))) {
+          token = TokenType.Whitespace
+          state = State.TopLevelContent
+        } else if ((next = part.match(RE_LINE_COMMENT))) {
+          token = TokenType.Comment
+          state = State.TopLevelContent
+        } else if ((next = part.match(RE_KEYWORD))) {
+          switch (next[0]) {
+            case 'let':
+            case 'var':
+              token = TokenType.Keyword
+              state = State.AfterKeywordDeclaration
+              break
+            case 'if':
+            case 'elseif':
+            case 'else':
+              token = TokenType.KeywordControl
+              state = State.TopLevelContent
+              break
+            case 'return':
+              token = TokenType.KeywordReturn
+              state = State.TopLevelContent
+              break
+            case 'vec4':
+            case 'vec2':
+            case 'f32':
+            case 'i32':
+            case 'mat4x4':
+              token = TokenType.Type
+              state = State.TopLevelContent
+              break
+            case 'struct':
+              token = TokenType.Keyword
+              state = State.AfterKeywordStruct
+              break
+            default:
+              token = TokenType.Keyword
+              state = State.TopLevelContent
+              break
+          }
+        } else if ((next = part.match(RE_PUNCTUATION))) {
+          token = TokenType.Punctuation
+          state = State.TopLevelContent
+        } else if ((next = part.match(RE_VARIABLE_NAME))) {
+          token = TokenType.Variable
+          state = State.TopLevelContent
+        } else if ((next = part.match(RE_ANYTHING))) {
+          token = TokenType.Unknown
+          state = State.TopLevelContent
+        } else {
+          part //?
+          throw new Error('no')
+        }
+        break
+      case State.AfterKeywordDeclaration:
+        if ((next = part.match(RE_WHITESPACE))) {
+          token = TokenType.Whitespace
+          state = State.AfterKeywordDeclaration
+        } else if ((next = part.match(RE_PUNCTUATION))) {
+          token = TokenType.Punctuation
+          state = State.AfterKeywordDeclaration
+        } else if ((next = part.match(RE_VARIABLE_NAME))) {
+          token = TokenType.Variable
+          state = State.TopLevelContent
+        } else if ((next = part.match(RE_ANYTHING))) {
+          token = TokenType.Unknown
+          state = State.TopLevelContent
+        } else {
+          throw new Error('no')
+        }
+        break
+      case State.AfterKeywordStruct:
+        if ((next = part.match(RE_WHITESPACE))) {
+          token = TokenType.Whitespace
+          state = State.AfterKeywordStruct
+        } else if ((next = part.match(RE_PUNCTUATION))) {
+          token = TokenType.Punctuation
+          state = State.TopLevelContent
+        } else if ((next = part.match(RE_VARIABLE_NAME))) {
+          token = TokenType.Type
+          state = State.TopLevelContent
+        } else if ((next = part.match(RE_ANYTHING))) {
+          token = TokenType.Unknown
+          state = State.TopLevelContent
+        } else {
+          throw new Error('no')
+        }
+        break
+      default:
+        throw new Error('no')
+    }
+    const tokenLength = next[0].length
+    index += tokenLength
+    tokens.push(token, tokenLength)
+  }
+  return {
+    state,
+    tokens,
+    stack,
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.16.18",
+  "version": "0.16.20",
   "description": "Utility package for @lvce-editor/server",
   "main": "index.js",
   "type": "module",
@@ -17,9 +17,9 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.22.5",
-    "@lvce-editor/extension-host": "0.16.18",
-    "@lvce-editor/extension-host-helper-process": "0.16.18",
-    "@lvce-editor/pty-host": "0.16.18",
+    "@lvce-editor/extension-host": "0.16.20",
+    "@lvce-editor/extension-host-helper-process": "0.16.20",
+    "@lvce-editor/pty-host": "0.16.20",
     "debug": "^4.3.4",
     "execa": "^7.1.1",
     "exit-hook": "^3.2.0",

package/src/parts/ElectronContextMenu/ElectronContextMenu.ipc.js

@@ -0,0 +1,7 @@
+import * as ElectronContextMenu from './ElectronContextMenu.js'
+
+export const name = 'ElectronContextMenu'
+
+export const Commands = {
+  openContextMenu: ElectronContextMenu.openContextMenu,
+}

package/src/parts/ElectronContextMenu/ElectronContextMenu.js

@@ -0,0 +1,5 @@
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const openContextMenu = (menuItems, x, y, customData) => {
+  return ParentIpc.invoke('ElectronContextMenu.openContextMenu', menuItems, x, y, customData)
+}

package/src/parts/ElectronProcess/ElectronProcess.ipc.js

@@ -0,0 +1,8 @@
+import * as ElectronProcess from './ElectronProcess.js'
+
+export const name = 'ElectronProcess'
+
+export const Commands = {
+  getChromeVersion: ElectronProcess.getChromeVersion,
+  getElectronVersion: ElectronProcess.getElectronVersion,
+}

package/src/parts/ElectronProcess/ElectronProcess.js

@@ -0,0 +1,9 @@
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const getElectronVersion = () => {
+  return ParentIpc.invoke('Process.getElectronVersion')
+}
+
+export const getChromeVersion = () => {
+  return ParentIpc.invoke('Process.getChromeVersion')
+}

package/src/parts/ElectronSafeStorage/ElectronSafeStorage.ipc.js

@@ -0,0 +1,9 @@
+import * as ElectronSafeStorage from './ElectronSafeStorage.js'
+
+export const name = 'ElectronSafeStorage'
+
+export const Commands = {
+  decryptString: ElectronSafeStorage.decryptString,
+  encryptString: ElectronSafeStorage.encryptString,
+  isEncryptionAvailable: ElectronSafeStorage.isEncryptionAvailable,
+}

package/src/parts/ElectronSafeStorage/ElectronSafeStorage.js

@@ -0,0 +1,13 @@
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const isEncryptionAvailable = () => {
+  return ParentIpc.invoke('ElectronSafeStorage.isEncryptionAvailable')
+}
+
+export const encryptString = (plainText) => {
+  return ParentIpc.invoke('ElectronSafeStorage.encryptString', plainText)
+}
+
+export const decryptString = (encrypted) => {
+  return ParentIpc.invoke('ElectronSafeStorage.decryptString', encrypted)
+}

package/src/parts/ExtensionManifest/ExtensionManifest.js

@@ -3,6 +3,7 @@ import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
 import * as ReadJson from '../JsonFile/JsonFile.js'
 import * as Path from '../Path/Path.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
 import { VError } from '../VError/VError.js'
 
 const RE_EXTENSION_FRAGMENT = /.+(\/|\\)(.+)$/
@@ -32,7 +33,7 @@ export const get = async (path) => {
   } catch (error) {
     const id = inferExtensionId(path)
     const enhancedError = new VError(error, `Failed to load extension manifest for ${id}`)
-    if (error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       try {
         const monoRepoPath = Path.join(path, `packages`, 'extension', 'extension.json')
         const json = await ReadJson.readJson(monoRepoPath)

package/src/parts/ExtensionManifests/ExtensionManifestsFromFolder.js

@@ -1,6 +1,6 @@
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
 import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js'
 import { VError } from '../VError/VError.js'
 
@@ -14,9 +14,7 @@ export const getExtensionManifests = async (path) => {
     const manifests = await Promise.all(absolutePaths.map(ExtensionManifest.get))
     return manifests
   } catch (error) {
-    // TODO how to make typescript happy?
-    // @ts-ignore
-    if (error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       return []
     }
     throw new VError(error, 'Failed to get extension manifests')

package/src/parts/ExtensionManifests/ExtensionManifestsFromLinkedExtensionsFolder.js

@@ -1,8 +1,8 @@
 import { readlink } from 'fs/promises'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
 import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
 import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js'
 import { VError } from '../VError/VError.js'
 
@@ -46,9 +46,7 @@ export const getExtensionManifests = async (path) => {
     const merged = mergeWithSymLinks(manifests, symlinks)
     return merged
   } catch (error) {
-    // TODO how to make typescript happy?
-    // @ts-ignore
-    if (error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       return []
     }
     throw new VError(error, 'Failed to get extension manifests')

package/src/parts/ExtensionUnlink/ExtensionUnlink.js

@@ -1,8 +1,8 @@
 import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
 import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
-import * as FileSystem from '../FileSystem/FileSystem.js'
 import * as Path from '../Path/Path.js'
 import * as Platform from '../Platform/Platform.js'
+import * as RemoveSymlink from '../RemoveSymlink/RemoveSymlink.js'
 import { VError } from '../VError/VError.js'
 
 export const unlink = async (path) => {
@@ -14,7 +14,7 @@ export const unlink = async (path) => {
     const linkedExtensionsPath = Platform.getLinkedExtensionsPath()
     // @ts-ignore
     const to = Path.join(linkedExtensionsPath, manifest.id)
-    await FileSystem.remove(to)
+    await RemoveSymlink.removeSymlink(to)
   } catch (error) {
     throw new VError(error, `Failed to unlink extension`)
   }

package/src/parts/FileSystem/FileSystem.js

@@ -1,10 +1,12 @@
 // TODO lazyload chokidar and trash (but doesn't work currently because of bug with jest)
 import * as fs from 'node:fs/promises'
 import * as os from 'node:os'
+import * as Assert from '../Assert/Assert.js'
 import * as EncodingType from '../EncodingType/EncodingType.js'
-import { FileNotFoundError } from '../FileNotFoundError/FileNotFoundError.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import { FileNotFoundError } from '../FileNotFoundError/FileNotFoundError.js'
 import * as GetDirentType from '../GetDirentType/GetDirentType.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
 import * as Path from '../Path/Path.js'
 import * as Platform from '../Platform/Platform.js'
 import * as Trash from '../Trash/Trash.js'
@@ -36,6 +38,7 @@ export const copy = async (source, target) => {
 export const readFile = async (path, encoding = EncodingType.Utf8) => {
   // console.info('[shared-process] read file', path)
   try {
+    Assert.string(path)
     // const start = performance.now()
     // console.time(`read ${path}`)
     const content = await fs.readFile(path, encoding)
@@ -44,7 +47,7 @@ export const readFile = async (path, encoding = EncodingType.Utf8) => {
     // console.timeEnd(`read ${path}`)
     return content
   } catch (error) {
-    if (error && error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       throw new FileNotFoundError(path)
     }
     throw new VError(error, `Failed to read file "${path}"`)
@@ -59,11 +62,13 @@ export const readFile = async (path, encoding = EncodingType.Utf8) => {
  */
 export const writeFile = async (path, content, encoding = EncodingType.Utf8) => {
   try {
+    Assert.string(path)
+    Assert.string(content)
     // queue would be more correct for concurrent writes but also slower
     // Queue.add(`writeFile/${path}`, () =>
     await fs.writeFile(path, content, encoding)
   } catch (error) {
-    if (error && error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       throw new FileNotFoundError(path)
     }
     throw new VError(error, `Failed to write to file "${path}"`)
@@ -169,7 +174,7 @@ export const readDir = async (path) => {
     const dirents = await fs.readdir(path)
     return dirents
   } catch (error) {
-    if (error && error.code === ErrorCodes.ENOENT) {
+    if (IsEnoentError.isEnoentError(error)) {
       throw new FileNotFoundError(path)
     }
     throw new VError(error, `Failed to read directory "${path}"`)