chore: cloudcmd: actions: lint ☘️

This reverts commit b0687b54c7.

.babelrc

@@ -1,8 +0,0 @@
-{
-  "presets": [
-    "@babel/preset-env"
-  ],
-  "plugins": [
-    "module:babel-plugin-macros",
-  ]
-}

.babelrc.json

@@ -0,0 +1,9 @@
+{
+    "presets": [
+        "@babel/preset-env"
+    ],
+    "plugins": [
+        "module:babel-plugin-macros",
+        "@babel/plugin-transform-optional-chaining"
+    ]
+}

.browserslistrc

@@ -1,5 +1,4 @@
 last 2 Chrome versions
 last 2 Safari versions
 Firefox ESR
-maintained node versions
 not dead

.cloudcmd.menu.js

@@ -1,25 +1,31 @@
-'use strict';
+export default {
-
+    'F2 - Rename File': renameCurrent,
-module.exports = {
+    'L - Lint': run('npm run lint'),
-    'F2 - Rename file': async ({DOM}) => {
+    'F - Fix Lint': run('npm run fix:lint'),
-        await DOM.renameCurrent();
+    'T - Test': run('npm run test'),
-    },
+    'C - Coverage': run('npm run coverage'),
-    'D - Build Dev': async ({CloudCmd}) => {
+    'D - Build Dev': run('npm run build:client:dev'),
-        await CloudCmd.TerminalRun.show({
+    'P - Build Prod': run('npm run build:client'),
-            command: 'npm run build:client:dev',
-            autoClose: false,
-            closeMessage: 'Press any button to close Terminal',
-        });
-        
-        CloudCmd.refresh();
-    },
-    'P - Build Prod': async ({CloudCmd}) => {
-        await CloudCmd.TerminalRun.show({
-            command: 'npm run build:client',
-            autoClose: true,
-        });
-        
-        CloudCmd.refresh();
-    },
 };
 
+async function renameCurrent(DOM) {
+    await DOM.renameCurrent();
+}
+
+function run(command) {
+    return async ({CloudCmd, DOM}) => {
+        const {TerminalRun, config} = CloudCmd;
+        
+        const {CurrentInfo} = DOM;
+        const {dirPath} = CurrentInfo;
+        
+        const cwd = config('root') + dirPath;
+        
+        return await TerminalRun.show({
+            cwd,
+            command,
+            closeMessage: 'Press any key to close Terminal',
+            autoClose: false,
+        });
+    };
+}

.dockerignore

@@ -19,6 +19,5 @@ cssnano.config.js
 bin/release.js
 
 client
-legacy
 server_
 

.editorconfig

@@ -9,7 +9,7 @@ root = true
 charset = utf-8
 end_of_line = lf
 insert_final_newline = true
-trim_trailing_whitespace = true
+trim_trailing_whitespace = false
 indent_style = space
 indent_size = 4
 

.eslintrc.js

@@ -1,34 +0,0 @@
-'use strict';
-
-module.exports = {
-    extends: [
-        'plugin:putout/recommended',
-    ],
-    plugins: [
-        'putout',
-        'node',
-    ],
-    overrides: [{
-        files: ['bin/release.js'],
-        rules: {
-            'no-console': 'off',
-            'node/shebang': 'off',
-        },
-        extends: [
-            'plugin:node/recommended',
-        ],
-    }, {
-        files: ['bin/cloudcmd.js'],
-        rules: {
-            'no-console': 'off',
-        },
-        extends: [
-            'plugin:node/recommended',
-        ],
-    }, {
-        files: ['{client,common}/**/*.js'],
-        env: {
-            browser: true,
-        },
-    }],
-};

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+github: coderaiser
+open_collective: cloudcmd
+ko_fi: coderaiser

.github/ISSUE_TEMPLATE.md

@@ -1,12 +0,0 @@
-<!--
-Thank you for reporting an issue. Please fill in the template below. If unsure
-about something, just do as best as you're able.
--->
-
-* **Version** (`cloudcmd -v`): 
-* **Node Version** `node -v`: 
-* **OS** (`uname -a` on Linux): 
-* **Browser name/version**: 
-* **Used Command Line Parameters**: 
-* **Changed Config**: 
-

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,45 @@
+---
+
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: needs clarification
+assignees: coderaiser
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+
+- **Version** (`cloudcmd -v`):
+- **Node Version** `node -v`:
+- **OS** (`uname -a` on Linux):
+- **Browser name/version**:
+- **Used Command Line Parameters**:
+- **Changed Config**:
+  
+```json
+{}
+```
+- [ ] 🎁 **I'm ready to donate on https://opencollective.com/cloudcmd**
+- [ ] 🎁 **I'm ready to donate on https://ko-fi.com/coderaiser**
+- [ ] 💪 **I'm willing to work on this issue**
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Stack Overflow
+    url: https://stackoverflow.com/search?q=cloudcmd
+    about: Please ask and answer questions here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,21 @@
+---
+
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/issue_template.md

@@ -0,0 +1,24 @@
+***
+
+name: Tracking issue
+about: Create an issue with bug report or feature request.
+title: ""
+labels: needs triage
+assignees: coderaiser
+
+***
+
+- **Version** (`cloudcmd -v`):
+- **Node Version** `node -v`:
+- **OS** (`uname -a` on Linux):
+- **Browser name/version**:
+- **Used Command Line Parameters**:
+- **Changed Config**:
+
+```json
+{}
+```
+
+- [ ] 🎁 **I'm ready to donate on https://opencollective.com/cloudcmd**
+- [ ] 🎁 **I'm ready to donate on https://ko-fi.com/coderaiser**
+- [ ] 💪 **I'm willing to work on this issue**

.github/PULL_REQUEST_TEMPLATE.md

@@ -4,6 +4,5 @@ about something, just do as best as you're able.
 -->
 
 - [ ] commit message named according to [Contributing Guide](https://github.com/coderaiser/cloudcmd/blob/master/CONTRIBUTING.md "Contributting Guide")
-- [ ] `npm run codestyle` is OK
+- [ ] `npm run fix:lint` is OK
 - [ ] `npm test` is OK
-

.github/workflows/docker-io.yml

@@ -0,0 +1,60 @@
+name: Docker IO
+permissions:
+  contents: write
+on:
+  - push
+jobs:
+  buildx:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - name: Use Node.js 24.x
+        uses: actions/setup-node@v6
+        with:
+          node-version: 24.x
+      - name: Install Redrun
+        run: bun i redrun -g --no-save
+      - name: NPM Install
+        run: bun i --no-save
+      - name: Lint
+        run: redrun lint
+      - name: Build
+        id: build
+        run: |
+          redrun build
+          VERSION=$(grep '"version":' package.json -m1 | cut -d\" -f4)
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v4
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+      - name: Login to DockerHub
+        uses: docker/login-action@v4
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v4
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build and push io-image
+        uses: docker/build-push-action@v7
+        with:
+          context: .
+          file: docker/Dockerfile.io
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            coderaiser/cloudcmd:io
+            coderaiser/cloudcmd:${{ steps.build.outputs.version }}-io
+            ghcr.io/${{ github.repository }}-io
+            ghcr.io/${{ github.repository }}:${{ steps.build.outputs.version }}-io

.github/workflows/docker.yml

@@ -0,0 +1,88 @@
+name: Docker CI
+permissions:
+  contents: write
+on:
+  push:
+    tags:
+      - "*"
+jobs:
+  buildx:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - name: Use Node.js 22.x
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22.x
+      - name: Install Redrun
+        run: bun i redrun -g --no-save
+      - name: NPM Install
+        run: bun i --no-save
+      - name: Lint
+        run: redrun lint
+      - name: Build
+        id: build
+        run: |
+          redrun build
+          VERSION=$(grep '"version":' package.json -m1 | cut -d\" -f4)
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v4
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+      - name: Login to DockerHub
+        uses: docker/login-action@v4
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v4
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build and push base-image
+        uses: docker/build-push-action@v7
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            coderaiser/cloudcmd:latest
+            coderaiser/cloudcmd:${{ steps.build.outputs.version }}
+            ghcr.io/${{ github.repository }}:latest
+            ghcr.io/${{ github.repository }}:${{ steps.build.outputs.version }}
+      - name: Build and push alpine-image
+        uses: docker/build-push-action@v7
+        with:
+          context: .
+          file: docker/Dockerfile.alpine
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            coderaiser/cloudcmd:alpine
+            coderaiser/cloudcmd:latest-alpine
+            coderaiser/cloudcmd:${{ steps.build.outputs.version }}-alpine
+            ghcr.io/${{ github.repository }}:latest-alpine
+            ghcr.io/${{ github.repository }}:${{ steps.build.outputs.version }}-alpine
+      - name: Build and push slim-image
+        uses: docker/build-push-action@v7
+        with:
+          context: .
+          file: docker/Dockerfile.slim
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            coderaiser/cloudcmd:slim
+            coderaiser/cloudcmd:latest-slim
+            coderaiser/cloudcmd:${{ steps.build.outputs.version }}-slim
+            ghcr.io/${{ github.repository }}-slim
+            ghcr.io/${{ github.repository }}:${{ steps.build.outputs.version }}-slim

.github/workflows/nodejs.yml

@@ -1,20 +1,53 @@
 name: Node CI
-
+on:
-on: [push]
+  - push
-
+permissions:
+  contents: write
 jobs:
   build:
-
     runs-on: ubuntu-latest
-
+    env:
+      NAME: cloudcmd
+    strategy:
+      matrix:
+        node-version:
+          - 22.x
+          - 24.x
+          - 26.x
     steps:
-    - uses: actions/checkout@master
+      - uses: actions/checkout@v5
-    - name: Use Node.js 12.x
+      - uses: oven-sh/setup-bun@v2
-      uses: actions/setup-node@v1
+        with:
-      with:
+          bun-version: latest
-        version: 12.x
+      - name: Use Node.js ${{ matrix.node-version }}
-    - name: npm install, build, and test
+        uses: actions/setup-node@v6
-      run: |
+        with:
-        npm install
+          node-version: ${{ matrix.node-version }}
-        npm run build
+      - name: Install Redrun
-        npm test
+        run: bun i redrun madrun -g --no-save
+      - name: Install
+        run: bun i --no-save
+      - name: Init Madrun
+        run: madrun --init
+      - name: Lint
+        run: redrun fix:lint
+      - name: Typos
+        uses: coderaiser/typos.ai@v1.1.8
+        with:
+          key: ${{ secrets.TYPOS_AI_KEY }}
+      - name: Commit fixes
+        uses: EndBug/add-and-commit@v10
+        continue-on-error: true
+        with:
+          message: "chore: ${{ env.NAME }}: actions: lint ☘️"
+      - name: Build
+        run: redrun build
+      - name: Test
+        run: redrun test
+      - name: Coverage
+        run: redrun coverage coverage:report
+      - name: Coveralls
+        uses: coverallsapp/github-action@v2
+        continue-on-error: true
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1,18 +1,17 @@
-package-lock.json
+*.swp
-yarn.lock
+*.log
-yarn-error.log
+*.lock
-node_modules
-npm-debug.log*
-coverage
-
-modules/execon
-modules/emitify
 
 .nyc_output
+.DS_Store
+.idea
 
-*.swp
+package-lock.json
-.putoutcache
+npm-debug.log*
 
+node_modules
+coverage
+modules/execon
+modules/emitify
 dist
 dist-dev
-

.madrun.js

@@ -1,178 +1,62 @@
-'use strict';
+import {run, cutEnv} from 'madrun';
+import {defineEnv} from 'supertape/env';
 
-const {
+const testEnv = defineEnv({
-    run,
+    timeout: 7000,
-    parallel,
+    css: true,
-    predefined,
+});
-} = require('madrun');
 
-const {version} = require('./package');
+const buildEnv = {
+    NODE_ENV: 'production',
+};
 
-const names = [
+export default {
-    'bin/cloudcmd.js',
-    'client',
-    'common',
-    'server',
-    'test',
-    'bin/release.js',
-    'webpack.config.js',
-    'cssnano.config.js',
-    '.webpack',
-    '.eslintrc.js',
-    '.madrun.js',
-    '{client,server,common}/**/*.spec.js',
-];
-
-const {putout} = predefined;
-
-const env = 'THREAD_IT_COUNT=0';
-const dockerName = 'coderaiser/cloudcmd';
-
-module.exports = {
     'start': () => 'node bin/cloudcmd.js',
-    'start:dev': () => `NODE_ENV=development ${run('start')}`,
+    'start:dev': async () => await run('start', null, {
-    'build:start': () => run(['build:client', 'start']),
+        NODE_ENV: 'development',
-    'build:start:dev': () => run(['build:client:dev', 'start:dev']),
-    'lint:all': () => run(['lint', 'lint:css', 'spell']),
-    'lint:base': () => putout({
-        names,
     }),
-    'lint:css': () => 'stylelint css/*.css',
+    'build:start': () => run(['build:client', 'start']),
-    'spell': () => 'yaspeller .',
+    'build:start:dev': () => run([
-    'fix:lint': () => run(['lint', 'lint:css'], '--fix'),
+        'build:client:dev',
-    'lint': () => run('lint:progress', '--cache'),
+        'start:dev',
-    'lint:progress': () => run('lint:base', '-f progress'),
+    ]),
-    'lint:stream': () => run('lint:base', '-f stream'),
+    'lint:all': () => run('lint:progress'),
-    
+    'lint': () => 'redlint fix; putout .',
-    'test:base': () => {
+    'lint:progress': () => run('lint', '-f progress'),
-        const cmd = 'tape';
+    'watch:lint': () => 'nodemon -w client -w server -w test -w common -w .webpack -x "putout -s"',
-        const names = `'test/**/*.js' '{client,static,common,server}/**/*.spec.js'`;
+    'fresh:lint': () => run('lint', '--fresh'),
-        
+    'lint:fresh': () => run('lint', '--fresh'),
-        return `${cmd} ${names}`;
+    'fix:lint': async () => `putout --fix . && redlint fix`,
-    },
+    'lint:stream': () => run('lint', '-f stream'),
-    
+    'test': () => [testEnv, `tape '{test}/**/*.js' '{bin,client,static,common,server}/**/*.spec.js' -f fail`],
-    'test': () => `${env} ${run('test:base')}`,
+    'test:e2e': () => `tape 'test-e2e/**/*.js'`,
     'test:client': () => `tape 'test/client/**/*.js'`,
     'test:server': () => `tape 'test/**/*.js' 'server/**/*.spec.js' 'common/**/*.spec.js'`,
-    'wisdom': () => run(['lint:all', 'build', 'test']),
+    'wisdom': async () => await run(['lint:all', 'build', 'test'], null, {
+        CI: 1,
+    }),
     'wisdom:type': () => 'bin/release.js',
-    'docker:pull': () => 'docker pull node',
+    'coverage': async () => [testEnv, `c8 ${await cutEnv('test')}`],
-    'docker:pull:alpine': () => 'docker pull mhart/alpine-node',
+    'coverage:report': () => 'c8 report --reporter=lcov',
-    'docker:pull:arm32': () => 'docker pull arm32v7/node:slim',
+    'report': () => 'c8 report --reporter=lcov',
-    'docker:pull:arm64': () => 'docker pull arm64v8/node:slim',
+    '6to5': () => [buildEnv, 'rspack build --config rspack.config.js'],
-    'docker:push': () => dockerPush('x64', version),
-    'docker:push:latest': () => dockerPush('x64'),
-    'docker:push:alpine': () => dockerPush('alpine', version),
-    'docker:push:alpine:latest': () => dockerPush('alpine'),
-    'docker:push:arm32': () => dockerPush('arm32', version),
-    'docker:push:arm32:latest': () => dockerPush('arm32'),
-    'docker:push:arm64': () => dockerPush('arm64', version),
-    'docker:push:arm64:latest': () => dockerPush('arm64'),
-    'docker:build': () => dockerBuild('docker/Dockerfile', 'x64', version),
-    'docker:build:alpine': () => dockerBuild('docker/Dockerfile.alpine', 'alpine', version),
-    'docker:build:arm32': () => dockerBuild('docker/arm/Dockerfile.arm32v7', 'arm32', version),
-    'docker:build:arm64': () => dockerBuild('docker/arm/Dockerfile.arm64v8', 'arm64', version),
-    'docker:manifest:create': () => {
-        const images = [
-            `${dockerName}:latest`,
-            `${dockerName}:latest-x64`,
-            // `${dockerName}:latest-arm32`,
-            // `${dockerName}:latest-arm64`,
-        ].join(' ');
-        
-        return `docker manifest create ${images}`;
-    },
-    'docker:manifest:push': () => `docker manifest push ${dockerName}:latest`,
-    'docker': () => run(['docker:x64', 'docker:alpine', 'docker:manifest:*']),
-    'docker-ci': () => run(['build', 'docker-login', 'docker']),
-    'docker-login': () => 'docker login -u $DOCKER_USERNAME -p $DOCKER_PASSWORD',
-    
-    'docker:x64': () => run([
-        'docker:pull',
-        'docker:build',
-        'docker:tag',
-        'docker:push',
-        'docker:push:latest',
-    ]),
-    
-    'docker:alpine': () => run([
-        'docker:pull:alpine',
-        'docker:build:alpine',
-        'docker:tag:alpine',
-        'docker:push:alpine',
-        'docker:push:alpine:latest',
-    ]),
-    
-    /*
-    'docker:arm32': () => run([
-        'docker:pull:arm32',
-        'docker:build:arm32',
-        'docker:tag:arm32',
-        'docker:push:arm32',
-        'docker:push:arm32:latest',
-    ]),
-    
-    'docker:arm64': () => run([
-        'docker:pull:arm64',
-        'docker:build:arm64',
-        'docker:tag:arm64',
-        'docker:push:arm64',
-        'docker:push:arm64:latest',
-    ]),
-    */
-    
-    'docker:manifest': () => run([
-        'docker:manifest:create',
-        'docker:manifest:push',
-    ]),
-    
-    'docker:tag': () => dockerTag('x64', version),
-    'docker:tag:alpine': () => dockerTag('alpine', version),
-    'docker:tag:arm32': () => dockerTag('arm32', version),
-    'docker:tag:arm64': () => dockerTag('arm64', version),
-    'docker:rm:version': () => dockerRmi('x64', version),
-    'docker:rm:latest': () => dockerRmi('x64'),
-    'docker:rm:alpine': () => dockerRmi('alpine', version),
-    'docker:rm:latest-alpine': () => dockerRmi('alpine'),
-    'docker:rm:arm32': () => dockerRmi('arm32', version),
-    'docker:rm:latest-arm32': () => dockerRmi('arm32'),
-    'docker:rm:arm64': () => dockerRmi('arm64', version),
-    'docker:rm:latest-arm64': () => dockerRmi('arm64'),
-    'docker:rm-old': () => `${parallel('docker:rm:*')} || true`,
-    
-    'coverage': () => `${env} nyc ${run('test:base')}`,
-    'report': () => 'nyc report --reporter=text-lcov | coveralls',
-    '6to5': () => 'webpack --progress',
     '6to5:client': () => run('6to5', '--mode production'),
-    '6to5:client:dev': () => `NODE_ENV=development ${run('6to5', '--mode development')}`,
+    '6to5:client:dev': async () => await run('6to5', '--mode development', {
+        NODE_ENV: 'development',
+    }),
     'pre6to5:client': () => 'rimraf dist',
     'pre6to5:client:dev': () => 'rimraf dist-dev',
     'watch:client': () => run('6to5:client', '--watch'),
     'watch:client:dev': () => run('6to5:client:dev', '--watch'),
     'watch:server': () => 'nodemon bin/cloudcmd.js',
-    'watch:lint': () => `nodemon -w client -w server -w webpack.config.js -x ${run('lint')}`,
+    'watch:test': async () => [testEnv, `nodemon -w client -w server -w test -w common -x ${await cutEnv('test')}`],
-    'watch:test': () => `nodemon -w client -w server -w test -w common -x ${run('test')}`,
+    'watch:test:client': async () => `nodemon -w client -w test/client -x ${await run('test:client')}`,
-    'watch:test:client': () => `nodemon -w client -w test/client -x ${run('test:client')}`,
+    'watch:test:server': async () => `nodemon -w client -w test/client -x ${await run('test:server')}`,
-    'watch:test:server': () => `nodemon -w client -w test/client -x ${run('test:server')}`,
+    'watch:coverage': async () => [testEnv, `nodemon -w server -w test -w common -x ${await cutEnv('coverage')}`],
-    'watch:coverage': () => `nodemon -w server -w test -w common -x ${run('coverage')}`,
+    'watch:fix:lint': async () => `nodemon -w client -w server -w test -w common -x '${await run('fix:lint')}'`,
-    'build': () => run('6to5:*'),
+    'build': async () => run('6to5:*'),
+    'build:dev': async () => run('build:client:dev'),
     'build:client': () => run('6to5:client'),
     'build:client:dev': () => run('6to5:client:dev'),
     'heroku-postbuild': () => run('6to5:client'),
 };
-
-function dockerPush(type, version = 'latest') {
-    return `docker push coderaiser/cloudcmd:${version}-${type}`;
-}
-
-function dockerBuild(file, type, version) {
-    return `docker build -f ${file} -t coderaiser/cloudcmd:${version}-${type} .`;
-}
-
-function dockerTag(type, version) {
-    return `docker tag coderaiser/cloudcmd:${version}-${type} coderaiser/cloudcmd:latest-${type}`;
-}
-
-function dockerRmi(type, version = 'latest') {
-    return `docker rmi -f coderaiser/cloudcmd:${version}-${type}`;
-}

.npmignore

@@ -1,30 +1,29 @@
-.*
+*.spec.*
-*.spec.js
+*.config.*
 *.fixture.js*
-manifest.yml
-docker
-docker-compose.yml
-test
-fixture
-coverage
-css
-html
-yarn-error.log
-yarn.lock
-now.json
-cssnano.config.js
-
-app.json
-bower.json
-manifest.yml
-
-bin/release.js
-
-client
-
-webpack.config.js
-
 *.ai
 *.cdr
 *.eps
+*.log
+*.lock
 
+.*
+
+manifest.yml
+docker-compose.yml
+now.json
+app.json
+bower.json
+deno.json
+bin/release.*
+img/logo/cloudcmd-hq.png
+webpack.config.js
+
+docker
+test*
+fixture
+fixture-*
+coverage
+css
+html
+client

.nycrc.json

@@ -0,0 +1,15 @@
+{
+    "checkCoverage": false,
+    "all": false,
+    "exclude": [
+        "**/*.spec.js",
+        "**/*.*.js",
+        "**/*.config.*",
+        "**/fixture",
+        "**/test/**"
+    ],
+    "branches": 100,
+    "lines": 100,
+    "functions": 100,
+    "statements": 100
+}

.putout.json

@@ -1,27 +1,60 @@
 {
+    "plugins": ["cloudcmd"],
+    "ignore": [
+        "*.md",
+        "app.json",
+        "fontello.json",
+        "html",
+        "fixture*"
+    ],
+    "rules": {
+        "package-json/add-type": "off"
+    },
     "match": {
+        ".filesystem.json": {
+            "nodejs/rename-file-cjs-to-js": "off"
+        },
+        "base64": {
+            "types/convert-typeof-to-is-type": "off"
+        },
+        "*.md": {
+            "nodejs/convert-commonjs-to-esm": "on"
+        },
+        ".webpack": {
+            "webpack": "on"
+        },
         "server": {
-            "remove-process-exit": true
+            "nodejs/remove-process-exit": "on"
         },
-        "server/(server|exit).js": {
+        "server/{server,exit}.js": {
-            "remove-process-exit": false,
+            "nodejs/remove-process-exit": "off"
-            "remove-console": false
         },
-        "server/(terminal|distribute/log).js": {
+        "server/{server,exit,terminal,distribute/log}.{js,mjs}": {
-            "remove-console": false
+            "remove-console": "off"
         },
-        "client/(client|cloudcmd|load-module).js": {
+        "client/{client,cloudcmd,load-module}.{js,mjs}": {
-            "remove-console": false
+            "remove-console": "off"
         },
-        "client/modules/config/index.js": {
+        "client": {
-            "apply-shorthand-properties": [{
+            "nodejs": "off"
-                "ignore": [
+        },
-                    "ONE_MINUTE"
+        "client/sw": {
-                ]
+            "remove-console": "off"
-            }]
         },
         "test/common/cloudfunc.js": {
-            "remove-console": false
+            "remove-console": "off"
+        },
+        "storage.js": {
+            "promises/remove-useless-async": "off"
+        },
+        "docker.yml": {
+            "github/set-node-versions": "off"
+        },
+        "vim.js": {
+            "merge-duplicate-functions": "off"
+        },
+        "common": {
+            "nodejs/declare": "off"
         }
     }
 }

.rspack/css.js

@@ -0,0 +1,38 @@
+import {env} from 'node:process';
+import {rspack} from '@rspack/core';
+
+const {CssExtractRspackPlugin} = rspack;
+const isDev = env.NODE_ENV === 'development';
+
+const plugins = [
+    new CssExtractRspackPlugin({
+        filename: '[name].css',
+    }),
+];
+
+const rules = [{
+    test: /\.css$/i,
+    use: [CssExtractRspackPlugin.loader, {
+        loader: 'css-loader',
+        options: {
+            url: true,
+        },
+    }],
+}, {
+    test: /\.(png|gif|svg|woff|woff2|eot|ttf)$/,
+    type: 'asset/inline',
+}];
+
+export default {
+    mode: isDev ? 'development' : 'production',
+    plugins,
+    module: {
+        rules,
+    },
+    optimization: {
+        minimize: !isDev,
+        minimizer: [
+            new rspack.LightningCssMinimizerRspackPlugin(),
+        ],
+    },
+};

.rspack/html.js

@@ -0,0 +1,36 @@
+import {env} from 'node:process';
+import HtmlWebpackPlugin from 'html-webpack-plugin';
+
+const isDev = env.NODE_ENV === 'development';
+
+export const plugins = [
+    new HtmlWebpackPlugin({
+        inject: false,
+        template: 'html/index.html',
+        minify: !isDev && getMinifyHtmlOptions(),
+    }),
+];
+
+function getMinifyHtmlOptions() {
+    return {
+        removeComments: true,
+        removeCommentsFromCDATA: true,
+        removeCDATASectionsFromCDATA: true,
+        collapseWhitespace: true,
+        collapseBooleanAttributes: true,
+        removeAttributeQuotes: true,
+        removeRedundantAttributes: true,
+        useShortDoctype: true,
+        removeEmptyAttributes: true,
+        /* оставляем, поскольку у нас
+         * в элемент fm генерируеться
+         * таблица файлов
+         */
+        removeEmptyElements: false,
+        removeOptionalTags: true,
+        removeScriptTypeAttributes: true,
+        removeStyleLinkTypeAttributes: true,
+        
+        minifyJS: true,
+    };
+}

.rspack/js.js

@@ -0,0 +1,173 @@
+import {resolve, sep} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {env} from 'node:process';
+import {rspack} from '@rspack/core';
+
+const resolveModule = (a) => fileURLToPath(import.meta.resolve(a));
+
+const {
+    EnvironmentPlugin,
+    NormalModuleReplacementPlugin,
+    ProvidePlugin,
+} = rspack;
+
+const modules = './modules';
+const dirModules = './client/modules';
+const dirCss = './css';
+const dirThemes = `${dirCss}/themes`;
+const dirColumns = `${dirCss}/columns`;
+const dir = './client';
+const {NODE_ENV} = env;
+const isDev = NODE_ENV === 'development';
+
+const rootDir = new URL('..', import.meta.url).pathname;
+const dist = resolve(rootDir, 'dist');
+const distDev = resolve(rootDir, 'dist-dev');
+const devtool = isDev ? 'eval' : 'source-map';
+
+const noParse = (a) => a.endsWith('.spec.js');
+
+// codegen.macro is a babel-macro (build-time codegen), not supported by
+// Rspack's native SWC transform, so client/sw/sw.js (the only file that
+// uses it) keeps going through babel-loader. Everything else uses
+// Rspack's built-in SWC loader, which is the main source of the speedup.
+const rules = [{
+    test: /sw\/sw\.js$/,
+    exclude: /node_modules/,
+    loader: 'babel-loader',
+}, {
+    test: /\.[mc]?js$/,
+    exclude: [/node_modules/, /sw\/sw\.js$/],
+    loader: 'builtin:swc-loader',
+    options: {
+        jsc: {
+            parser: {
+                syntax: 'ecmascript',
+            },
+        },
+        env: {
+            targets: 'defaults',
+        },
+    },
+}];
+
+const plugins = [
+    new NormalModuleReplacementPlugin(/^node:/, (resource) => {
+        resource.request = resource.request.replace(/^node:/, '');
+    }),
+    new NormalModuleReplacementPlugin(/^putout$/, '@putout/bundle'),
+    new EnvironmentPlugin({
+        NODE_ENV,
+    }),
+    new ProvidePlugin({
+        process: 'process/browser',
+    }),
+];
+
+const splitChunks = {
+    chunks: 'all',
+    cacheGroups: {
+        abcCommon: {
+            name: 'cloudcmd.common',
+            chunks: (chunk) => {
+                const lazyChunks = [
+                    'sw',
+                    'nojs',
+                    'view',
+                    'edit',
+                    'terminal',
+                    'config',
+                    'user-menu',
+                    'help',
+                    'themes/dark',
+                    'themes/light',
+                    'columns/name-size',
+                    'columns/name-size-date',
+                    'columns/name-size-time',
+                    'columns/name-size-date-time',
+                ];
+                
+                return !lazyChunks.includes(chunk.name);
+            },
+            minChunks: 1,
+            enforce: true,
+            priority: -1,
+            reuseExistingChunk: true,
+        },
+    },
+};
+
+export default {
+    resolve: {
+        symlinks: false,
+        alias: {
+            'node:process': 'process',
+            'node:path': 'path',
+        },
+        fallback: {
+            path: resolveModule('path-browserify'),
+            process: resolveModule('process/browser'),
+            util: resolveModule('util'),
+        },
+    },
+    devtool,
+    optimization: {
+        splitChunks,
+    },
+    entry: {
+        'themes/dark': `${dirThemes}/dark.css`,
+        'themes/light': `${dirThemes}/light.css`,
+        'columns/name-size': `${dirColumns}/name-size.css`,
+        'columns/name-size-date': `${dirColumns}/name-size-date.css`,
+        'columns/name-size-date-time': `${dirColumns}/name-size-date-time.css`,
+        'nojs': `${dirCss}/nojs.css`,
+        'help': `${dirCss}/help.css`,
+        'view': `${dirCss}/view.css`,
+        'config': `${dirCss}/config.css`,
+        'terminal': `${dirCss}/terminal.css`,
+        'user-menu': `${dirCss}/user-menu.css`,
+        'sw': `${dir}/sw/sw.js`,
+        'cloudcmd': `${dir}/cloudcmd.js`,
+        [`${modules}/edit`]: `${dirModules}/edit.js`,
+        [`${modules}/edit-file`]: `${dirModules}/edit-file.js`,
+        [`${modules}/edit-file-vim`]: `${dirModules}/edit-file-vim.js`,
+        [`${modules}/edit-names`]: `${dirModules}/edit-names.js`,
+        [`${modules}/edit-names-vim`]: `${dirModules}/edit-names-vim.js`,
+        [`${modules}/menu`]: `${dirModules}/menu/index.js`,
+        [`${modules}/view`]: `${dirModules}/view/index.js`,
+        [`${modules}/help`]: `${dirModules}/help.js`,
+        [`${modules}/markdown`]: `${dirModules}/markdown.js`,
+        [`${modules}/config`]: `${dirModules}/config/index.js`,
+        [`${modules}/contact`]: `${dirModules}/contact.js`,
+        [`${modules}/upload`]: `${dirModules}/upload.js`,
+        [`${modules}/operation`]: `${dirModules}/operation/index.js`,
+        [`${modules}/konsole`]: `${dirModules}/konsole.js`,
+        [`${modules}/terminal`]: `${dirModules}/terminal.js`,
+        [`${modules}/terminal-run`]: `${dirModules}/terminal-run.js`,
+        [`${modules}/cloud`]: `${dirModules}/cloud.js`,
+        [`${modules}/user-menu`]: `${dirModules}/user-menu/index.js`,
+        [`${modules}/polyfill`]: `${dirModules}/polyfill.js`,
+        [`${modules}/command-line`]: `${dirModules}/command-line.js`,
+    },
+    output: {
+        filename: '[name].js',
+        path: isDev ? distDev : dist,
+        pathinfo: isDev,
+        devtoolModuleFilenameTemplate,
+        publicPath: '/dist/',
+    },
+    module: {
+        rules,
+        noParse,
+    },
+    plugins,
+    performance: {
+        maxEntrypointSize: 800_000,
+        maxAssetSize: 600_000,
+    },
+};
+
+function devtoolModuleFilenameTemplate(info) {
+    const resource = info.absoluteResourcePath.replace(rootDir + sep, '');
+    return `file://cloudcmd/${resource}`;
+}

.stylelintrc.yml

@@ -1,17 +0,0 @@
-extends: stylelint-config-standard
-rules:
-    indentation: 4
-    declaration-block-trailing-semicolon: always
-    declaration-colon-space-before: null
-    selector-list-comma-newline-after: null
-    comment-empty-line-before: null
-    number-leading-zero: null
-    number-no-trailing-zeros: null
-    string-quotes: single
-    function-url-quotes: never
-    no-eol-whitespace: null
-    font-family-name-quotes: always-unless-keyword
-    font-family-no-missing-generic-family-keyword: null
-    rule-empty-line-before: null
-    max-empty-lines: 2
-

.travis.yml

@@ -1,52 +0,0 @@
-language: node_js
-node_js:
-  - 14
-  - 12
-  - 10
-
-cache:
-  npm: false
-
-matrix:
-  allow_failures:
-    - os: windows
-
-os:
-  - linux
-  - osx
-  - windows
-
-# https://docs.travis-ci.com/user/customizing-the-build/#git-end-of-line-conversion-control
-# need for windows
-git:
-  autocrlf: input
-
-
-script:
-  - npm run lint && npm run build && npm run coverage && npm run report
-
-notifications:
-  email:
-    on_success: never
-    on_failure: change
-
-sudo: required
-
-services:
-  - docker
-
-before_deploy:
-  - echo '{"experimental":"enabled"}' | sudo tee /etc/docker/daemon.json
-  - mkdir -p $HOME/.docker
-  - echo '{"experimental":"enabled"}' | tee $HOME/.docker/config.json
-  - sudo service docker start
-
-deploy:
-  provider: script
-  script: npm run docker-ci
-  skip_cleanup: true
-  on:
-    node: 12
-    condition: $TRAVIS_OS_NAME = linux
-    tags: true
-    all_branches: false

.typos.toml

@@ -0,0 +1,2 @@
+[files]
+extend-exclude = ["ChangeLog"]

.webpack/css.js

@@ -1,81 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const {
-    basename,
-    extname,
-    join,
-} = require('path');
-
-const {env} = process;
-const isDev = env.NODE_ENV === 'development';
-
-const ExtractTextPlugin = require('extract-text-webpack-plugin');
-const OptimizeCssAssetsPlugin = require('optimize-css-assets-webpack-plugin');
-
-const extractCSS = (a) => new ExtractTextPlugin(`${a}.css`);
-const extractMain = extractCSS('[name]');
-
-const cssNames = [
-    'nojs',
-    'view',
-    'config',
-    'terminal',
-    'user-menu',
-    ...getCSSList('columns'),
-];
-
-const cssPlugins = cssNames.map(extractCSS);
-const clean = (a) => a.filter(Boolean);
-
-const plugins = clean([
-    ...cssPlugins,
-    extractMain,
-    !isDev && new OptimizeCssAssetsPlugin(),
-]);
-
-const rules = [{
-    test: /\.css$/,
-    exclude: /css\/(nojs|view|config|terminal|user-menu|columns.*)\.css/,
-    use: extractMain.extract([
-        'css-loader',
-    ]),
-},
-...cssPlugins.map(extract), {
-    test: /\.(png|gif|svg|woff|woff2|eot|ttf)$/,
-    use: {
-        loader: 'url-loader',
-        options: {
-            limit: 100000,
-        },
-    },
-}];
-
-module.exports = {
-    plugins,
-    module: {
-        rules,
-    },
-};
-
-function getCSSList(dir) {
-    const base = (a) => basename(a, extname(a));
-    const addDir = (name) => `${dir}/${name}`;
-    const rootDir = join(__dirname, '..');
-    
-    return fs.readdirSync(`${rootDir}/css/${dir}`)
-        .map(base)
-        .map(addDir);
-}
-
-function extract(extractPlugin) {
-    const {filename} = extractPlugin;
-    
-    return {
-        test: RegExp(`css/${filename}`),
-        use: extractPlugin.extract([
-            'css-loader',
-        ]),
-    };
-}
-

.webpack/html.js

@@ -1,43 +0,0 @@
-'use strict';
-
-const {env} = process;
-const isDev = env.NODE_ENV === 'development';
-
-const HtmlWebpackPlugin = require('html-webpack-plugin');
-
-const plugins = [
-    new HtmlWebpackPlugin({
-        inject: false,
-        template: 'html/index.html',
-        minify: !isDev && getMinifyHtmlOptions(),
-    }),
-];
-
-module.exports = {
-    plugins,
-};
-
-function getMinifyHtmlOptions() {
-    return {
-        removeComments:                 true,
-        removeCommentsFromCDATA:        true,
-        removeCDATASectionsFromCDATA:   true,
-        collapseWhitespace:             true,
-        collapseBooleanAttributes:      true,
-        removeAttributeQuotes:          true,
-        removeRedundantAttributes:      true,
-        useShortDoctype:                true,
-        removeEmptyAttributes:          true,
-        /* оставляем, поскольку у нас
-         * в элемент fm генерируеться
-         * таблица файлов
-         */
-        removeEmptyElements:            false,
-        removeOptionalTags:             true,
-        removeScriptTypeAttributes:     true,
-        removeStyleLinkTypeAttributes:  true,
-        
-        minifyJS:                       true,
-    };
-}
-

.webpack/js.js

@@ -1,134 +0,0 @@
-'use strict';
-
-const {
-    resolve,
-    sep,
-    join,
-} = require('path');
-
-const {EnvironmentPlugin} = require('webpack');
-
-const ServiceWorkerWebpackPlugin = require('serviceworker-webpack-plugin');
-
-const dir = './client';
-const dirModules = './client/modules';
-const modules = './modules';
-
-const {env} = process;
-const {NODE_ENV} = env;
-const isDev = NODE_ENV === 'development';
-
-const rootDir = join(__dirname, '..');
-const dist = resolve(rootDir, 'dist');
-const distDev = resolve(rootDir, 'dist-dev');
-const devtool = isDev ? 'eval' : 'source-map';
-
-const notEmpty = (a) => a;
-const clean = (array) => array.filter(notEmpty);
-
-const noParse = (a) => /\.spec\.js$/.test(a);
-
-const options = {
-    babelrc: false,
-    plugins: [
-        'module:babel-plugin-macros',
-    ],
-};
-
-const rules = clean([
-    !isDev && {
-        test: /\.js$/,
-        exclude: /node_modules/,
-        loader: 'babel-loader',
-    },
-    isDev && {
-        test: /\.js$/,
-        exclude: /node_modules/,
-        loader: 'babel-loader',
-        options,
-    }]);
-
-const plugins = [
-    new EnvironmentPlugin({
-        NODE_ENV,
-    }),
-    
-    new ServiceWorkerWebpackPlugin({
-        entry: join(__dirname, '..', 'client', 'sw', 'sw.js'),
-        excludes: ['*'],
-    }),
-];
-
-const splitChunks = {
-    name: 'cloudcmd.common',
-    chunks: 'all',
-};
-
-module.exports = {
-    resolve: {
-        symlinks: false,
-    },
-    devtool,
-    optimization: {
-        splitChunks,
-    },
-    entry: {
-        cloudcmd: `${dir}/cloudcmd.js`,
-        [modules + '/edit']: `${dirModules}/edit.js`,
-        [modules + '/edit-file']: `${dirModules}/edit-file.js`,
-        [modules + '/edit-file-vim']: `${dirModules}/edit-file-vim.js`,
-        [modules + '/edit-names']: `${dirModules}/edit-names.js`,
-        [modules + '/edit-names-vim']: `${dirModules}/edit-names-vim.js`,
-        [modules + '/menu']: `${dirModules}/menu.js`,
-        [modules + '/view']: `${dirModules}/view.js`,
-        [modules + '/help']: `${dirModules}/help.js`,
-        [modules + '/markdown']: `${dirModules}/markdown.js`,
-        [modules + '/config']: `${dirModules}/config/index.js`,
-        [modules + '/contact']: `${dirModules}/contact.js`,
-        [modules + '/upload']: `${dirModules}/upload.js`,
-        [modules + '/operation']: `${dirModules}/operation/index.js`,
-        [modules + '/konsole']: `${dirModules}/konsole.js`,
-        [modules + '/terminal']: `${dirModules}/terminal.js`,
-        [modules + '/terminal-run']: `${dirModules}/terminal-run.js`,
-        [modules + '/cloud']: `${dirModules}/cloud.js`,
-        [modules + '/user-menu']: `${dirModules}/user-menu/index.js`,
-        [modules + '/polyfill']: `${dirModules}/polyfill.js`,
-    },
-    output: {
-        filename: '[name].js',
-        path: isDev ? distDev : dist,
-        pathinfo: isDev,
-        devtoolModuleFilenameTemplate,
-        publicPath: '/dist/',
-    },
-    externals: [
-        externals,
-    ],
-    module: {
-        rules,
-        noParse,
-    },
-    plugins,
-    performance: {
-        maxEntrypointSize: 600000,
-        maxAssetSize: 600000,
-    },
-};
-
-function externals(context, request, fn) {
-    if (!isDev)
-        return fn();
-    
-    const list = [];
-    
-    if (list.includes(request))
-        return fn(null, request);
-    
-    fn();
-}
-
-function devtoolModuleFilenameTemplate(info) {
-    const resource = info.absoluteResourcePath.replace(rootDir + sep, '');
-    return `file://cloudcmd/${resource}`;
-}
-

.yaspellerrc

@@ -22,12 +22,14 @@
         "Iptables",
         "JitSu",
         "Node",
+        "IO",
         "Olena",
         "TarZak",
         "Termux",
         "Zalitok",
         "WebSocket",
         "auth",
+        "autostart",
         "binded",
         "cd",
         "cloudcmd",
@@ -44,6 +46,7 @@
         "gz",
         "io",
         "js",
+        "linux",
         "maintainers",
         "markdown",
         "microservice",
@@ -53,6 +56,8 @@
         "nginx",
         "npm",
         "or io",
+        "patreon",
+        "rc",
         "refactor",
         "sexualized",
         "sslPort",
@@ -61,6 +66,7 @@
         "v0",
         "v1",
         "v2",
-        "yml"
+        "yml",
+        "systemd"
     ]
 }

CODE_OF_CONDUCT.md

@@ -8,19 +8,19 @@ In the interest of fostering an open and welcoming environment, we as contributo
 
 Examples of behavior that contributes to creating a positive environment include:
 
-* Using welcoming and inclusive language
+- Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
+- Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
+- Gracefully accepting constructive criticism
-* Focusing on what is best for the community
+- Focusing on what is best for the community
-* Showing empathy towards other community members
+- Showing empathy towards other community members
 
 Examples of unacceptable behavior by participants include:
 
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
+- The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
+- Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
+- Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
+- Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
+- Other conduct which could reasonably be considered inappropriate in a professional setting
 
 ## Our Responsibilities
 

CONTRIBUTING.md

@@ -1,27 +1,30 @@
-Commit
+## Commit
----------------
+
 Format of the commit message: **type(scope) subject**
 
 **Type**:
-- feature(scope) subject
+
-- fix(scope) subject
+- feature: scope: subject
-- docs(scope) subject
+- fix: scope: subject
-- refactor(scope) subject
+- docs: scope: subject
-- test(scope) subject
+- refactor: scope: subject
-- chore(scope) subject
+- test: scope: subject
+- chore: scope: subject
 
 **Scope**:
 Scope could be anything specifying place of the commit change.
 For example util, console, view, edit, style etc...
 
 **Subject text**:
+
 - use imperative, present tense: “change” not “changed” nor “changes”
 - don't capitalize first letter
 - no dot (.) at the end
-**Message body**:
+  **Message body**:
 - just as in <subject> use imperative, present tense: “change” not “changed” nor “changes”
 - includes motivation for the change and contrasts with previous behavior
 
 **Examples**:
-- [fix(style) .name{width}: 37% -> 35%](https://github.com/coderaiser/cloudcmd/commit/94b0642e3990c17b3a0ee3efeb75f343e1e7c050)
+
-- [fix(console) dispatch: focus -> mouseup](https://github.com/coderaiser/cloudcmd/commit/f41ec5058d1411e86a881f8e8077e0572e0409ec)
+- [fix: style: .name{width}: 37% -> 35%](https://github.com/coderaiser/cloudcmd/commit/94b0642e3990c17b3a0ee3efeb75f343e1e7c050)
+- [fix: console: dispatch: focus -> mouseup](https://github.com/coderaiser/cloudcmd/commit/f41ec5058d1411e86a881f8e8077e0572e0409ec)

LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2012-2019 Coderaiser <mnemonic.enemy@gmail.com>
+Copyright (c) 2012-2025 Coderaiser <mnemonic.enemy@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

README.md

@@ -1,25 +1,22 @@
-# Cloud Commander v14.6.0 [![Build Status][BuildStatusIMGURL]][BuildStatusURL] [![Codacy][CodacyIMG]][CodacyURL] [![Gitter][GitterIMGURL]][GitterURL] [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fcoderaiser%2Fcloudcmd.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fcoderaiser%2Fcloudcmd?ref=badge_shield)
+# Cloud Commander v19.19.1 [![Build Status][BuildStatusIMGURL]][BuildStatusURL] [![Codacy][CodacyIMG]][CodacyURL] [![Gitter][GitterIMGURL]][GitterURL] [![Deploy on InstaPods][DeployInstaPodsIMG]][DeployInstaPodsURL]
 
-### [Main][MainURL] [Blog][BlogURL] Live([Heroku][HerokuURL])
+### [Main][MainURL] [Blog][BlogURL] [Support][SupportURL] [Demo][DemoURL]
 
-[NPM_INFO_IMG]:             https://nodei.co/npm/cloudcmd.png
+[MainURL]: https://cloudcmd.io "Main"
-[MainURL]:                  http://cloudcmd.io "Main"
+[BlogURL]: https://blog.cloudcmd.io "Blog"
-[BlogURL]:                  http://blog.cloudcmd.io "Blog"
+[SupportURL]: https://patreon.com/coderaiser "Patreon"
-[HerokuURL]:                https://cloudcmd.herokuapp.com/ "Heroku"
+[DemoURL]: https://cloudcmd-zdp6.onrender.com
-[BuildStatusURL]:           https://travis-ci.org/coderaiser/cloudcmd  "Build Status"
+[NPM_INFO_IMG]: https://nodei.co/npm/cloudcmd.png
-[BuildStatusIMGURL]:        https://img.shields.io/travis/coderaiser/cloudcmd.svg?style=flat-squere&longCache=true
+[BuildStatusURL]: https://github.com/coderaiser/cloudcmd/actions/workflows/nodejs.yml "Build Status"
-
+[BuildStatusIMGURL]: https://github.com/coderaiser/cloudcmd/actions/workflows/nodejs.yml/badge.svg
-[BuildAppveyorURL]:         https://ci.appveyor.com/project/coderaiser/cloudcmd
+[CodacyURL]: https://www.codacy.com/app/coderaiser/cloudcmd
-[BuildAppveyorIMGURL]:      https://ci.appveyor.com/api/projects/status/tse6sc8dxrqxqehi?svg=true
+[CodacyIMG]: https://api.codacy.com/project/badge/Grade/ddda78be780549ce8754f8d47a8c0e36
-
+[GitterURL]: https://gitter.im/cloudcmd/hello
-[CodacyURL]:                https://www.codacy.com/app/coderaiser/cloudcmd
+[GitterIMGURL]: https://img.shields.io/gitter/room/coderaiser/cloudcmd.js.svg
-[CodacyIMG]:                https://api.codacy.com/project/badge/Grade/ddda78be780549ce8754f8d47a8c0e36
+[DeployURL]: https://heroku.com/deploy?template=https://github.com/coderaiser/cloudcmd "Deploy"
-
+[DeployIMG]: https://www.herokucdn.com/deploy/button.png
-[GitterURL]:                https://gitter.im/cloudcmd/hello
+[DeployInstaPodsIMG]: https://img.shields.io/badge/deploy%20on-InstaPods-blue
-[GitterIMGURL]:             https://img.shields.io/gitter/room/coderaiser/cloudcmd.js.svg
+[DeployInstaPodsURL]: https://app.instapods.com/dashboard/pods/create?app=cloudcmd&ref=cloudcmd
-
-[DeployURL]:                https://heroku.com/deploy?template=https://github.com/coderaiser/cloudcmd "Deploy"
-[DeployIMG]:                https://www.herokucdn.com/deploy/button.png
 
 **Cloud Commander** a file manager for the web with console and editor.
 
@@ -30,6 +27,7 @@
 ```
 npm i cloudcmd -g
 ```
+
 ## Start
 
 For starting just type in console:
@@ -47,8 +45,8 @@ Open url `http://localhost:8000` in browser.
 You will see something similar to this.
 ![View](https://cloudcmd.io/img/screen/view.png "View")
 
-
 ## Deploy
+
 `Cloud Commander` could be easily deployed to [Heroku][DeployURL].
 
 [![Deploy][DeployIMG]][DeployURL]
@@ -72,17 +70,19 @@ npm i cloudcmd express socket.io -S
 And create `index.js`:
 
 ```js
-const http = require('http');
+import http from 'node:http';
-const cloudcmd = require('cloudcmd');
+import {cloudcmd} from 'cloudcmd';
-const io = require('socket.io');
+import {Server} from 'socket.io';
-const app = require('express')();
+import express from 'express';
+
+const app = express();
 
 const port = 1337;
 const prefix = '/';
 
 const server = http.createServer(app);
-const socket = io.listen(server, {
+const socket = new Server(server, {
-    path: `${prefix}/socket.io`
+    path: `${prefix}socket.io`,
 });
 
 const config = {
@@ -93,8 +93,8 @@ const filePicker = {
     data: {
         FilePicker: {
             key: 'key',
-        }
+        },
-    }
+    },
 };
 
 // override option from json/modules.json
@@ -109,11 +109,11 @@ const {
 
 const configManager = createConfigManager({
     configPath,
-}),
+});
 
 app.use(prefix, cloudcmd({
-    socket,  // used by Config, Edit (optional) and Console (required)
+    socket, // used by Config, Edit (optional) and Console (required)
-    config,  // config data (optional)
+    config, // config data (optional)
     modules, // optional
     configManager, // optional
 }));
@@ -121,12 +121,21 @@ app.use(prefix, cloudcmd({
 server.listen(port);
 ```
 
-Docker
+## Docker
----------------
+
+The docker images are provided for multiple architectures and types. The following list shows all existing images:
+
+| Architecture   | Type         |
+|----------------|--------------|
+| amd64          | linux        |
+| arm64 (arm/v8) | linux        |
+| amd64          | linux-alpine |
+| arm64 (arm/v8) | linux-alpine |
+
 `Cloud Commander` could be used as a [docker container](https://hub.docker.com/r/coderaiser/cloudcmd/ "Docker container") this way:
 
 ```sh
-docker run -t --rm -v ~:/root -v /:/mnt/fs -w=/root -p 8000:8000 coderaiser/cloudcmd
+docker run -it --rm -v ~:/root -v /:/mnt/fs -w=/root -p 8000:8000 coderaiser/cloudcmd
 ```
 
 Config would be read from home directory, hosts root file system would be mount to `/mnt/fs`,
@@ -152,11 +161,15 @@ When you create this file run:
 docker-compose up
 ```
 
-Get involved
+## Documentation
----------------
+
+More documentation you can find on https://cloudcmd.io/.
+
+## Get involved
 
 There is a lot ways to be involved in `Cloud Commander` development:
 
+- support project on patreon: https://patreon.com/coderaiser;
 - if you find a bug or got idea to share [create an issue](https://github.com/coderaiser/cloudcmd/issues/new "Create issue");
 - if you fixed a bug, typo or implemented new feature [create pull request](https://github.com/coderaiser/cloudcmd/compare "Create pull request");
 - if you know languages you can help with [site translations](https://github.com/coderaiser/cloudcmd/wiki "Cloud Commander community wiki");

app.json

@@ -11,6 +11,7 @@
     "folder",
     "orthodox"
   ],
+  "stack": "heroku-18",
   "env": {
       "NPM_CONFIG_PRODUCTION": {
           "description": "Keep false to install devDependencies and build frontend",
@@ -62,11 +63,6 @@
           "value": "",
           "required": false
       },
-      "CLOUDCMD_CONFIG_DIALOG": {
-          "description": "show config dialog",
-          "value": "false",
-          "required": false
-      },
       "CLOUDCMD_ONE_FILE_PANEL": {
           "description": "show one file panel",
           "value": "false",

bin/cloudcmd.js

@@ -1,37 +1,48 @@
 #!/usr/bin/env node
 
-'use strict';
+import process from 'node:process';
+import {promisify} from 'node:util';
+import {tryToCatch} from 'try-to-catch';
+import parse from 'yargs-parser';
+import exit from '../server/exit.js';
+import {createConfig, configPath} from '../server/config.js';
+import * as env from '../server/env.js';
+import prefixer from '../server/prefixer.js';
+import * as validate from '../server/validate.js';
+import Info from '../package.json' with {
+    type: 'json',
+};
 
-const Info = require('../package');
+process.on('unhandledRejection', exit);
-const DIR_SERVER = '../server/';
 
-const {promisify} = require('util');
+const isUndefined = (a) => typeof a === 'undefined';
-const tryToCatch = require('try-to-catch');
-
-const exit = require(DIR_SERVER + 'exit');
-const {
-    createConfig,
-    configPath,
-} = require(DIR_SERVER + 'config');
-
-const config = createConfig({
-    configPath,
-});
-
-const env = require(DIR_SERVER + 'env');
-const prefixer = require(DIR_SERVER + '/prefixer');
 
 const choose = (a, b) => {
-    if (a === undefined)
+    if (isUndefined(a))
         return b;
     
     return a;
 };
 
-process.on('unhandledRejection', exit);
+const config = createConfig({
+    configPath,
+});
 
-const {argv} = process;
+const maybeRoot = (a) => {
-const args = require('minimist')(argv.slice(2), {
+    if (a === '.')
+        return process.cwd();
+    
+    return a;
+};
+
+const yargsOptions = {
+    configuration: {
+        'strip-aliased': true,
+        'strip-dashed': true,
+    },
+    coerce: {
+        root: maybeRoot,
+    },
     string: [
         'name',
         'port',
@@ -46,6 +57,8 @@ const args = require('minimist')(argv.slice(2), {
         'terminal-path',
         'terminal-command',
         'columns',
+        'menu',
+        'theme',
         'import-url',
         'import-token',
         'export-token',
@@ -60,6 +73,7 @@ const args = require('minimist')(argv.slice(2), {
         'open',
         'config-dialog',
         'config-auth',
+        'config-port',
         'console',
         'sync-console-path',
         'contact',
@@ -69,6 +83,7 @@ const args = require('minimist')(argv.slice(2), {
         'confirm-copy',
         'confirm-move',
         'show-config',
+        'show-dot-files',
         'show-file-name',
         'vim',
         'keys-panel',
@@ -77,65 +92,70 @@ const args = require('minimist')(argv.slice(2), {
         'import',
         'import-listen',
         'log',
+        'zip',
         'dropbox',
     ],
     default: {
-        'server'      : true,
+        'server': true,
-        'name'        : choose(env('name'), config('name')),
+        'name': choose(env.parse('name'), config('name')),
-        'auth'        : choose(env.bool('auth'), config('auth')),
+        'auth': choose(env.bool('auth'), config('auth')),
-        'port'        : config('port'),
+        'port': config('port'),
-        'online'      : config('online'),
+        'online': config('online'),
-        'open'        : choose(env.bool('open'), config('open')),
+        'open': choose(env.bool('open'), config('open')),
-        'editor'      : env('editor') || config('editor'),
+        'editor': env.parse('editor') || config('editor'),
-        'packer'      : config('packer') || 'tar',
+        'menu': env.parse('menu') || config('menu'),
-        'zip'         : config('zip'),
+        'packer': config('packer') || 'tar',
-        'username'    : env('username') || config('username'),
+        'zip': config('zip'),
-        'root'        : choose(env('root'), config('root')),
+        'username': env.parse('username') || config('username'),
-        'prefix'      : choose(env('cloudcmd_prefix'), config('prefix')),
+        'root': choose(env.parse('root'), config('root')),
-        'console'     : choose(env.bool('console'), config('console')),
+        'prefix': choose(env.parse('prefix'), config('prefix')),
-        'contact'     : choose(env.bool('contact'), config('contact')),
+        'console': choose(env.bool('console'), config('console')),
-        'terminal'    : choose(env.bool('terminal'), config('terminal')),
+        'contact': choose(env.bool('contact'), config('contact')),
-        'columns'     : env('columns') || config('columns') || '',
+        'terminal': choose(env.bool('terminal'), config('terminal')),
-        'vim'         : choose(env.bool('vim'), config('vim')),
+        'columns': env.parse('columns') || config('columns') || '',
-        'log'         : config('log'),
+        'theme': env.parse('theme') || config('theme') || '',
+        'vim': choose(env.bool('vim'), config('vim')),
+        'log': choose(env.bool('log'), config('log')),
         
-        'import-url': env('import_url') || config('importUrl'),
+        'import-url': env.parse('import_url') || config('importUrl'),
         'import-listen': choose(env.bool('import_listen'), config('importListen')),
-        'import'      : choose(env.bool('import'), config('import')),
+        'import': choose(env.bool('import'), config('import')),
-        'export'      : choose(env.bool('export'), config('export')),
+        'export': choose(env.bool('export'), config('export')),
         
         'prefix-socket': config('prefixSocket'),
+        'show-dot-files': choose(env.bool('show_dot_files'), config('showDotFiles')),
         'show-file-name': choose(env.bool('show_file_name'), config('showFileName')),
         'sync-console-path': choose(env.bool('sync_console_path'), config('syncConsolePath')),
         'config-dialog': choose(env.bool('config_dialog'), config('configDialog')),
         'config-auth': choose(env.bool('config_auth'), config('configAuth')),
-        'terminal-path': env('terminal_path') || config('terminalPath'),
+        'config-port': choose(env.bool('config_port'), config('configPort')),
-        'terminal-command': env('terminal_command') || config('terminalCommand'),
+        'terminal-path': env.parse('terminal_path') || config('terminalPath'),
+        'terminal-command': env.parse('terminal_command') || config('terminalCommand'),
         'terminal-auto-restart': choose(env.bool('terminal_auto_restart'), config('terminalAutoRestart')),
         'one-file-panel': choose(env.bool('one_file_panel'), config('oneFilePanel')),
         'confirm-copy': choose(env.bool('confirm_copy'), config('confirmCopy')),
         'confirm-move': choose(env.bool('confirm_move'), config('confirmMove')),
         'keys-panel': env.bool('keys_panel') || config('keysPanel'),
-        'import-token': env('import_token') || config('importToken'),
+        'import-token': env.parse('import_token') || config('importToken'),
-        'export-token': env('export_token') || config('exportToken'),
+        'export-token': env.parse('export_token') || config('exportToken'),
         
         'dropbox': config('dropbox'),
-        'dropbox-token': config('dropboxToken'),
+        'dropbox-token': config('dropboxToken') || '',
     },
     alias: {
-        v: 'version',
+        version: 'v',
-        h: 'help',
+        help: 'h',
-        p: 'password',
+        password: 'p',
-        o: 'online',
+        online: 'o',
-        u: 'username',
+        username: 'u',
-        s: 'save',
+        save: 's',
-        a: 'auth',
+        auth: 'a',
-        c: 'config',
+        config: 'c',
     },
-    unknown: (cmd) => {
+};
-        exit('\'%s\' is not a cloudcmd option. See \'cloudcmd --help\'.', cmd);
+
-    },
+const {argv} = process;
-});
+const args = parse(argv.slice(2), yargsOptions);
 
 if (args.version)
     version();
@@ -145,8 +165,21 @@ else
     main();
 
 async function main() {
+    const {validateArgs} = await import('@putout/cli-validate-args');
+    
+    const error = await validateArgs(args, [
+        ...yargsOptions.boolean,
+        ...yargsOptions.string,
+    ]);
+    
+    if (error)
+        return exit(error);
+    
     if (args.repl)
-        repl();
+        await repl();
+    
+    validate.columns(args.columns);
+    validate.theme(args.theme);
     
     port(args.port);
     
@@ -156,37 +189,41 @@ async function main() {
     config('open', args.open);
     config('username', args.username);
     config('console', args.console);
-    config('syncConsolePath', args['sync-console-path']);
+    config('syncConsolePath', args.syncConsolePath);
-    config('showFileName', args['show-file-name']);
+    config('showDotFiles', args.showDotFiles);
+    config('showFileName', args.showFileName);
     config('contact', args.contact);
     config('terminal', args.terminal);
-    config('terminalPath', args['terminal-path']);
+    config('terminalPath', args.terminalPath);
-    config('terminalCommand', args['terminal-command']);
+    config('terminalCommand', args.terminalCommand);
-    config('terminalAutoRestart', args['terminal-auto-restart']);
+    config('terminalAutoRestart', args.terminalAutoRestart);
     config('editor', args.editor);
+    config('menu', args.menu);
     config('prefix', prefixer(args.prefix));
-    config('prefixSocket', prefixer(args['prefix-socket']));
+    config('prefixSocket', prefixer(args.prefixSocket));
     config('root', args.root || '/');
     config('vim', args.vim);
+    config('theme', args.theme);
     config('columns', args.columns);
     config('log', args.log);
-    config('confirmCopy', args['confirm-copy']);
+    config('confirmCopy', args.confirmCopy);
-    config('confirmMove', args['confirm-move']);
+    config('confirmMove', args.confirmMove);
-    config('oneFilePanel', args['one-file-panel']);
+    config('oneFilePanel', args.oneFilePanel);
-    config('configDialog', args['config-dialog']);
+    config('configDialog', args.configDialog);
-    config('configAuth', args['config-auth']);
+    config('configAuth', args.configAuth);
-    config('keysPanel', args['keys-panel']);
+    config('configPort', args.configPort);
+    config('keysPanel', args.keysPanel);
     config('export', args.export);
-    config('exportToken', args['export-token']);
+    config('exportToken', args.exportToken);
     config('import', args.import);
-    config('importToken', args['import-token']);
+    config('importToken', args.importToken);
-    config('importListen', args['import-listen']);
+    config('importListen', args.importListen);
-    config('importUrl', args['import-url']);
+    config('importUrl', args.importUrl);
     
-    config('dropbox', args['dropbox']);
+    config('dropbox', args.dropbox);
-    config('dropboxToken', args['dropbox-token'] || '');
+    config('dropboxToken', args.dropboxToken);
     
-    readConfig(args.config);
+    await readConfig(args.config);
     
     const options = {
         root: config('root'),
@@ -195,42 +232,44 @@ async function main() {
         prefix: config('prefix'),
         prefixSocket: config('prefixSocket'),
         columns: config('columns'),
+        theme: config('theme'),
+        menu: config('menu'),
     };
     
-    const password = env('password') || args.password;
+    const password = env.parse('password') || args.password;
     
     if (password)
-        config('password', getPassword(password));
+        config('password', await getPassword(password));
     
     validateRoot(options.root, config);
     
-    if (args['show-config'])
+    if (args.showConfig)
-        showConfig();
+        await showConfig();
     
-    const distribute = require('../server/distribute');
+    const {distributeImport} = await import('../server/distribute/import.js');
-    const importConfig = promisify(distribute.import);
+    const importConfig = promisify(distributeImport);
     
-    await importConfig(config);
+    await start(options, config);
     
     if (args.save)
         config.write();
     
-    start(options, config);
     await tryToCatch(checkUpdate);
+    await importConfig(config);
 }
 
 function validateRoot(root, config) {
-    const validate = require(DIR_SERVER + 'validate');
     validate.root(root, config);
     
     if (root === '/')
         return;
     
-    console.log(`root: ${root}`);
+    if (config('log'))
+        console.log(`root: ${root}`);
 }
 
-function getPassword(password) {
+async function getPassword(password) {
-    const criton = require('criton');
+    const {default: criton} = await import('criton');
     return criton(password, config('algo'));
 }
 
@@ -238,13 +277,11 @@ function version() {
     console.log('v' + Info.version);
 }
 
-function start(options, config) {
+async function start(options, config) {
-    const SERVER = DIR_SERVER + 'server';
-    
     if (!args.server)
         return;
     
-    const server = require(SERVER);
+    const {default: server} = await import('../server/server.js');
     server(options, config);
 }
 
@@ -257,38 +294,38 @@ function port(arg) {
     exit('cloudcmd --port: should be a number');
 }
 
-function showConfig() {
+async function showConfig() {
-    const show = require('../server/show-config');
+    const {showConfig} = await import('../server/show-config.js');
-    const data = show(config('*'));
+    const data = showConfig(config('*'));
     
     console.log(data);
 }
 
-function readConfig(name) {
+async function readConfig(name) {
     if (!name)
         return;
     
-    const fs = require('fs');
+    const {default: forEachKey} = await import('for-each-key');
-    const tryCatch = require('try-catch');
-    const jju = require('jju');
-    const forEachKey = require('for-each-key');
     
-    const readjsonSync = (name) => jju.parse(fs.readFileSync(name, 'utf8'), {
+    const data = await import(name, {
-        mode: 'json',
+        with: {
+            type: 'json',
+        },
     });
     
-    const [error, data] = tryCatch(readjsonSync, name);
-    
-    if (error)
-        return exit(error.message);
-    
     forEachKey(config, data);
 }
 
-function help() {
+async function help() {
-    const bin = require('../json/help');
+    const {default: bin} = await import('../json/help.json', {
-    const forEachKey = require('for-each-key');
+        with: {
-    const currify = require('currify');
+            type: 'json',
+        },
+    });
+    
+    const {default: forEachKey} = await import('for-each-key');
+    const {default: currify} = await import('currify');
+    
     const usage = 'Usage: cloudcmd [options]';
     const url = Info.homepage;
     const log = currify((a, b, c) => console.log(a, b, c));
@@ -299,28 +336,27 @@ function help() {
     console.log('\nGeneral help using Cloud Commander: <%s>', url);
 }
 
-function repl() {
+async function repl() {
     console.log('REPL mode enabled (telnet localhost 1337)');
-    require(DIR_SERVER + 'repl');
+    await import('../server/repl.js');
 }
 
 async function checkUpdate() {
-    const load = require('package-json');
+    const {default: load} = await import('package-json');
-    
     const {version} = await load(Info.name, 'latest');
-    showUpdateInfo(version);
+    
+    await showUpdateInfo(version);
 }
 
-function showUpdateInfo(version) {
+async function showUpdateInfo(version) {
     if (version === Info.version)
         return;
     
-    const chalk = require('chalk');
+    const {default: chalk} = await import('chalk');
     
-    const latestVersion = chalk.green.bold('v' + version);
+    const latestVersion = chalk.green.bold(`v${version}`);
     const latest = `update available: ${latestVersion}`;
     const current = chalk.dim(`(current: v${Info.version})`);
     
     console.log('%s %s', latest, current);
 }
-

bin/cloudcmd.spec.js

@@ -0,0 +1,26 @@
+import {spawnSync} from 'node:child_process';
+import {test} from 'supertape';
+import info from '../package.json' with {
+    type: 'json',
+};
+
+const cliPath = new URL('cloudcmd.js', import.meta.url).pathname;
+
+test('cloudcmd: bin: cli: -h', (t) => {
+    const {stdout} = spawnSync(cliPath, ['-h'], {
+        encoding: 'utf8',
+    });
+    
+    t.match(stdout, `Options`);
+    t.end();
+});
+
+test('cloudcmd: bin: cli: -v', (t) => {
+    const {version} = info;
+    const {stdout} = spawnSync(cliPath, ['-v'], {
+        encoding: 'utf8',
+    });
+    
+    t.match(stdout, `v${version}`);
+    t.end();
+});

bin/release.js

@@ -1,67 +1,72 @@
 #!/usr/bin/env node
 
-'use strict';
+import {promisify} from 'node:util';
+import process from 'node:process';
+import {tryToCatch} from 'try-to-catch';
+import minor from 'minor';
+import _place from 'place';
+import {rendy} from 'rendy';
+import shortdate from 'shortdate';
+import Info from '../package.json' with {
+    type: 'json',
+};
 
-const DIR = '../';
+const place = promisify(_place);
-const Info = require(DIR + 'package');
 
-const minor = require('minor');
+await main();
-const place = require('place');
-const rendy = require('rendy');
-const shortdate = require('shortdate');
 
-const ERROR = Error('ERROR: version is missing. release --patch|--minor|--major');
+async function main() {
-
+    const history = '## Version history\n\n';
-main((error) => {
-    if (error)
-        console.error(error.message);
-});
-
-function main(callback) {
-    const history = 'Version history\n---------------\n';
     const link = '//github.com/coderaiser/cloudcmd/releases/tag/';
-    const template = '- *{{ date }}*, ' +
+    
-                      '**[v{{ version }}]' +
+    const template = '- ' +
-                      '(' + link + 'v{{ version }})**\n';
+        '*{{ date }}*, ' +
+        '**[v{{ version }}]' +
+        '(' +
+        link +
+        'v{{ version }})**\n';
     
     const {version} = Info;
     
-    cl((error, versionNew) => {
+    const [error, versionNew] = await tryToCatch(cl);
-        if (error)
+    
-            return callback(error);
+    if (error)
-        
+        return console.error(error);
-        replaceVersion('README.md', version, versionNew, callback);
+    
-        replaceVersion('HELP.md', version, versionNew, () => {
+    await replaceVersion('README.md', version, versionNew);
-            const historyNew = history + rendy(template, {
+    await replaceVersion('HELP.md', version, versionNew);
-                date    : shortdate(),
+    
-                version : versionNew,
+    const historyNew = history +
-            });
+        rendy(template, {
-            
+            date: shortdate(),
-            replaceVersion('HELP.md', history, historyNew, callback);
+            version: versionNew,
         });
-    });
+    
+    await replaceVersion('HELP.md', history, historyNew);
 }
 
-function replaceVersion(name, version, versionNew, callback) {
+async function replaceVersion(name, version, versionNew) {
-    place(name, version, versionNew, (error) => {
+    const [error] = await tryToCatch(place, name, version, versionNew);
-        if (error)
+    
-            return callback(error);
+    if (error)
-        
+        return console.error(error);
-        callback(null, 'done: ' + name);
+    
-    });
+    console.log(`done: ${name}`);
 }
 
-function cl(callback) {
+async function cl() {
     const {argv} = process;
     const length = argv.length - 1;
     const last = process.argv[length];
     const regExp = /^--(major|minor|patch)$/;
     const [, match] = last.match(regExp) || [];
     
-    if (!regExp.test(last))
+    console.log(last);
-        return callback(ERROR);
     
-    callback(null, getVersionNew(last, match));
+    if (!regExp.test(last))
+        throw Error('ERROR: version is missing. release --patch|--minor|--major');
+    
+    return getVersionNew(last, match);
 }
 
 function getVersionNew(last, match) {
@@ -70,4 +75,3 @@ function getVersionNew(last, match) {
     
     return last.substr(3);
 }
-

client/client.js

@@ -1,74 +1,59 @@
-'use strict';
+import process from 'node:process';
-
+import Emitify from 'emitify';
-/* global DOM */
+import inherits from 'inherits';
-
+import {rendy} from 'rendy';
-const Emitify = require('emitify');
+import load from 'load.js';
-const inherits = require('inherits');
+import {tryToCatch} from 'try-to-catch';
-const rendy = require('rendy');
+import {addSlashToEnd} from 'format-io';
-const load = require('load.js');
+import pascalCase from 'just-pascal-case';
-const tryToCatch = require('try-to-catch');
+import currify from 'currify';
-
+import {
-const pascalCase = require('just-pascal-case');
-const isDev = process.env.NODE_ENV === 'development';
-
-const Images = require('./dom/images');
-const {unregisterSW} = require('./sw/register');
-const getJsonFromFileTable = require('./get-json-from-file-table');
-
-const currify = require('currify');
-
-const noJS = (a) => a.replace(/.js$/, '');
-
-const {
     apiURL,
     formatMsg,
     buildFromJSON,
-} = require('../common/cloudfunc');
+} from '#common/cloudfunc';
+import * as Images from '#dom/images';
+import {unregisterSW} from './sw/register.js';
+import {getJsonFromFileTable} from './get-json-from-file-table.js';
+import {Key} from './key/index.js';
+import {loadModule} from './load-module.js';
 
-const loadModule = require('./load-module');
+const noJS = (a) => a.replace(/.js$/, '');
+
+const isDev = process.env.NODE_ENV === 'development';
 
 inherits(CloudCmdProto, Emitify);
 
-module.exports = new CloudCmdProto(DOM);
+export const createCloudCmd = ({DOM, Listeners}) => {
+    return new CloudCmdProto({
+        DOM,
+        Listeners,
+    });
+};
 
 load.addErrorListener((e, src) => {
     const msg = `file ${src} could not be loaded`;
     Images.show.error(msg);
 });
 
-function CloudCmdProto(DOM) {
+function CloudCmdProto({DOM, Listeners}) {
-    let Listeners;
-    
-    const log = (...a) => {
-        if (!isDev )
-            return;
-        
-        console.log(...a);
-    };
-    
     Emitify.call(this);
     
     const CloudCmd = this;
     const Info = DOM.CurrentInfo;
     
-    const {
+    const {Storage, Files} = DOM;
-        Storage,
-        Files,
-    } = DOM;
     
-    this.log = log;
+    this.log = () => {
+        if (!isDev)
+            return;
+    };
     this.prefix = '';
     this.prefixSocket = '';
     this.prefixURL = '';
-    this.DIRCLIENT = '/dist/';
-    this.DIRCLIENT_MODULES = this.DIRCLIENT + 'modules/';
     
-    this.MIN_ONE_PANEL_WIDTH = 1155;
+    this.MIN_ONE_PANEL_WIDTH = DOM.getCSSVar('min-one-panel-width');
     this.HOST = location.origin || location.protocol + '//' + location.host;
-    
-    const TITLE = 'Cloud Commander';
-    this.TITLE = TITLE;
-    
     this.sort = {
         left: 'name',
         right: 'name',
@@ -79,28 +64,16 @@ function CloudCmdProto(DOM) {
         right: 'asc',
     };
     
-    /**
+    this.changeDir = async (path, overrides = {}) => {
-     * Функция привязываеться ко всем ссылкам и
-     *  загружает содержимое каталогов
-     *
-     * @param params - {
-     *          paramLink - ссылка
-     *          needRefresh - необходимость обязательной загрузки данных с сервера
-     *          panel
-     *      }
-     * @param callback
-     */
-    this.loadDir = async (params) => {
-        const p = params;
-        const refresh = p.isRefresh;
-        
         const {
+            isRefresh,
             panel,
-            history,
+            history = true,
             noCurrent,
             currentName,
-        } = p;
+        } = overrides;
         
+        const refresh = isRefresh;
         let panelChanged;
         
         if (!noCurrent && panel && panel !== Info.panel) {
@@ -116,11 +89,12 @@ function CloudCmdProto(DOM) {
         Images.show.load(imgPosition, panel);
         
         /* загружаем содержимое каталога */
-        await ajaxLoad(p.path, {
+        await ajaxLoad(addSlashToEnd(path), {
             refresh,
             history,
             noCurrent,
             currentName,
+            showDotFiles: CloudCmd.config('showDotFiles'),
         }, panel);
     };
     
@@ -133,6 +107,8 @@ function CloudCmdProto(DOM) {
         CloudCmd.prefix = prefix;
         CloudCmd.prefixURL = `${prefix}${apiURL}`;
         CloudCmd.prefixSocket = config.prefixSocket;
+        CloudCmd.DIR_DIST = `${prefix}/dist`;
+        CloudCmd.DIR_MODULES = `${this.DIR_DIST}/modules`;
         
         CloudCmd.config = (key) => config[key];
         CloudCmd.config.if = currify((key, fn, a) => config[key] && fn(a));
@@ -141,7 +117,6 @@ function CloudCmdProto(DOM) {
              * should be called from config.js only
              * after successful update on server
              */
-            
             if (key === 'password')
                 return;
             
@@ -152,22 +127,14 @@ function CloudCmdProto(DOM) {
             CloudCmd.MIN_ONE_PANEL_WIDTH = Infinity;
         
         if (!document.body.scrollIntoViewIfNeeded)
-            await load.js(prefix + CloudCmd.DIRCLIENT_MODULES + 'polyfill.js');
+            await load.js(`${CloudCmd.DIR_MODULES}/polyfill.js`);
         
         await initModules();
         await baseInit();
-        await loadStyle();
         
         CloudCmd.route(location.hash);
     };
     
-    async function loadStyle() {
-        const {prefix} = CloudCmd;
-        const name = prefix + '/dist/cloudcmd.common.css';
-        
-        await load.css(name);
-    }
-    
     this.route = (path) => {
         const query = path.split('/');
         
@@ -177,12 +144,13 @@ function CloudCmdProto(DOM) {
         const [kebabModule] = query;
         const module = noJS(pascalCase(kebabModule.slice(1)));
         
-        const file = query[1];
+        const [, file] = query;
         const current = DOM.getCurrentByName(file);
         
         if (file && !current) {
             const msg = formatMsg('set current file', file, 'error');
             CloudCmd.log(msg);
+            
             return;
         }
         
@@ -204,7 +172,7 @@ function CloudCmdProto(DOM) {
     };
     
     const initModules = async () => {
-        CloudCmd.Key = new CloudCmd.Key();
+        CloudCmd.Key = Key;
         CloudCmd.Key.bind();
         
         const [, modules] = await tryToCatch(Files.get, 'modules');
@@ -254,7 +222,7 @@ function CloudCmdProto(DOM) {
             });
         
         const dirPath = DOM.getCurrentDirPath();
-        Listeners = CloudCmd.Listeners;
+        
         Listeners.init();
         
         const panels = getPanels();
@@ -268,7 +236,7 @@ function CloudCmdProto(DOM) {
         const data = await Storage.get(dirPath);
         
         if (!data)
-            await Storage.set(dirPath, getJsonFromFileTable());
+            await Storage.setJson(dirPath, getJsonFromFileTable());
     }
     
     function getPanels() {
@@ -291,19 +259,15 @@ function CloudCmdProto(DOM) {
     };
     
     this.refresh = async (options = {}) => {
-        const {
+        const {panel = Info.panel, currentName} = options;
-            panel = Info.panel,
-            currentName,
-        } = options;
         
         const path = DOM.getCurrentDirPath(panel);
         
         const isRefresh = true;
         const history = false;
-        const noCurrent = options ? options.noCurrent : false;
+        const noCurrent = options?.noCurrent;
         
-        await CloudCmd.loadDir({
+        await CloudCmd.changeDir(path, {
-            path,
             isRefresh,
             history,
             panel,
@@ -319,22 +283,18 @@ function CloudCmdProto(DOM) {
      * @param options
      * { refresh, history } - необходимость обновить данные о каталоге
      * @param panel
-     * @param callback
      *
      */
     async function ajaxLoad(path, options = {}, panel) {
         const {RESTful} = DOM;
         
-        CloudCmd.log('reading dir: "' + path + '";');
+        CloudCmd.log(`reading dir: "${path}";`);
         
         const dirStorage = CloudCmd.config('dirStorage');
-        const json = dirStorage && await Storage.get(path);
+        const json = dirStorage && await Storage.getJson(path);
         
         const name = options.currentName || Info.name;
-        const {
+        const {noCurrent, refresh} = options;
-            noCurrent,
-            refresh,
-        } = options;
         
         if (!refresh && json)
             return await createFileTable(json, panel, options);
@@ -351,7 +311,8 @@ function CloudCmdProto(DOM) {
         const [, newObj] = await RESTful.read(path + query, 'json');
         
         if (!newObj)
-            return; // that's OK, error handled by RESTful
+            // that's OK, error handled by RESTful
+            return;
         
         options.sort = sort;
         options.order = order;
@@ -364,28 +325,35 @@ function CloudCmdProto(DOM) {
         if (!CloudCmd.config('dirStorage'))
             return;
         
-        Storage.set(path, newObj);
+        Storage.setJson(path, newObj);
     }
     
     /**
      * Функция строит файловую таблицу
-     * @param json  - данные о файлах
+     * @param data - данные о файлах
      * @param panelParam
-     * @param history
+     * @param options - history, noCurrent, showDotFiles
-     * @param callback
      */
     async function createFileTable(data, panelParam, options) {
         const {
             history,
             noCurrent,
+            showDotFiles,
         } = options;
         
-        const names = ['file', 'path', 'link', 'pathLink'];
+        const names = [
+            'file',
+            'path',
+            'link',
+            'pathLink',
+        ];
         
-        const [
+        const [error, [
-            error,
+            file,
-            [file, path, link, pathLink],
+            path,
-        ] = await tryToCatch(Files.get, names);
+            link,
+            pathLink,
+        ]] = await tryToCatch(Files.get, names);
         
         if (error)
             return DOM.Dialog.alert(error.responseText);
@@ -393,10 +361,7 @@ function CloudCmdProto(DOM) {
         const panel = panelParam || DOM.getPanel();
         const {prefix} = CloudCmd;
         
-        const {
+        const {dir, name} = Info;
-            dir,
-            name,
-        } = Info;
         
         const {childNodes} = panel;
         let i = childNodes.length;
@@ -405,12 +370,13 @@ function CloudCmdProto(DOM) {
             panel.removeChild(panel.lastChild);
         
         panel.innerHTML = buildFromJSON({
-            sort        : options.sort,
+            sort: options.sort,
-            order       : options.order,
+            order: options.order,
             data,
-            id          : panel.id,
+            id: panel.id,
             prefix,
-            template    : {
+            showDotFiles,
+            template: {
                 file,
                 path,
                 pathLink,
@@ -450,9 +416,7 @@ function CloudCmdProto(DOM) {
         
         const path = parentDirPath;
         
-        await CloudCmd.loadDir({
+        await CloudCmd.changeDir(path);
-            path,
-        });
         
         const current = DOM.getCurrentByName(dir);
         const [first] = DOM.getFiles(panel);
@@ -462,4 +426,3 @@ function CloudCmdProto(DOM) {
         });
     };
 }
-

client/cloudcmd.js

@@ -1,42 +1,44 @@
-'use strict';
+import '../css/main.css';
-
+import process from 'node:process';
-require('../css/main.css');
+import wraptile from 'wraptile';
-require('../css/nojs.css');
+import load from 'load.js';
-require('../css/columns/name-size-date.css');
+import * as Util from '#common/util';
-require('../css/columns/name-size.css');
+import * as CloudFunc from '#common/cloudfunc';
-
+import DOM from '#dom';
-const wraptile = require('wraptile');
+import {registerSW, listenSW} from './sw/register.js';
-const load = require('load.js');
+import {initSortPanel, sortPanel} from './sort.js';
+import {createCloudCmd} from './client.js';
+import * as Listeners from './listeners/index.js';
 
 const isDev = process.env.NODE_ENV === 'development';
 
-const {
+export default init;
-    registerSW,
-    listenSW,
-} = require('./sw/register');
 
-// prevent additional loading of emitify
+globalThis.CloudCmd = init;
-window.Emitify = require('emitify');
 
-module.exports = window.CloudCmd = (config) => {
+async function init(config) {
-    window.Util = require('../common/util');
+    globalThis.CloudCmd = createCloudCmd({
-    window.CloudFunc = require('../common/cloudfunc');
+        DOM,
+        Listeners,
+    });
+    globalThis.DOM = DOM;
+    globalThis.Util = Util;
+    globalThis.CloudFunc = CloudFunc;
     
-    const DOM = require('./dom');
+    await register(config);
-    
-    window.DOM = DOM;
-    window.CloudCmd = require('./client');
-    
-    register(config);
-    
-    require('./listeners');
-    require('./key');
-    require('./sort');
     
+    initSortPanel();
+    globalThis.CloudCmd.sortPanel = sortPanel;
     const prefix = getPrefix(config.prefix);
     
-    window.CloudCmd.init(prefix, config);
+    globalThis.CloudCmd.init(prefix, config);
-};
+    
+    if (globalThis.CloudCmd.config('menu') === 'aleman')
+        setTimeout(() => {
+            import('https://esm.sh/@putout/processor-html');
+            import('https://esm.sh/@putout/bundle@5.5');
+        }, 100);
+}
 
 function getPrefix(prefix) {
     if (!prefix)
@@ -52,7 +54,7 @@ const onUpdateFound = wraptile(async (config) => {
     if (isDev)
         return;
     
-    const {DOM} = window;
+    const {DOM} = globalThis;
     const prefix = getPrefix(config.prefix);
     
     await load.js(`${prefix}/dist/cloudcmd.common.js`);
@@ -61,7 +63,7 @@ const onUpdateFound = wraptile(async (config) => {
     console.log('cloudcmd: sw: updated');
     
     DOM.Events.removeAll();
-    window.CloudCmd(config);
+    globalThis.CloudCmd(config);
 });
 
 async function register(config) {
@@ -70,4 +72,3 @@ async function register(config) {
     
     listenSW(sw, 'updatefound', onUpdateFound(config));
 }
-

client/dom/buffer.js

@@ -1,137 +1,124 @@
-'use strict';
+/* global CloudCmd*/
+import * as Storage from '#dom/storage';
+import tryToPromiseAll from '../../common/try-to-promise-all.js';
 
-/* global CloudCmd */
+const CLASS = 'cut-file';
+const COPY = 'copy';
+const CUT = 'cut';
 
-const tryToPromiseAll = require('../../common/try-to-promise-all');
+function showMessage(msg) {
-const Storage = require('./storage');
+    globalThis.DOM.Dialog.alert(msg);
-const DOM = require('./');
-
-module.exports = new BufferProto();
-
-function BufferProto() {
-    const Info = DOM.CurrentInfo;
-    const CLASS = 'cut-file';
-    const COPY = 'copy';
-    const CUT = 'cut';
-    const Buffer = {
-        cut     : callIfEnabled.bind(null, cut),
-        copy    : callIfEnabled.bind(null, copy),
-        clear   : callIfEnabled.bind(null, clear),
-        paste   : callIfEnabled.bind(null, paste),
-    };
-    
-    function showMessage(msg) {
-        DOM.Dialog.alert(msg);
-    }
-    
-    function getNames() {
-        const files = DOM.getActiveFiles();
-        const names = DOM.getFilenames(files);
-        
-        return names;
-    }
-    
-    function addCutClass() {
-        const files = DOM.getActiveFiles();
-        
-        for (const element of files) {
-            element.classList.add(CLASS);
-        }
-    }
-    
-    function rmCutClass() {
-        const files = DOM.getByClassAll(CLASS);
-        
-        for (const element of files) {
-            element.classList.remove(CLASS);
-        }
-    }
-    
-    function callIfEnabled(callback) {
-        const is = CloudCmd.config('buffer');
-        
-        if (is)
-            return callback();
-        
-        showMessage('Buffer disabled in config!');
-    }
-    
-    async function readBuffer() {
-        const [e, cp, ct] = await tryToPromiseAll([
-            Storage.get(COPY),
-            Storage.get(CUT),
-        ]);
-        
-        return [
-            e,
-            cp,
-            ct,
-        ];
-    }
-    
-    async function copy() {
-        const names = getNames();
-        const from = Info.dirPath;
-        
-        await clear();
-        
-        if (!names.length)
-            return;
-        
-        await Storage.remove(CUT);
-        await Storage.set(COPY, {
-            from,
-            names,
-        });
-    }
-    
-    async function cut() {
-        const names = getNames();
-        const from = Info.dirPath;
-        
-        await clear();
-        
-        if (!names.length)
-            return;
-        
-        addCutClass();
-        
-        await Storage.set(CUT, {
-            from,
-            names,
-        });
-    }
-    
-    async function clear() {
-        await Storage.remove(COPY);
-        await Storage.remove(CUT);
-        
-        rmCutClass();
-    }
-    
-    async function paste() {
-        const [error, cp, ct] = await readBuffer();
-        
-        if (error || !cp && !ct)
-            return showMessage(error || 'Buffer is empty!');
-        
-        const opStr = cp ? 'copy' : 'move';
-        const data = cp || ct;
-        const {Operation} = CloudCmd;
-        const msg = 'Path is same!';
-        const to = Info.dirPath;
-        
-        if (data.from === to)
-            return showMessage(msg);
-        
-        Operation.show(opStr, {
-            ...data,
-            to,
-        });
-        
-        await clear();
-    }
-    
-    return Buffer;
 }
 
+function getNames() {
+    const {DOM} = globalThis;
+    const files = DOM.getActiveFiles();
+    
+    return DOM.getFilenames(files);
+}
+
+function addCutClass() {
+    const {DOM} = globalThis;
+    const files = DOM.getActiveFiles();
+    
+    for (const element of files) {
+        element.classList.add(CLASS);
+    }
+}
+
+function rmCutClass() {
+    const {DOM} = globalThis;
+    const files = DOM.getByClassAll(CLASS);
+    
+    for (const element of files) {
+        element.classList.remove(CLASS);
+    }
+}
+
+const checkEnabled = (fn) => () => {
+    const is = CloudCmd.config('buffer');
+    
+    if (is)
+        return fn();
+    
+    showMessage('Buffer disabled in config!');
+};
+
+async function readBuffer() {
+    const [e, cp, ct] = await tryToPromiseAll([
+        Storage.getJson(COPY),
+        Storage.getJson(CUT),
+    ]);
+    
+    return [
+        e,
+        cp,
+        ct,
+    ];
+}
+
+export const copy = checkEnabled(async () => {
+    const Info = globalThis.DOM.CurrentInfo;
+    const names = getNames();
+    const from = Info.dirPath;
+    
+    await clear();
+    
+    if (!names.length)
+        return;
+    
+    await Storage.remove(CUT);
+    await Storage.setJson(COPY, {
+        from,
+        names,
+    });
+});
+
+export const cut = checkEnabled(async () => {
+    const Info = globalThis.DOM.CurrentInfo;
+    const names = getNames();
+    const from = Info.dirPath;
+    
+    await clear();
+    
+    if (!names.length)
+        return;
+    
+    addCutClass();
+    
+    await Storage.setJson(CUT, {
+        from,
+        names,
+    });
+});
+
+export const clear = checkEnabled(async () => {
+    await Storage.remove(COPY);
+    await Storage.remove(CUT);
+    
+    rmCutClass();
+});
+
+export const paste = checkEnabled(async () => {
+    const Info = globalThis.DOM.CurrentInfo;
+    const [error, cp, ct] = await readBuffer();
+    
+    if (error || !cp && !ct)
+        return showMessage(error || 'Buffer is empty!');
+    
+    const opStr = cp ? 'copy' : 'move';
+    const data = cp || ct;
+    const {Operation} = CloudCmd;
+    const msg = 'Path is same!';
+    const to = Info.dirPath;
+    
+    if (data.from === to)
+        return showMessage(msg);
+    
+    Operation.show(opStr, {
+        ...data,
+        to,
+    });
+    
+    await clear();
+});

client/dom/cmd.js

@@ -0,0 +1,83 @@
+/* global DOM */
+const SELECTED_FILE = 'selected-file';
+const Cmd = {
+    getSelectedFiles,
+    isSelected,
+    unselectFile,
+    selectFile,
+    selectAllFiles,
+    toggleSelectedFile,
+    toggleAllSelectedFiles,
+};
+
+/**
+ * selected file check
+ *
+ * @param currentFile
+ */
+export function isSelected(currentFile) {
+    if (!currentFile)
+        return false;
+    
+    return DOM.isContainClass(currentFile, SELECTED_FILE);
+}
+
+/**
+ * select current file
+ * @param currentFile
+ */
+export function selectFile(currentFile) {
+    const current = currentFile || DOM.getCurrentFile();
+    
+    current.classList.add(SELECTED_FILE);
+    
+    return Cmd;
+}
+
+export function unselectFile(currentFile) {
+    const current = currentFile || DOM.getCurrentFile();
+    
+    current.classList.remove(SELECTED_FILE);
+    
+    return Cmd;
+}
+
+export function toggleSelectedFile(currentFile) {
+    const current = currentFile || DOM.getCurrentFile();
+    const name = DOM.getCurrentName(current);
+    
+    if (name === '..')
+        return Cmd;
+    
+    current.classList.toggle(SELECTED_FILE);
+    
+    return Cmd;
+}
+
+export function toggleAllSelectedFiles() {
+    DOM
+        .getAllFiles()
+        .map(DOM.toggleSelectedFile);
+    
+    return Cmd;
+}
+
+export function selectAllFiles() {
+    DOM
+        .getAllFiles()
+        .map(DOM.selectFile);
+    
+    return Cmd;
+}
+
+/**
+ * unified way to get selected files
+ *
+ * @currentFile
+ */
+export function getSelectedFiles() {
+    const panel = DOM.getPanel();
+    const selected = DOM.getByClassAll(SELECTED_FILE, panel);
+    
+    return Array.from(selected);
+}

client/dom/current-file.js

@@ -1,28 +1,16 @@
-'use strict';
-
 /* global DOM */
 /* global CloudCmd */
-
+import createElement from '@cloudcmd/create-element';
-const btoa = require('../../common/btoa');
+import {getTitle, FS} from '#common/cloudfunc';
-const createElement = require('@cloudcmd/create-element');
+import {encode, decode} from '#common/entity';
-
-const {
-    encode,
-    decode,
-} = require('../../common/entity');
-
-const {
-    getTitle,
-    FS,
-} = require('../../common/cloudfunc');
 
 let Title;
 
 const CURRENT_FILE = 'current-file';
-const NBSP_REG = RegExp(String.fromCharCode(160), 'g');
+const encodeNBSP = (a) => a?.replace('\xa0', ' ');
-const SPACE = ' ';
+const decodeNBSP = (a) => a?.replace(' ', '\xa0');
 
-module.exports._CURRENT_FILE = CURRENT_FILE;
+export const _CURRENT_FILE = CURRENT_FILE;
 
 /**
  * set name from current (or param) file
@@ -30,7 +18,7 @@ module.exports._CURRENT_FILE = CURRENT_FILE;
  * @param name
  * @param current
  */
-module.exports.setCurrentName = (name, current) => {
+export const setCurrentName = (name, current) => {
     const Info = DOM.CurrentInfo;
     const {link} = Info;
     const {prefix} = CloudCmd;
@@ -41,7 +29,7 @@ module.exports.setCurrentName = (name, current) => {
     link.href = dir + encoded;
     link.innerHTML = encoded;
     
-    current.setAttribute('data-name', 'js-file-' + btoa(encodeURI(name)));
+    current.setAttribute('data-name', createNameAttribute(name));
     CloudCmd.emit('current-file', current);
     
     return link;
@@ -52,28 +40,48 @@ module.exports.setCurrentName = (name, current) => {
  *
  * @param currentFile
  */
-module.exports.getCurrentName = (currentFile) => {
+export const getCurrentName = (currentFile) => {
     const current = currentFile || DOM.getCurrentFile();
     
     if (!current)
         return '';
     
-    const link = DOM.getCurrentLink(current);
+    return parseNameAttribute(current.getAttribute('data-name'));
-    
-    if (!link)
-        return '';
-    
-    return decode(link.title)
-        .replace(NBSP_REG, SPACE);
 };
 
 /**
- * get current direcotory path
+ * Generate a `data-name` attribute for the given filename
+ * @param name The string name to encode
  */
-module.exports.getCurrentDirPath = (panel = DOM.getPanel()) => {
+const createNameAttribute = (name) => {
+    const encoded = btoa(encodeURI(name));
+    return `js-file-${encoded}`;
+};
+
+/**
+ * Parse a `data-name` attribute string back into the original filename
+ * @param attribute The string we wish to decode
+ */
+const parseNameAttribute = (attribute) => {
+    attribute = attribute.replace('js-file-', '');
+    return decodeNBSP(decodeURI(atob(attribute)));
+};
+
+export const _parseNameAttribute = parseNameAttribute;
+
+const parseHrefAttribute = (prefix, attribute) => {
+    attribute = attribute.replace(RegExp('^' + prefix + FS), '');
+    return decode(decodeNBSP(attribute));
+};
+
+export const _parseHrefAttribute = parseHrefAttribute;
+
+/**
+ * get current directory path
+ */
+export const getCurrentDirPath = (panel = DOM.getPanel()) => {
     const path = DOM.getByDataName('js-path', panel);
-    return path.textContent
+    return path.textContent;
-        .replace(NBSP_REG, SPACE);
 };
 
 /**
@@ -81,36 +89,31 @@ module.exports.getCurrentDirPath = (panel = DOM.getPanel()) => {
  *
  * @param currentFile - current file by default
  */
-module.exports.getCurrentPath = (currentFile) => {
+export const getCurrentPath = (currentFile) => {
     const current = currentFile || DOM.getCurrentFile();
     const [element] = DOM.getByTag('a', current);
     const {prefix} = CloudCmd;
     
-    const path = element
+    return parseHrefAttribute(prefix, element.getAttribute('href'));
-        .getAttribute('href')
-        .replace(RegExp('^' + prefix + FS), '')
-        .replace(NBSP_REG, SPACE);
-    
-    return decode(path);
 };
 
 /**
- * get current direcotory name
+ * get current directory name
  */
-module.exports.getCurrentDirName = () => {
+export const getCurrentDirName = () => {
-    const href = DOM.getCurrentDirPath()
+    const href = DOM
+        .getCurrentDirPath()
         .replace(/\/$/, '');
     
     const substr = href.substr(href, href.lastIndexOf('/'));
-    const ret = href.replace(substr + '/', '') || '/';
     
-    return ret;
+    return href.replace(`${substr}/`, '') || '/';
 };
 
 /**
- * get current direcotory path
+ * get current directory path
  */
-module.exports.getParentDirPath = (panel) => {
+export const getParentDirPath = (panel) => {
     const path = DOM.getCurrentDirPath(panel);
     const dirName = DOM.getCurrentDirName() + '/';
     const index = path.lastIndexOf(dirName);
@@ -122,9 +125,9 @@ module.exports.getParentDirPath = (panel) => {
 };
 
 /**
- * get not current direcotory path
+ * get not current directory path
  */
-module.exports.getNotCurrentDirPath = () => {
+export const getNotCurrentDirPath = () => {
     const panel = DOM.getPanel({
         active: false,
     });
@@ -137,20 +140,20 @@ module.exports.getNotCurrentDirPath = () => {
  *
  * @currentFile
  */
-module.exports.getCurrentFile = () => {
+export const getCurrentFile = () => {
     return DOM.getByClass(CURRENT_FILE);
 };
 
 /**
  * get current file by name
  */
-module.exports.getCurrentByName = (name, panel = DOM.CurrentInfo.panel) => {
+export const getCurrentByName = (name, panel = DOM.CurrentInfo.panel) => {
-    const dataName = 'js-file-' + btoa(encodeURI(name));
+    const dataName = 'js-file-' + btoa(encodeURI(encodeNBSP(name)));
     return DOM.getByDataName(dataName, panel);
 };
 
 /**
- * private function thet unset currentfile
+ * private function that unset currentFile
  *
  * @currentFile
  */
@@ -166,7 +169,7 @@ function unsetCurrentFile(currentFile) {
 /**
  * unified way to set current file
  */
-module.exports.setCurrentFile = (currentFile, options) => {
+export const setCurrentFile = (currentFile, options) => {
     const o = options;
     const currentFileWas = DOM.getCurrentFile();
     
@@ -195,7 +198,7 @@ module.exports.setCurrentFile = (currentFile, options) => {
          * but it should be false
          * to prevent default behavior
          */
-        if (!o || o.history !== false) {
+        if (!o || o.history) {
             const historyPath = path === '/' ? path : FS + path;
             DOM.setHistory(historyPath, null, historyPath);
         }
@@ -203,6 +206,7 @@ module.exports.setCurrentFile = (currentFile, options) => {
     
     /* scrolling to current file */
     const CENTER = true;
+    
     DOM.scrollIntoViewIfNeeded(currentFile, CENTER);
     
     CloudCmd.emit('current-file', currentFile);
@@ -212,7 +216,7 @@ module.exports.setCurrentFile = (currentFile, options) => {
     return DOM;
 };
 
-this.setCurrentByName = (name) => {
+export const setCurrentByName = (name) => {
     const current = DOM.getCurrentByName(name);
     return DOM.setCurrentFile(current);
 };
@@ -223,7 +227,7 @@ this.setCurrentByName = (name) => {
   * @param layer    - element
   * @param          - position {x, y}
   */
-module.exports.getCurrentByPosition = ({x, y}) => {
+export const getCurrentByPosition = ({x, y}) => {
     const element = document.elementFromPoint(x, y);
     
     const getEl = (el) => {
@@ -255,7 +259,7 @@ module.exports.getCurrentByPosition = ({x, y}) => {
  *
  * @param currentFile
  */
-module.exports.isCurrentFile = (currentFile) => {
+export const isCurrentFile = (currentFile) => {
     if (!currentFile)
         return false;
     
@@ -267,8 +271,7 @@ module.exports.isCurrentFile = (currentFile) => {
  *
  * @param name
  */
-
+export const setTitle = (name) => {
-module.exports.setTitle = (name) => {
     if (!Title)
         Title = DOM.getByTag('title')[0] || createElement('title', {
             innerHTML: name,
@@ -285,20 +288,24 @@ module.exports.setTitle = (name) => {
  *
  * @param currentFile
  */
-module.exports.isCurrentIsDir = (currentFile) => {
+export const isCurrentIsDir = (currentFile) => {
     const current = currentFile || DOM.getCurrentFile();
+    const path = DOM.getCurrentPath(current);
     const fileType = DOM.getCurrentType(current);
     
-    return /^directory(-link)?/.test(fileType);
+    const isZip = path.endsWith('.zip');
+    const isDir = /^directory(-link)?/.test(fileType);
+    
+    return isDir || isZip;
 };
 
-module.exports.getCurrentType = (currentFile) => {
+export const getCurrentType = (currentFile) => {
     const current = currentFile || DOM.getCurrentFile();
     const el = DOM.getByDataName('js-type', current);
+    
     const type = el.className
         .split(' ')
         .pop();
     
     return type;
 };
-

client/dom/current-file.spec.js

@@ -1,69 +1,72 @@
-'use strict';
+import {test, stub} from 'supertape';
+import {create} from 'auto-globals';
+import wraptile from 'wraptile';
+import * as currentFile from './current-file.js';
 
-const test = require('supertape');
-const {create} = require('auto-globals');
-const stub = require('@cloudcmd/stub');
 const id = (a) => a;
-const wraptile = require('wraptile');
-const returns = wraptile(id);
 
-const currentFile = require('./current-file');
+const returns = wraptile(id);
 const {_CURRENT_FILE} = currentFile;
 
 test('current-file: setCurrentName: setAttribute', (t) => {
-    const {
+    const {DOM, CloudCmd} = globalThis;
-        DOM,
-        CloudCmd,
-    } = global;
     
-    global.DOM = getDOM();
+    globalThis.DOM = getDOM();
-    global.CloudCmd = getCloudCmd();
+    globalThis.CloudCmd = getCloudCmd();
     
     const current = create();
     const {setAttribute} = current;
     
     currentFile.setCurrentName('hello', current);
     
-    t.ok(setAttribute.calledWith('data-name', 'js-file-aGVsbG8='), 'should call setAttribute');
+    globalThis.DOM = DOM;
-    
+    globalThis.CloudCmd = CloudCmd;
-    global.DOM = DOM;
-    global.CloudCmd = CloudCmd;
     
+    t.calledWith(setAttribute, [
+        'data-name',
+        'js-file-aGVsbG8=',
+    ], 'should call setAttribute');
     t.end();
 });
 
 test('current-file: setCurrentName: setAttribute: cyrillic', (t) => {
-    const {
+    const {DOM, CloudCmd} = globalThis;
-        DOM,
-        CloudCmd,
-    } = global;
     
-    global.DOM = getDOM();
+    globalThis.DOM = getDOM();
-    global.CloudCmd = getCloudCmd();
+    globalThis.CloudCmd = getCloudCmd();
     
     const current = create();
     const {setAttribute} = current;
     
     currentFile.setCurrentName('ай', current);
     
-    t.ok(setAttribute.calledWith('data-name', 'js-file-JUQwJUIwJUQwJUI5'), 'should call setAttribute');
+    globalThis.DOM = DOM;
+    globalThis.CloudCmd = CloudCmd;
     
-    global.DOM = DOM;
+    t.calledWith(setAttribute, [
-    global.CloudCmd = CloudCmd;
+        'data-name',
+        'js-file-JUQwJUIwJUQwJUI5',
+    ], 'should call setAttribute');
+    t.end();
+});
+
+test('current-file: getCurrentName', (t) => {
+    const current = create();
+    current.getAttribute.returns('js-file-Ymlu');
     
+    const result = currentFile.getCurrentName(current);
+    
+    t.equal(result, 'bin');
     t.end();
 });
 
 test('current-file: emit', (t) => {
-    const {
+    const {DOM, CloudCmd} = globalThis;
-        DOM,
-        CloudCmd,
-    } = global;
     
     const emit = stub();
     
-    global.DOM = getDOM();
+    globalThis.DOM = getDOM();
-    global.CloudCmd = getCloudCmd({
+    globalThis.CloudCmd = getCloudCmd({
         emit,
     });
     
@@ -71,47 +74,41 @@ test('current-file: emit', (t) => {
     
     currentFile.setCurrentName('hello', current);
     
-    t.ok(emit.calledWith('current-file', current), 'should call emit');
+    globalThis.DOM = DOM;
-    
+    globalThis.CloudCmd = CloudCmd;
-    global.DOM = DOM;
-    global.CloudCmd = CloudCmd;
     
+    t.calledWith(emit, ['current-file', current], 'should call emit');
     t.end();
 });
 
 test('current-file: setCurrentName: return', (t) => {
-    const {
+    const {DOM, CloudCmd} = globalThis;
-        DOM,
-        CloudCmd,
-    } = global;
     
     const link = {};
     
-    global.DOM = getDOM({
+    globalThis.DOM = getDOM({
         link,
     });
     
-    global.CloudCmd = getCloudCmd();
+    globalThis.CloudCmd = getCloudCmd();
     
     const current = create();
-    
     const result = currentFile.setCurrentName('hello', current);
     
+    globalThis.DOM = DOM;
+    globalThis.CloudCmd = CloudCmd;
+    
     t.equal(result, link, 'should return link');
-    
-    global.DOM = DOM;
-    global.CloudCmd = CloudCmd;
-    
     t.end();
 });
 
 test('current-file: getParentDirPath: result', (t) => {
-    const {DOM} = global;
+    const {DOM} = globalThis;
     
     const getCurrentDirPath = returns('/D/Films/+++favorite films/');
     const getCurrentDirName = returns('+++favorite films');
     
-    global.DOM = getDOM({
+    globalThis.DOM = getDOM({
         getCurrentDirPath,
         getCurrentDirName,
     });
@@ -119,65 +116,55 @@ test('current-file: getParentDirPath: result', (t) => {
     const result = currentFile.getParentDirPath();
     const expected = '/D/Films/';
     
-    global.DOM = DOM;
+    globalThis.DOM = DOM;
     
     t.equal(result, expected, 'should return parent dir path');
     t.end();
 });
 
 test('current-file: isCurrentFile: no', (t) => {
-    const {
+    const {DOM, CloudCmd} = globalThis;
-        DOM,
-        CloudCmd,
-    } = global;
     
-    global.DOM = getDOM();
+    globalThis.DOM = getDOM();
-    global.CloudCmd = getCloudCmd();
+    globalThis.CloudCmd = getCloudCmd();
     
     const result = currentFile.isCurrentFile();
-    const expect = false;
     
-    global.DOM = DOM;
+    globalThis.DOM = DOM;
-    global.CloudCmd = CloudCmd;
+    globalThis.CloudCmd = CloudCmd;
     
-    t.equal(result, expect, 'should equal');
+    t.notOk(result);
     t.end();
 });
 
 test('current-file: isCurrentFile', (t) => {
-    const {
+    const {DOM, CloudCmd} = globalThis;
-        DOM,
-        CloudCmd,
-    } = global;
     
     const isContainClass = stub();
     
-    global.DOM = getDOM({
+    globalThis.DOM = getDOM({
         isContainClass,
     });
     
-    global.CloudCmd = getCloudCmd();
+    globalThis.CloudCmd = getCloudCmd();
     
     const current = {};
     currentFile.isCurrentFile(current);
     
-    global.DOM = DOM;
+    globalThis.DOM = DOM;
-    global.CloudCmd = CloudCmd;
+    globalThis.CloudCmd = CloudCmd;
     
-    t.ok(isContainClass.calledWith(current, _CURRENT_FILE), 'should call isContainClass');
+    t.calledWith(isContainClass, [current, _CURRENT_FILE], 'should call isContainClass');
     t.end();
 });
 
 test('current-file: getCurrentType', (t) => {
-    const {
+    const {DOM, CloudCmd} = globalThis;
-        DOM,
-        CloudCmd,
-    } = global;
     
-    global.DOM = getDOM();
+    globalThis.DOM = getDOM();
-    global.CloudCmd = getCloudCmd();
+    globalThis.CloudCmd = getCloudCmd();
     
-    const {getByDataName} = global.DOM;
+    const {getByDataName} = globalThis.DOM;
     
     getByDataName.returns({
         className: 'mini-icon directory',
@@ -187,122 +174,129 @@ test('current-file: getCurrentType', (t) => {
     
     currentFile.getCurrentType(current);
     
-    global.DOM = DOM;
+    globalThis.DOM = DOM;
-    global.CloudCmd = CloudCmd;
+    globalThis.CloudCmd = CloudCmd;
     
-    t.ok(getByDataName.calledWith('js-type', current));
+    t.calledWith(getByDataName, ['js-type', current]);
     t.end();
 });
 
 test('current-file: isCurrentIsDir: getCurrentType', (t) => {
-    const {
+    const {DOM, CloudCmd} = globalThis;
-        DOM,
-        CloudCmd,
-    } = global;
     
-    global.DOM = getDOM();
+    globalThis.DOM = getDOM();
-    global.CloudCmd = getCloudCmd();
+    globalThis.CloudCmd = getCloudCmd();
     
-    const {getCurrentType} = global.DOM;
+    const {getCurrentType} = globalThis.DOM;
     
     const current = create();
     
     currentFile.isCurrentIsDir(current);
     
-    global.DOM = DOM;
+    globalThis.DOM = DOM;
-    global.CloudCmd = CloudCmd;
+    globalThis.CloudCmd = CloudCmd;
     
-    t.ok(getCurrentType.calledWith(current));
+    t.calledWith(getCurrentType, [current]);
     t.end();
 });
 
 test('current-file: isCurrentIsDir: directory', (t) => {
-    const {
+    const {DOM, CloudCmd} = globalThis;
-        DOM,
-        CloudCmd,
-    } = global;
     
-    global.DOM = getDOM({
+    globalThis.DOM = getDOM({
         getCurrentType: stub().returns('directory'),
     });
     
-    global.CloudCmd = getCloudCmd();
+    globalThis.CloudCmd = getCloudCmd();
     
     const current = create();
     
     const result = currentFile.isCurrentIsDir(current);
     
-    global.DOM = DOM;
+    globalThis.DOM = DOM;
-    global.CloudCmd = CloudCmd;
+    globalThis.CloudCmd = CloudCmd;
     
     t.ok(result);
     t.end();
 });
 
 test('current-file: isCurrentIsDir: directory-link', (t) => {
-    const {
+    const {DOM, CloudCmd} = globalThis;
-        DOM,
-        CloudCmd,
-    } = global;
     
-    global.DOM = getDOM({
+    globalThis.DOM = getDOM({
         getCurrentType: stub().returns('directory-link'),
     });
     
-    global.CloudCmd = getCloudCmd();
+    globalThis.CloudCmd = getCloudCmd();
     
     const current = create();
     
     const result = currentFile.isCurrentIsDir(current);
     
-    global.DOM = DOM;
+    globalThis.DOM = DOM;
-    global.CloudCmd = CloudCmd;
+    globalThis.CloudCmd = CloudCmd;
     
     t.ok(result);
     t.end();
 });
 
 test('current-file: isCurrentIsDir: file', (t) => {
-    const {
+    const {DOM, CloudCmd} = globalThis;
-        DOM,
-        CloudCmd,
-    } = global;
     
-    global.DOM = getDOM({
+    globalThis.DOM = getDOM({
         getCurrentType: stub().returns('file'),
     });
     
-    global.CloudCmd = getCloudCmd();
+    globalThis.CloudCmd = getCloudCmd();
     
     const current = create();
     
     const result = currentFile.isCurrentIsDir(current);
     
-    global.DOM = DOM;
+    globalThis.DOM = DOM;
-    global.CloudCmd = CloudCmd;
+    globalThis.CloudCmd = CloudCmd;
     
     t.notOk(result);
     t.end();
 });
 
-function getCloudCmd({emit} = {}) {
+const getCloudCmd = ({emit} = {}) => ({
-    return {
+    prefix: '',
-        prefix: '',
+    emit: emit || stub(),
-        emit: emit || stub(),
+});
-    };
-}
 
-function getDOM({
+test('current-file: parseNameAttribute', (t) => {
-    link = {},
+    const result = currentFile._parseNameAttribute('js-file-aGVsbG8mbmJzcDt3b3JsZA==');
-    getCurrentDirPath = stub(),
+    const expected = 'hello\xa0world';
-    getCurrentDirName = stub(),
+    
-    getByDataName = stub(),
+    t.equal(result, expected);
-    isContainClass = stub(),
+    t.end();
-    getCurrentType = stub(),
+});
-} = {}) {
+
+test('current-file: parseHrefAttribute', (t) => {
+    const prefix = '/api/v1';
+    const result = currentFile._parseHrefAttribute(prefix, '/api/v1/fs/hello world');
+    const expected = '/hello\xa0world';
+    
+    t.equal(result, expected);
+    t.end();
+});
+
+function getDOM(overrides = {}) {
+    const {
+        link = {},
+        getCurrentDirPath = stub(),
+        getCurrentDirName = stub(),
+        getByDataName = stub(),
+        isContainClass = stub(),
+        getCurrentType = stub(),
+        getCurrentPath = stub().returns(''),
+    } = overrides;
+    
     return {
         getCurrentDirPath,
         getCurrentDirName,
+        getCurrentPath,
         getByDataName,
         isContainClass,
         getCurrentType,
@@ -312,4 +306,3 @@ function getDOM({
         },
     };
 }
-

client/dom/dialog.js

@@ -1,27 +1,18 @@
-'use strict';
+import {tryToCatch} from 'try-to-catch';
-
+import * as smalltalk from 'smalltalk';
-const tryToCatch = require('try-to-catch');
-
-const {
-    alert,
-    prompt,
-    confirm,
-    progress,
-} = require('smalltalk');
 
 const title = 'Cloud Commander';
 
-module.exports.alert = (...a) => alert(title, ...a, {
+export const alert = (...a) => smalltalk.alert(title, ...a, {
     cancel: false,
 });
 
-module.exports.prompt = (...a) => tryToCatch(prompt, title, ...a);
+export const prompt = (...a) => tryToCatch(smalltalk.prompt, title, ...a);
-module.exports.confirm = (...a) => tryToCatch(confirm, title, ...a);
+export const confirm = (...a) => tryToCatch(smalltalk.confirm, title, ...a);
-module.exports.progress = (...a) => progress(title, ...a);
+export const progress = (...a) => smalltalk.progress(title, ...a);
 
-module.exports.alert.noFiles = () => {
+alert.noFiles = () => {
-    return alert(title, 'No files selected!', {
+    return smalltalk.alert(title, 'No files selected!', {
         cancel: false,
     });
 };
-

client/dom/directory.js

@@ -1,27 +1,19 @@
-'use strict';
+/* global DOM, CloudCmd */
+import philip from 'philip';
+import * as Dialog from '#dom/dialog';
+import {FS} from '#common/cloudfunc';
+import * as Images from '#dom/images';
 
-/* global CloudCmd */
+export const uploadDirectory = (items) => {
-
-const philip = require('philip');
-
-const Images = require('./images');
-const {FS} = require('../../common/cloudfunc');
-const DOM = require('.');
-const Dialog = require('./dialog');
-
-const {getCurrentDirPath: getPathWhenRootEmpty} = DOM;
-
-module.exports = (items) => {
     if (items.length)
         Images.show('top');
     
-    const entries = Array.from(items).map((item) => {
+    const entries = Array
-        return item.webkitGetAsEntry();
+        .from(items)
-    });
+        .map((item) => item.webkitGetAsEntry());
     
-    const dirPath = getPathWhenRootEmpty();
+    const dirPath = DOM.getCurrentDirPath();
-    const path = dirPath
+    const path = dirPath.replace(/\/$/, '');
-        .replace(/\/$/, '');
     
     const progress = Dialog.progress('Uploading...');
     
@@ -65,15 +57,8 @@ module.exports = (items) => {
     uploader.on('end', CloudCmd.refresh);
 };
 
-function percent(i, n, per = 100) {
+const percent = (i, n, per = 100) => Math.round(i * per / n);
-    return Math.round(i * per / n);
-}
 
-function uploadFile(url, data) {
+const uploadFile = (url, data) => DOM.load.put(url, data);
-    return DOM.load.put(url, data);
-}
-
-function uploadDir(url) {
-    return DOM.load.put(url + '?dir');
-}
 
+const uploadDir = (url) => DOM.load.put(`${url}?dir`);

client/dom/dom-tree.js

@@ -1,8 +1,15 @@
-'use strict';
+import currify from 'currify';
 
-const currify = require('currify');
+const DOM = {
-
+    show,
-const DOM = module.exports;
+    hide,
+    getByClass,
+    getByClassAll,
+    getByDataName,
+    getById,
+    getByTag,
+    isContainClass,
+};
 
 /**
  * check class of element
@@ -10,7 +17,7 @@ const DOM = module.exports;
  * @param element
  * @param className
  */
-const isContainClass = (element, className) => {
+export function isContainClass(element, className) {
     if (!element)
         throw Error('element could not be empty!');
     
@@ -18,67 +25,68 @@ const isContainClass = (element, className) => {
         throw Error('className could not be empty!');
     
     if (Array.isArray(className))
-        return className.some(currify(isContainClass, element));
+        return className.some(currify(
+            isContainClass,
+            element,
+        ));
     
     const {classList} = element;
     
     return classList.contains(className);
-};
+}
-
-module.exports.isContainClass = isContainClass;
 
 /**
  * Function search element by tag
  * @param tag - className
  * @param element - element
  */
-module.exports.getByTag = (tag, element = document) => {
+export function getByTag(tag, element = document) {
     return element.getElementsByTagName(tag);
-};
+}
 
 /**
  * Function search element by id
- * @param Id - id
+ * @param id
+ * @param element
  */
-module.exports.getById = (id, element = document) => {
+export function getById(id, element = document) {
-    return element.querySelector('#' + id);
+    return element.querySelector(`#${id}`);
-};
+}
 
 /**
  * Function search first element by class name
  * @param className - className
  * @param element - element
  */
-module.exports.getByClass = (className, element = document) => {
+export function getByClass(className, element = document) {
     return DOM.getByClassAll(className, element)[0];
-};
+}
 
-module.exports.getByDataName = (attribute, element = document) => {
+export function getByDataName(attribute, element = document) {
     const selector = '[' + 'data-name="' + attribute + '"]';
     return element.querySelector(selector);
-};
+}
 
 /**
  * Function search element by class name
- * @param pClass - className
+ * @param className
- * @param element - element
+ * @param element
  */
-module.exports.getByClassAll = (className, element) => {
+export function getByClassAll(className, element) {
     return (element || document).getElementsByClassName(className);
-};
+}
 
 /**
  * add class=hidden to element
  *
  * @param element
  */
-module.exports.hide = (element) => {
+export function hide(element) {
     element.classList.add('hidden');
     return DOM;
-};
+}
 
-module.exports.show = (element) => {
+export function show(element) {
     element.classList.remove('hidden');
     return DOM;
-};
+}
-

client/dom/dom-tree.spec.js

@@ -1,19 +1,27 @@
-'use strict';
+import {test, stub} from 'supertape';
-
+import {create} from 'auto-globals';
-const test = require('supertape');
+import {tryCatch} from 'try-catch';
-const {create} = require('auto-globals');
+import {
-const tryCatch = require('try-catch');
+    isContainClass,
-
+    getByTag,
-const {isContainClass} = require('./dom-tree');
+    getById,
+    getByClass,
+    getByDataName,
+    getByClassAll,
+    hide,
+    show,
+} from './dom-tree.js';
 
 test('dom: isContainClass: no element', (t) => {
     const [e] = tryCatch(isContainClass);
+    
     t.equal(e.message, 'element could not be empty!', 'should throw when no element');
     t.end();
 });
 
 test('dom: isContainClass: no className', (t) => {
     const [e] = tryCatch(isContainClass, {});
+    
     t.equal(e.message, 'className could not be empty!', 'should throw when no element');
     t.end();
 });
@@ -25,7 +33,7 @@ test('dom: isContainClass: contains', (t) => {
     const className = 'hello';
     isContainClass(el, className);
     
-    t.ok(contains.calledWith(className), 'should call contains');
+    t.calledWith(contains, [className], 'should call contains');
     t.end();
 });
 
@@ -34,13 +42,111 @@ test('dom: isContainClass: contains: array', (t) => {
     const {contains} = el.classList;
     
     const className = 'hello';
-    isContainClass(el, [
+    isContainClass(el, ['world', className, 'hello']);
-        'world',
-        className,
-        'hello',
-    ]);
     
-    t.ok(contains.calledWith(className), 'should call contains');
+    t.calledWith(contains, [className], 'should call contains');
     t.end();
 });
 
+test('dom: getByTag', (t) => {
+    const getElementsByTagName = stub();
+    const element = {
+        getElementsByTagName,
+    };
+    
+    getByTag('div', element);
+    
+    t.calledWith(getElementsByTagName, ['div'], 'should call getElementsByTagName');
+    t.end();
+});
+
+test('dom: getById', (t) => {
+    const querySelector = stub();
+    const element = {
+        querySelector,
+    };
+    
+    getById('my-id', element);
+    
+    t.calledWith(querySelector, ['#my-id'], 'should call querySelector with id selector');
+    t.end();
+});
+
+test('dom: getByClassAll', (t) => {
+    const getElementsByClassName = stub();
+    const element = {
+        getElementsByClassName,
+    };
+    
+    getByClassAll('my-class', element);
+    
+    t.calledWith(getElementsByClassName, ['my-class'], 'should call getElementsByClassName');
+    t.end();
+});
+
+test('dom: getByClass: calls getByClassAll', (t) => {
+    const element = {
+        getElementsByClassName: stub().returns(['first']),
+    };
+    
+    const result = getByClass('my-class', element);
+    
+    t.equal(result, 'first', 'should return first element from class list');
+    t.end();
+});
+
+test('dom: getByDataName', (t) => {
+    const querySelector = stub();
+    const element = {
+        querySelector,
+    };
+    
+    getByDataName('hello', element);
+    
+    t.calledWith(querySelector, ['[data-name="hello"]'], 'should call querySelector with data-name selector');
+    t.end();
+});
+
+test('dom: hide', (t) => {
+    const add = stub();
+    const element = {
+        classList: {
+            add,
+        },
+    };
+    
+    hide(element);
+    
+    t.calledWith(add, ['hidden'], 'should add hidden class');
+    t.end();
+});
+
+test('dom: show', (t) => {
+    const remove = stub();
+    const element = {
+        classList: {
+            remove,
+        },
+    };
+    
+    show(element);
+    
+    t.calledWith(remove, ['hidden'], 'should remove hidden class');
+    t.end();
+});
+
+test('dom: getByClassAll: without element uses document', (t) => {
+    const getElementsByClassName = stub();
+    const prevDocument = globalThis.document;
+    
+    globalThis.document = {
+        getElementsByClassName,
+    };
+    
+    getByClassAll('my-class');
+    
+    globalThis.document = prevDocument;
+    
+    t.calledWith(getElementsByClassName, ['my-class'], 'should fallback to document when no element');
+    t.end();
+});

client/dom/events/event-store.js

@@ -1,8 +1,6 @@
-'use strict';
-
 let list = [];
 
-module.exports.add = (el, name, fn) => {
+export const add = (el, name, fn) => {
     list.push([
         el,
         name,
@@ -10,11 +8,8 @@ module.exports.add = (el, name, fn) => {
     ]);
 };
 
-module.exports.clear = () => {
+export const clear = () => {
     list = [];
 };
 
-module.exports.get = () => {
+export const get = () => list;
-    return list;
-};
-

client/dom/events/event-store.spec.js

@@ -1,7 +1,5 @@
-'use strict';
+import {test} from 'supertape';
-
+import * as eventStore from './event-store.js';
-const test = require('supertape');
-const eventStore = require('./event-store');
 
 test('event-store: get', (t) => {
     const el = {};
@@ -10,11 +8,16 @@ test('event-store: get', (t) => {
     
     eventStore.add(el, name, fn);
     const result = eventStore.get();
+    
     const expected = [
-        [el, name, fn],
+        [
+            el,
+            name,
+            fn,
+        ],
     ];
     
-    t.deepEqual(expected, result, 'should equal');
+    t.deepEqual(result, expected);
     t.end();
 });
 
@@ -29,6 +32,6 @@ test('event-store: clear', (t) => {
     const result = eventStore.get();
     const expected = [];
     
-    t.deepEqual(expected, result, 'should equal');
+    t.deepEqual(result, expected);
     t.end();
 });

client/dom/events/index.js

@@ -1,250 +1,203 @@
-'use strict';
+import itype from 'itype';
+import * as EventStore from './event-store.js';
 
-const itype = require('itype');
+/**
-const EventStore = require('./event-store');
+ * safe add event listener
-
+ *
-module.exports = new EventsProto();
+ * @param type
-
+ * @param element - document by default
-function EventsProto() {
+ * @param listener
-    const Events = this;
+ */
+export const add = (type, element, listener) => {
+    checkType(type);
     
-    const getEventOptions = (eventName) => {
+    parseArgs(type, element, listener, (element, args) => {
-        if (eventName !== 'touchstart')
+        const [name, fn, options] = args;
-            return false;
         
-        return {
+        element.addEventListener(name, fn, options);
-            passive: true,
+        EventStore.add(element, name, fn);
-        };
+    });
+    
+    return Events;
+};
+
+/**
+ * safe add event listener
+ *
+ * @param type
+ * @param listener
+ * @param element - document by default
+ */
+export const addOnce = (type, element, listener) => {
+    const once = (event) => {
+        Events.remove(type, element, once);
+        listener(event);
     };
     
-    function parseArgs(eventName, element, listener, callback) {
+    if (!listener) {
-        let isFunc;
+        listener = element;
-        const args = [
+        element = null;
-            eventName,
-            element,
-            listener,
-            callback,
-        ];
-        
-        const EVENT_NAME = 1;
-        const ELEMENT = 0;
-        const type = itype(eventName);
-        
-        switch(type) {
-        default:
-            if (!/element$/.test(type))
-                throw Error('unknown eventName: ' + type);
-            
-            parseArgs(
-                args[EVENT_NAME],
-                args[ELEMENT],
-                listener,
-                callback,
-            );
-            break;
-        
-        case 'string':
-            isFunc = itype.function(element);
-            
-            if (isFunc) {
-                listener = element;
-                element = null;
-            }
-            
-            if (!element)
-                element = window;
-            
-            callback(element, [
-                eventName,
-                listener,
-                getEventOptions(eventName),
-            ]);
-            break;
-        
-        case 'array':
-            for (const name of eventName) {
-                parseArgs(
-                    name,
-                    element,
-                    listener,
-                    callback,
-                );
-            }
-            
-            break;
-        
-        case 'object':
-            for (const name of Object.keys(eventName)) {
-                const eventListener = eventName[name];
-                
-                parseArgs(
-                    name,
-                    element,
-                    eventListener,
-                    callback,
-                );
-            }
-            
-            break;
-        }
     }
     
-    /**
+    add(type, element, once);
-     * safe add event listener
-     *
-     * @param type
-     * @param element {document by default}
-     * @param listener
-     */
-    this.add = (type, element, listener) => {
-        checkType(type);
-        
-        parseArgs(type, element, listener, (element, args) => {
-            const [name, fn, options] = args;
-            
-            element.addEventListener(name, fn, options);
-            EventStore.add(element, name, fn);
-        });
-        
-        return Events;
-    };
     
-    /**
+    return Events;
-     * safe add event listener
+};
-     *
+
-     * @param type
+/**
-     * @param listener
+ * safe remove event listener
-     * @param element {document by default}
+ *
-     */
+ * @param type
-    this.addOnce = (type, element, listener) => {
+ * @param listener
-        const once = (event) => {
+ * @param element - document by default
-            Events.remove(type, element, once);
+ */
-            listener(event);
+export const remove = (type, element, listener) => {
-        };
+    checkType(type);
+    
+    parseArgs(type, element, listener, (element, args) => {
+        element.removeEventListener(...args);
+    });
+    
+    return Events;
+};
+
+/**
+ * remove all added event listeners
+ */
+export const removeAll = () => {
+    const events = EventStore.get();
+    
+    for (const [el, name, fn] of events)
+        el.removeEventListener(name, fn);
+    
+    EventStore.clear();
+};
+
+/**
+ * safe add event keydown listener
+ *
+ * @param args
+ */
+export const addKey = function(...args) {
+    return add('keydown', ...args);
+};
+
+/**
+ * safe remove event click listener
+ *
+ * @param args
+ */
+export const rmKey = function(...args) {
+    return Events.remove('keydown', ...args);
+};
+
+/**
+ * safe add event click listener
+ */
+export const addClick = function(...args) {
+    return Events.add('click', ...args);
+};
+
+/**
+ * safe remove event click listener
+ */
+export const rmClick = function(...args) {
+    return remove('click', ...args);
+};
+
+export const addContextMenu = function(...args) {
+    return add('contextmenu', ...args);
+};
+
+/**
+ * safe add load listener
+ */
+export const addLoad = function(...args) {
+    return add('load', ...args);
+};
+
+function checkType(type) {
+    if (!type)
+        throw Error('type could not be empty!');
+}
+
+const getEventOptions = (eventName) => {
+    if (eventName !== 'touchstart')
+        return false;
+    
+    return {
+        passive: true,
+    };
+};
+
+function parseArgs(eventName, element, listener, callback) {
+    let isFunc;
+    const args = [
+        eventName,
+        element,
+        listener,
+        callback,
+    ];
+    
+    const EVENT_NAME = 1;
+    const ELEMENT = 0;
+    const type = itype(eventName);
+    
+    switch(type) {
+    default:
+        if (!type.endsWith('element'))
+            throw Error(`unknown eventName: ${type}`);
         
-        if (!listener) {
+        parseArgs(args[EVENT_NAME], args[ELEMENT], listener, callback);
+        break;
+    
+    case 'string':
+        isFunc = itype.function(element);
+        
+        if (isFunc) {
             listener = element;
             element = null;
         }
         
-        this.add(type, element, once);
+        if (!element)
+            element = window;
         
-        return Events;
+        callback(element, [
-    };
+            eventName,
+            listener,
+            getEventOptions(eventName),
+        ]);
+        break;
     
-    /**
+    case 'array':
-     * safe remove event listener
-     *
-     * @param type
-     * @param listener
-     * @param element {document by default}
-     */
-    this.remove = (type, element, listener) => {
-        checkType(type);
         
-        parseArgs(type, element, listener, (element, args) => {
+        for (const name of eventName) {
-            element.removeEventListener(...args);
+            parseArgs(name, element, listener, callback);
-        });
+        }
         
-        return Events;
+        break;
-    };
     
-    /**
+    case 'object':
-     * remove all added event listeners
-     *
-     * @param listener
-     */
-    this.removeAll = () => {
-        const events = EventStore.get();
         
-        for (const [el, name, fn] of events)
+        for (const name of Object.keys(eventName)) {
-            el.removeEventListener(name, fn);
+            const eventListener = eventName[name];
+            
+            parseArgs(name, element, eventListener, callback);
+        }
         
-        EventStore.clear();
+        break;
-    };
-    
-    /**
-     * safe add event keydown listener
-     *
-     * @param listener
-     */
-    this.addKey = function(...argsArr) {
-        const name = 'keydown';
-        const args = [name, ...argsArr];
-        
-        return Events.add(...args);
-    };
-    
-    /**
-     * safe remove event click listener
-     *
-     * @param listener
-     */
-    this.rmKey = function(...argsArr) {
-        const name = 'keydown';
-        const args = [name, ...argsArr];
-        
-        return Events.remove(...args);
-    };
-    
-    /**
-     * safe add event click listener
-     *
-     * @param listener
-     */
-    this.addClick = function(...argsArr) {
-        const name = 'click';
-        const args = [name, ...argsArr];
-        
-        return Events.add(...args);
-    };
-    
-    /**
-     * safe remove event click listener
-     *
-     * @param listener
-     */
-    this.rmClick = function(...argsArr) {
-        const name = 'click';
-        const args = [name, ...argsArr];
-        
-        return Events.remove(...args);
-    };
-    
-    this.addContextMenu = function(...argsArr) {
-        const name = 'contextmenu';
-        const args = [name, ...argsArr];
-        
-        return Events.add(...args);
-    };
-    
-    /**
-     * safe add event click listener
-     *
-     * @param listener
-     */
-    this.addError = function(...argsArr) {
-        const name = 'error';
-        const args = [name, ...argsArr];
-        
-        return Events.add(...args);
-    };
-    
-    /**
-     * safe add load click listener
-     *
-     * @param listener
-     */
-    this.addLoad = function(...argsArr) {
-        const name = 'load';
-        const args = [name, ...argsArr];
-        
-        return Events.add(...args);
-    };
-    
-    function checkType(type) {
-        if (!type)
-            throw Error('type could not be empty!');
     }
 }
 
+const Events = {
+    add,
+    addClick,
+    addContextMenu,
+    addKey,
+    addLoad,
+    addOnce,
+    remove,
+    removeAll,
+    rmClick,
+    rmKey,
+};

client/dom/files.js

@@ -1,37 +1,29 @@
 /* global CloudCmd */
-
+import itype from 'itype';
-'use strict';
+import {promisify} from 'es6-promisify';
-
+import * as load from '#dom/load';
-const itype = require('itype');
+import * as RESTful from '#dom/rest';
-const currify = require('currify');
-const {promisify} = require('es6-promisify');
-
-const load = require('./load');
-const RESTful = require('./rest');
 
 const Promises = {};
 const FILES_JSON = 'config|modules';
 const FILES_HTML = 'file|path|link|pathLink|media';
 const FILES_HTML_ROOT = 'view/media-tmpl|config-tmpl|upload';
 const DIR_HTML = '/tmpl/';
-const DIR_HTML_FS = DIR_HTML + 'fs/';
+const DIR_HTML_FS = `${DIR_HTML}fs/`;
 const DIR_JSON = '/json/';
 const timeout = getTimeoutOnce(2000);
 
-const get = currify(getFile);
+export const get = getFile;
-const unaryMap = (array, fn) => array.map((a) => fn(a));
 
-module.exports.get = get;
+function getFile(name) {
-
-async function getFile(name) {
     const type = itype(name);
     check(name);
     
     if (type === 'string')
-        return await getModule(name);
+        return getModule(name);
     
     if (type === 'array')
-        return Promise.all(unaryMap(name, get));
+        return Promise.all(name.map(getFile));
 }
 
 function check(name) {
@@ -39,9 +31,9 @@ function check(name) {
         throw Error('name could not be empty!');
 }
 
-async function getModule(name) {
+function getModule(name) {
-    const regExpHTML = new RegExp(FILES_HTML + '|' + FILES_HTML_ROOT);
+    const regExpHTML = RegExp(FILES_HTML + '|' + FILES_HTML_ROOT);
-    const regExpJSON = new RegExp(FILES_JSON);
+    const regExpJSON = RegExp(FILES_JSON);
     
     const isHTML = regExpHTML.test(name);
     const isJSON = regExpJSON.test(name);
@@ -53,12 +45,13 @@ async function getModule(name) {
         return getConfig();
     
     const path = getPath(name, isHTML, isJSON);
+    
     return getSystemFile(path);
 }
 
 function getPath(name, isHTML, isJSON) {
     let path;
-    const regExp = new RegExp(FILES_HTML_ROOT);
+    const regExp = RegExp(FILES_HTML_ROOT);
     const isRoot = regExp.test(name);
     
     if (isHTML) {
@@ -76,8 +69,8 @@ function getPath(name, isHTML, isJSON) {
 }
 
 function showError(name) {
-    const str = 'Wrong file name: ' + name;
+    const str = `Wrong file name: ${name}`;
-    const error = new Error(str);
+    const error = Error(str);
     
     throw error;
 }
@@ -141,4 +134,3 @@ function getTimeoutOnce(time) {
         }, time);
     };
 }
-

client/dom/images.js

@@ -1,20 +1,13 @@
 /* global DOM */
-
+import createElement from '@cloudcmd/create-element';
-'use strict';
-
-const createElement = require('@cloudcmd/create-element');
-
-const Images = module.exports;
 
 const LOADING = 'loading';
 const HIDDEN = 'hidden';
 const ERROR = 'error';
 
-function getLoadingType() {
+const getLoadingType = () => isSVG() ? '-svg' : '-gif';
-    return isSVG() ? '-svg' : '-gif';
-}
 
-module.exports.get = getElement;
+export const get = getElement;
 
 /**
  * check SVG SMIL animation support
@@ -43,7 +36,7 @@ function getElement() {
 }
 
 /* Функция создаёт картинку загрузки */
-module.exports.loading = () => {
+export const loading = () => {
     const element = getElement();
     const {classList} = element;
     const loadingImage = LOADING + getLoadingType();
@@ -55,7 +48,7 @@ module.exports.loading = () => {
 };
 
 /* Функция создаёт картинку ошибки загрузки */
-module.exports.error = () => {
+export const error = () => {
     const element = getElement();
     const {classList} = element;
     const loadingImage = LOADING + getLoadingType();
@@ -66,15 +59,21 @@ module.exports.error = () => {
     return element;
 };
 
-module.exports.show = show;
+show.load = show;
-module.exports.show.load = show;
+show.error = (text) => {
-module.exports.show.error = error;
+    const image = Images.error();
+    
+    DOM.show(image);
+    image.title = text;
+    
+    return image;
+};
 
 /**
 * Function shows loading spinner
 * position = {top: true};
 */
-function show(position, panel) {
+export function show(position, panel) {
     const image = Images.loading();
     const parent = image.parentElement;
     const refreshButton = DOM.getRefreshButton(panel);
@@ -100,34 +99,25 @@ function show(position, panel) {
     return image;
 }
 
-function error(text) {
-    const image = Images.error();
-    
-    DOM.show(image);
-    image.title = text;
-    
-    return image;
-}
-
 /**
 * hide load image
 */
-module.exports.hide = () => {
+export function hide() {
     const element = Images.get();
     
     DOM.hide(element);
     
     return Images;
-};
+}
 
-module.exports.setProgress = (value, title) => {
+export const setProgress = (value, title) => {
     const DATA = 'data-progress';
     const element = Images.get();
     
     if (!element)
         return Images;
     
-    element.setAttribute(DATA, value + '%');
+    element.setAttribute(DATA, `${value}%`);
     
     if (title)
         element.title = title;
@@ -135,7 +125,7 @@ module.exports.setProgress = (value, title) => {
     return Images;
 };
 
-module.exports.clearProgress = () => {
+export const clearProgress = () => {
     const DATA = 'data-progress';
     const element = Images.get();
     
@@ -148,3 +138,12 @@ module.exports.clearProgress = () => {
     return Images;
 };
 
+const Images = {
+    clearProgress,
+    setProgress,
+    show,
+    hide,
+    get,
+    error,
+    loading,
+};

client/dom/index.spec.js

@@ -0,0 +1,52 @@
+import {test, stub} from 'supertape';
+import {getCSSVar, goToDirectory} from '#dom';
+
+globalThis.CloudCmd = {};
+
+test('cloudcmd: client: dom: goToDirectory', async (t) => {
+    const path = '';
+    const changeDir = stub();
+    const prompt = stub().returns([null, path]);
+    
+    await goToDirectory({
+        prompt,
+        changeDir,
+    });
+    
+    t.calledWith(changeDir, [path]);
+    t.end();
+});
+
+test('cloudcmd: client: dom: getCSSVar', (t) => {
+    const body = {};
+    const getPropertyValue = stub().returns(0);
+    
+    globalThis.getComputedStyle = stub().returns({
+        getPropertyValue,
+    });
+    const result = getCSSVar('hello', {
+        body,
+    });
+    
+    delete globalThis.getComputedStyle;
+    
+    t.notOk(result);
+    t.end();
+});
+
+test('cloudcmd: client: dom: getCSSVar: 1', (t) => {
+    const body = {};
+    const getPropertyValue = stub().returns(1);
+    
+    globalThis.getComputedStyle = stub().returns({
+        getPropertyValue,
+    });
+    const result = getCSSVar('hello', {
+        body,
+    });
+    
+    delete globalThis.getComputedStyle;
+    
+    t.ok(result);
+    t.end();
+});

client/dom/io.js

@@ -1,216 +0,0 @@
-'use strict';
-
-/* global CloudCmd*/
-
-const itype = require('itype');
-const {promisify} = require('es6-promisify');
-
-const {FS} = require('../../common/cloudfunc');
-
-const Images = require('./images');
-const load = require('./load');
-
-const imgPosition = {
-    top: true,
-};
-
-module.exports._replaceHash = replaceHash;
-function replaceHash(url) {
-    /*
-     * if we send ajax request -
-     * no need in hash so we escape #
-     */
-    return url.replace(/#/g, '%23');
-}
-
-module.exports.delete = promisify((url, data, callback) => {
-    const isFunc = itype.function(data);
-    
-    if (!callback && isFunc) {
-        callback = data;
-        data = null;
-    }
-    
-    sendRequest({
-        method      : 'DELETE',
-        url         : FS + url,
-        data,
-        callback,
-        imgPosition : {
-            top: !!data,
-        },
-    });
-});
-
-module.exports.patch = promisify((url, data, callback) => {
-    const isFunc = itype.function(data);
-    
-    if (!callback && isFunc) {
-        callback = data;
-        data = null;
-    }
-    
-    sendRequest({
-        method: 'PATCH',
-        url: FS + url,
-        data,
-        callback,
-        imgPosition,
-    });
-});
-
-module.exports.write = promisify((url, data, callback) => {
-    const isFunc = itype.function(data);
-    
-    if (!callback && isFunc) {
-        callback = data;
-        data = null;
-    }
-    
-    sendRequest({
-        method: 'PUT',
-        url: FS + url,
-        data,
-        callback,
-        imgPosition,
-    });
-});
-
-module.exports.read = promisify((url, dataType, callback) => {
-    const notLog = !url.includes('?');
-    const isFunc = itype.function(dataType);
-    
-    if (!callback && isFunc) {
-        callback = dataType;
-        dataType = 'text';
-    }
-    
-    sendRequest({
-        method: 'GET',
-        url: FS + url,
-        callback,
-        notLog,
-        dataType,
-    });
-});
-
-module.exports.cp = promisify((data, callback) => {
-    sendRequest({
-        method: 'PUT',
-        url: '/cp',
-        data,
-        callback,
-        imgPosition,
-    });
-});
-
-module.exports.pack = promisify((data, callback) => {
-    sendRequest({
-        method: 'PUT',
-        url: '/pack',
-        data,
-        callback,
-    });
-});
-
-module.exports.extract = promisify((data, callback) => {
-    sendRequest({
-        method      : 'PUT',
-        url         : '/extract',
-        data,
-        callback,
-    });
-});
-
-module.exports.mv = promisify((data, callback) => {
-    sendRequest({
-        method      : 'PUT',
-        url         : '/mv',
-        data,
-        callback,
-        imgPosition,
-    });
-});
-
-module.exports.Config = {
-    read: promisify((callback) => {
-        sendRequest({
-            method: 'GET',
-            url: '/config',
-            callback,
-            imgPosition,
-            notLog: true,
-        });
-    }),
-    
-    write: promisify((data, callback) => {
-        sendRequest({
-            method: 'PATCH',
-            url: '/config',
-            data,
-            callback,
-            imgPosition,
-        });
-    }),
-};
-
-module.exports.Markdown = {
-    read: promisify((url, callback) => {
-        sendRequest({
-            method: 'GET',
-            url: '/markdown' + url,
-            callback,
-            imgPosition,
-            notLog: true,
-        });
-    }),
-    
-    render: promisify((data, callback) => {
-        sendRequest({
-            method: 'PUT',
-            url: '/markdown',
-            data,
-            callback,
-            imgPosition,
-            notLog: true,
-        });
-    }),
-};
-
-function sendRequest(params) {
-    const p = params;
-    const {prefixURL} = CloudCmd;
-    
-    p.url = prefixURL + p.url;
-    p.url = encodeURI(p.url);
-    
-    p.url = replaceHash(p.url);
-    
-    load.ajax({
-        method      : p.method,
-        url         : p.url,
-        data        : p.data,
-        dataType    : p.dataType,
-        error       : (jqXHR) => {
-            const response = jqXHR.responseText;
-            
-            const {
-                statusText,
-                status,
-            } = jqXHR;
-            
-            const text = status === 404 ? response : statusText;
-            
-            p.callback(Error(text));
-        },
-        success: (data) => {
-            Images.hide();
-            
-            if (!p.notLog)
-                CloudCmd.log(data);
-            
-            p.callback(null, data);
-        },
-    });
-}
-

client/dom/io/index.js

@@ -0,0 +1,166 @@
+import {FS} from '#common/cloudfunc';
+import {sendRequest as _sendRequest} from './send-request.js';
+
+const {assign} = Object;
+
+const imgPosition = {
+    top: true,
+};
+
+export const remove = async (url, data, overrides = {}) => {
+    const {
+        sendRequest = _sendRequest,
+    } = overrides;
+    
+    const request = {
+        method: 'DELETE',
+        url: FS + url,
+        imgPosition: {
+            top: Boolean(data),
+        },
+    };
+    
+    if (data)
+        assign(request, {
+            data,
+            url: `${request.url}?files`,
+        });
+    
+    return await sendRequest(request);
+};
+
+export const patch = async (url, data) => {
+    return await _sendRequest({
+        method: 'PATCH',
+        url: FS + url,
+        data,
+        imgPosition,
+    });
+};
+
+export const write = async (url, data) => {
+    return await _sendRequest({
+        method: 'PUT',
+        url: FS + url,
+        data,
+        imgPosition,
+    });
+};
+
+export const createDirectory = async (url, overrides = {}) => {
+    const {
+        sendRequest = _sendRequest,
+    } = overrides;
+    
+    return await sendRequest({
+        method: 'PUT',
+        url: `${FS}${url}?dir`,
+        imgPosition,
+    });
+};
+
+export const read = async (url, dataType = 'text') => {
+    const notLog = !url.includes('?');
+    
+    return await _sendRequest({
+        method: 'GET',
+        url: FS + url,
+        notLog,
+        dataType,
+    });
+};
+
+export const copy = async (from, to, names) => {
+    return await _sendRequest({
+        method: 'PUT',
+        url: '/copy',
+        data: {
+            from,
+            to,
+            names,
+        },
+        imgPosition,
+    });
+};
+
+export const pack = async (data) => {
+    return await _sendRequest({
+        method: 'PUT',
+        url: '/pack',
+        data,
+    });
+};
+
+export const extract = async (data) => {
+    return await _sendRequest({
+        method: 'PUT',
+        url: '/extract',
+        data,
+    });
+};
+
+export const move = async (from, to, names) => {
+    return await _sendRequest({
+        method: 'PUT',
+        url: '/move',
+        data: {
+            from,
+            to,
+            names,
+        },
+        imgPosition,
+    });
+};
+
+export const rename = async (from, to) => {
+    return await _sendRequest({
+        method: 'PUT',
+        url: '/rename',
+        data: {
+            from,
+            to,
+        },
+        imgPosition,
+    });
+};
+
+export const Config = {
+    read: async () => {
+        return await _sendRequest({
+            method: 'GET',
+            url: '/config',
+            imgPosition,
+            notLog: true,
+        });
+    },
+    
+    write: async (data) => {
+        return await _sendRequest({
+            method: 'PATCH',
+            url: '/config',
+            data,
+            imgPosition,
+        });
+    },
+};
+
+export const Markdown = {
+    read: async (url) => {
+        return await _sendRequest({
+            method: 'GET',
+            url: `/markdown${url}`,
+            imgPosition,
+            notLog: true,
+        });
+    },
+    
+    render: async (data) => {
+        return await _sendRequest({
+            method: 'PUT',
+            url: '/markdown',
+            data,
+            imgPosition,
+            notLog: true,
+        });
+    },
+};

client/dom/io/index.spec.js

@@ -0,0 +1,61 @@
+import {test, stub} from 'supertape';
+import * as io from './index.js';
+
+test('client: dom: io', (t) => {
+    const sendRequest = stub();
+    
+    io.createDirectory('/hello', {
+        sendRequest,
+    });
+    
+    const expected = {
+        imgPosition: {
+            top: true,
+        },
+        method: 'PUT',
+        url: '/fs/hello?dir',
+    };
+    
+    t.calledWith(sendRequest, [expected]);
+    t.end();
+});
+
+test('client: dom: io: remove: no files', async (t) => {
+    const sendRequest = stub();
+    
+    await io.remove('/hello', null, {
+        sendRequest,
+    });
+    
+    const expected = {
+        imgPosition: {
+            top: false,
+        },
+        method: 'DELETE',
+        url: '/fs/hello',
+    };
+    
+    t.calledWith(sendRequest, [expected]);
+    t.end();
+});
+
+test('client: dom: io: remove: files', async (t) => {
+    const sendRequest = stub();
+    const files = ['world'];
+    
+    await io.remove('/hello', files, {
+        sendRequest,
+    });
+    
+    const expected = {
+        imgPosition: {
+            top: true,
+        },
+        data: ['world'],
+        method: 'DELETE',
+        url: '/fs/hello?files',
+    };
+    
+    t.calledWith(sendRequest, [expected]);
+    t.end();
+});

client/dom/io/send-request.js

@@ -0,0 +1,48 @@
+/* global CloudCmd */
+import {promisify} from 'es6-promisify';
+import * as Images from '#dom/images';
+import * as load from '#dom/load';
+
+export const sendRequest = promisify((params, callback) => {
+    const p = params;
+    const {prefixURL} = CloudCmd;
+    
+    p.url = prefixURL + p.url;
+    p.url = encodeURI(p.url);
+    
+    p.url = replaceHash(p.url);
+    
+    load.ajax({
+        method: p.method,
+        url: p.url,
+        data: p.data,
+        dataType: p.dataType,
+        error: (jqXHR) => {
+            const response = jqXHR.responseText;
+            
+            const {statusText, status} = jqXHR;
+            
+            const text = status === 404 ? response : statusText;
+            
+            callback(Error(text));
+        },
+        success: (data) => {
+            Images.hide();
+            
+            if (!p.notLog)
+                CloudCmd.log(data);
+            
+            callback(null, data);
+        },
+    });
+});
+
+export const _replaceHash = replaceHash;
+
+function replaceHash(url) {
+    /*
+     * if we send ajax request -
+     * no need in hash so we escape #
+     */
+    return url.replace(/#/g, '%23');
+}

client/dom/io/send-request.spec.js

@@ -1,15 +1,11 @@
-'use strict';
+import {test} from 'supertape';
-
+import {_replaceHash} from './send-request.js';
-const test = require('supertape');
-const io = require('./io');
 
 test('cloudcmd: client: io: replaceHash', (t) => {
-    const {_replaceHash} = io;
     const url = '/hello/####world';
     const result = _replaceHash(url);
     const expected = '/hello/%23%23%23%23world';
     
-    t.equal(result, expected, 'should equal');
+    t.equal(result, expected);
     t.end();
 });
-

client/dom/load-remote.js

@@ -1,60 +1,58 @@
-'use strict';
-
 /* global CloudCmd */
+import {callbackify} from 'node:util';
+import {rendy} from 'rendy';
+import itype from 'itype';
+import * as load from 'load.js';
+import {tryToCatch} from 'try-to-catch';
+import {findObjByNameInArr} from '#common/util';
+import * as Files from '#dom/files';
 
-const rendy = require('rendy');
+export const loadRemote = callbackify(async (name, options) => {
-const itype = require('itype');
-const load = require('load.js');
-const tryToCatch = require('try-to-catch');
-
-const {findObjByNameInArr} = require('../../common/util');
-
-const Files = require('./files');
-
-module.exports = (name, options, callback = options) => {
     const {prefix, config} = CloudCmd;
     const o = options;
     
     if (o.name && window[o.name])
-        return callback();
+        return;
     
-    Files.get('modules').then(async (modules) => {
+    const modules = await Files.get('modules');
-        const online = config('online') && navigator.onLine;
+    
-        const module = findObjByNameInArr(modules.remote, name);
+    const online = config('online') && navigator.onLine;
+    const module = findObjByNameInArr(modules.remote, name);
+    
+    const isArray = itype.array(module.local);
+    const {version} = module;
+    
+    let remoteTmpls;
+    let local;
+    
+    if (isArray) {
+        remoteTmpls = module.remote;
+        ({local} = module);
+    } else {
+        remoteTmpls = [module.remote];
+        local = [module.local];
+    }
+    
+    const localURL = [];
+    
+    for (const url of local) {
+        localURL.push(prefix + url);
+    }
+    
+    const remoteURL = [];
+    
+    for (const tmpl of remoteTmpls) {
+        remoteURL.push(rendy(tmpl, {
+            version,
+        }));
+    }
+    
+    if (online) {
+        const [e] = await tryToCatch(load.parallel, remoteURL);
         
-        const isArray = itype.array(module.local);
+        if (!e)
-        const {version} = module;
+            return;
-        
+    }
-        let remoteTmpls;
+    
-        let local;
+    await load.parallel(localURL);
-        
+});
-        if (isArray) {
-            remoteTmpls = module.remote;
-            local = module.local;
-        } else {
-            remoteTmpls = [module.remote];
-            local = [module.local];
-        }
-        
-        const localURL = local.map((url) => {
-            return prefix + url;
-        });
-        
-        const remoteURL = remoteTmpls.map((tmpl) => {
-            return rendy(tmpl, {
-                version,
-            });
-        });
-        
-        if (online) {
-            const [e] = await tryToCatch(load.parallel, remoteURL);
-            
-            if (!e)
-                return callback();
-        }
-        
-        const [e] = await tryToCatch(load.parallel, localURL);
-        callback(e);
-    });
-};
-

client/dom/load.js

@@ -1,12 +1,8 @@
-'use strict';
+import itype from 'itype';
-
+import jonny from 'jonny';
-const itype = require('itype');
+import Emitify from 'emitify';
-const jonny = require('jonny');
+import exec from 'execon';
-const Emitify = require('emitify');
+import * as Images from '#dom/images';
-const exec = require('execon');
-const Images = require('./images');
-
-module.exports.getIdBySrc = getIdBySrc;
 
 /**
  * Function gets id by src
@@ -14,17 +10,18 @@ module.exports.getIdBySrc = getIdBySrc;
  *
  * Example: http://domain.com/1.js -> 1_js
  */
-function getIdBySrc(src) {
+export function getIdBySrc(src) {
     const isStr = itype.string(src);
     
     if (!isStr)
         return;
     
-    if (~src.indexOf(':'))
+    if (src.includes(':'))
         src += '-join';
     
     const num = src.lastIndexOf('/') + 1;
     const sub = src.substr(src, num);
+    
     const id = src
         .replace(sub, '')
         .replace(/\./g, '-');
@@ -37,15 +34,15 @@ function getIdBySrc(src) {
  *
  * @param params
  */
-module.exports.ajax = (params) => {
+export const ajax = (params) => {
     const p = params;
     const isObject = itype.object(p.data);
     const isArray = itype.array(p.data);
     const isArrayBuf = itype(p.data) === 'arraybuffer';
     const type = p.type || p.method || 'GET';
-    const {
+    
-        headers = {},
+    const {headers = {}} = p;
-    } = p;
+    
     const xhr = new XMLHttpRequest();
     
     xhr.open(type, p.url, true);
@@ -63,7 +60,7 @@ module.exports.ajax = (params) => {
     if (!isArrayBuf && isObject || isArray)
         data = jonny.stringify(p.data);
     else
-        data = p.data;
+        ({data} = p);
     
     xhr.onreadystatechange = (event) => {
         const xhr = event.target;
@@ -81,7 +78,7 @@ module.exports.ajax = (params) => {
             return exec(p.error, xhr);
         
         const notText = p.dataType !== 'text';
-        const isContain = ~type.indexOf(TYPE_JSON);
+        const isContain = type.includes(TYPE_JSON);
         
         let data = xhr.response;
         
@@ -94,12 +91,11 @@ module.exports.ajax = (params) => {
     xhr.send(data);
 };
 
-module.exports.put = (url, body) => {
+export const put = (url, body) => {
     const emitter = Emitify();
     const xhr = new XMLHttpRequest();
     
-    url = encodeURI(url)
+    url = encodeURI(url).replace(/#/g, '#');
-        .replace('#', '%23');
     
     xhr.open('put', url, true);
     
@@ -120,8 +116,10 @@ module.exports.put = (url, body) => {
         if (!over)
             return;
         
-        if (xhr.status === OK)
+        if (xhr.status === OK) {
+            emitter.emit('progress', 100);
             return emitter.emit('end');
+        }
         
         const error = Error(xhr.responseText);
         emitter.emit('error', error);
@@ -131,4 +129,3 @@ module.exports.put = (url, body) => {
     
     return emitter;
 };
-

client/dom/operations/rename-current.js

@@ -1,23 +1,27 @@
-'use strict';
-
 /* global CloudCmd */
+import capitalize from 'just-capitalize';
+import * as _Dialog from '#dom/dialog';
+import * as Storage from '#dom/storage';
+import * as RESTful from '#dom/rest';
+import * as _currentFile from '../current-file.js';
 
-const capitalize = require('just-capitalize');
+export default async (current, overrides = {}) => {
-
+    const {
-const Dialog = require('../dialog');
+        refresh = CloudCmd.refresh,
-const Storage = require('../storage');
+        Dialog = _Dialog,
-const RESTful = require('../rest');
+        currentFile = _currentFile,
-const {
+    } = overrides;
-    isCurrentFile,
+    
-    getCurrentName,
+    const {
-    getCurrentFile,
+        isCurrentFile,
-    getCurrentByName,
+        getCurrentName,
-    getCurrentType,
+        getCurrentFile,
-    getCurrentDirPath,
+        getCurrentByName,
-    setCurrentName,
+        getCurrentType,
-} = require('../current-file');
+        getCurrentDirPath,
-
+        setCurrentName,
-module.exports = async (current) => {
+    } = currentFile;
+    
     if (!isCurrentFile(current))
         current = getCurrentFile();
     
@@ -46,12 +50,11 @@ module.exports = async (current) => {
         return;
     
     const dirPath = getCurrentDirPath();
-    const files = {
-        from : dirPath + from,
-        to : dirPath + to,
-    };
     
-    const [e] = await RESTful.mv(files);
+    const fromFull = `${dirPath}${from}`;
+    const toFull = `${dirPath}${to}`;
+    
+    const [e] = await RESTful.rename(fromFull, toFull);
     
     if (e)
         return;
@@ -59,5 +62,5 @@ module.exports = async (current) => {
     setCurrentName(to, current);
     
     Storage.remove(dirPath);
-    CloudCmd.refresh();
+    refresh();
 };

client/dom/operations/rename-current.spec.js

@@ -1,37 +1,26 @@
-'use strict';
+import {test, stub} from 'supertape';
-
+import renameCurrent from './rename-current.js';
-const test = require('supertape');
-const stub = require('@cloudcmd/stub');
-const mockRequire = require('mock-require');
-
-const {reRequire} = mockRequire;
 
 test('cloudcmd: client: dom: renameCurrent: isCurrentFile', async (t) => {
     const current = {};
     const isCurrentFile = stub();
     
-    mockRequire('../dialog', stubDialog());
+    const currentFile = stubCurrentFile({
-    mockRequire('../current-file', stubCurrentFile({
         isCurrentFile,
-    }));
+    });
     
-    const renameCurrent = reRequire('./rename-current');
+    await renameCurrent(current, {
-    await renameCurrent(current);
+        Dialog: stubDialog(),
+        currentFile,
+    });
     
-    t.ok(isCurrentFile.calledWith(current), 'should call isCurrentFile');
+    t.calledWith(isCurrentFile, [current], 'should call isCurrentFile');
     t.end();
 });
 
 test('cloudcmd: client: dom: renameCurrent: file exist', async (t) => {
     const current = {};
     const name = 'hello';
-    const {CloudCmd} = global;
-    
-    const CloudCmdStub = {
-        refresh: stub(),
-    };
-    
-    global.CloudCmd = CloudCmdStub;
     
     const prompt = stub().returns([null, name]);
     const confirm = stub().returns([true]);
@@ -39,23 +28,24 @@ test('cloudcmd: client: dom: renameCurrent: file exist', async (t) => {
     const getCurrentByName = stub().returns(current);
     const getCurrentType = stub().returns('directory');
     
-    mockRequire('../dialog', stubDialog({
+    const Dialog = stubDialog({
         confirm,
         prompt,
-    }));
+    });
     
-    mockRequire('../current-file', stubCurrentFile({
+    const currentFile = stubCurrentFile({
         getCurrentByName,
         getCurrentType,
-    }));
+    });
     
-    const renameCurrent = reRequire('./rename-current');
+    await renameCurrent(null, {
-    await renameCurrent();
+        Dialog,
+        currentFile,
+    });
     
     const expected = 'Directory "hello" already exists. Proceed?';
-    global.CloudCmd = CloudCmd;
     
-    t.ok(confirm.calledWith(expected), 'should call confirm');
+    t.calledWith(confirm, [expected], 'should call confirm');
     t.end();
 });
 
@@ -94,4 +84,3 @@ const stubCurrentFile = (fns = {}) => {
         setCurrentName,
     };
 };
-

client/dom/rest.js

@@ -1,12 +1,8 @@
-'use strict';
+import {tryToCatch} from 'try-to-catch';
-
+import * as Dialog from '#dom/dialog';
-const tryToCatch = require('try-to-catch');
+import * as Images from '#dom/images';
-
+import {encode} from '#common/entity';
-const {encode} = require('../../common/entity');
+import * as IO from './io/index.js';
-
-const Images = require('./images');
-const IO = require('./io');
-const Dialog = require('./dialog');
 
 const handleError = (promise) => async (...args) => {
     const [e, data] = await tryToCatch(promise, ...args);
@@ -22,22 +18,23 @@ const handleError = (promise) => async (...args) => {
     return [e, data];
 };
 
-module.exports.delete = handleError(IO.delete);
+export const remove = handleError(IO.remove);
-module.exports.patch = handleError(IO.patch);
+export const patch = handleError(IO.patch);
-module.exports.write = handleError(IO.write);
+export const write = handleError(IO.write);
-module.exports.read = handleError(IO.read);
+export const createDirectory = handleError(IO.createDirectory);
-module.exports.cp = handleError(IO.cp);
+export const read = handleError(IO.read);
-module.exports.pack = handleError(IO.pack);
+export const copy = handleError(IO.copy);
-module.exports.extract = handleError(IO.extract);
+export const pack = handleError(IO.pack);
-module.exports.mv = handleError(IO.mv);
+export const extract = handleError(IO.extract);
+export const move = handleError(IO.move);
+export const rename = handleError(IO.rename);
 
-module.exports.Config = {
+export const Config = {
     read: handleError(IO.Config.read),
     write: handleError(IO.Config.write),
 };
 
-module.exports.Markdown = {
+export const Markdown = {
     read: handleError(IO.Markdown.read),
     render: handleError(IO.Markdown.render),
 };
-

client/dom/select-by-pattern.js

@@ -1,22 +1,18 @@
-'use strict';
+import {alert, prompt} from '#dom/dialog';
+import {getRegExp} from '#common/util';
+import {getCurrentName} from './current-file.js';
+import {
+    isSelected,
+    toggleSelectedFile,
+} from './cmd.js';
 
 let SelectType = '*.*';
 
-const {getRegExp} = require('../../common/util');
+export const selectByPattern = async (msg, files) => {
-const {
-    alert,
-    prompt,
-} = require('./dialog');
-
-const DOM = require('.');
-
-module.exports = async (msg, files) => {
     if (!files)
         return;
     
     const allMsg = `Specify file type for ${msg} selection`;
-    
-    /* eslint require-atomic-updates: 0 */
     const [cancel, type] = await prompt(allMsg, SelectType);
     
     if (cancel)
@@ -28,24 +24,23 @@ module.exports = async (msg, files) => {
     let matches = 0;
     
     for (const current of files) {
-        const name = DOM.getCurrentName(current);
+        const name = getCurrentName(current);
         
         if (name === '..' || !regExp.test(name))
             continue;
         
         ++matches;
         
-        let isSelected = DOM.isSelected(current);
+        let selected = isSelected(current);
         const shouldSel = msg === 'expand';
         
         if (shouldSel)
-            isSelected = !isSelected;
+            selected = !selected;
         
-        if (isSelected)
+        if (selected)
-            DOM.toggleSelectedFile(current);
+            toggleSelectedFile(current);
     }
     
     if (!matches)
         alert('No matches found!');
 };
-

client/dom/storage.js

@@ -1,38 +1,26 @@
-'use strict';
-
-const tryCatch = require('try-catch');
-
 const {parse, stringify} = JSON;
-const isObj = (a) => typeof a === 'object';
 
-module.exports.set = (name, data) => {
+export const set = (name, data) => {
-    const primitive = !isObj(data) ? data : stringify(data);
+    localStorage.setItem(name, data);
-    
-    localStorage.setItem(name, primitive);
 };
 
-module.exports.get = async (name) => {
+export const setJson = (name, data) => {
+    localStorage.setItem(name, stringify(data));
+};
+
+export const get = (name) => {
+    return localStorage.getItem(name);
+};
+
+export const getJson = (name) => {
     const data = localStorage.getItem(name);
-    const [, result = data] = tryCatch(parse, data);
+    return parse(data);
-    
-    return result;
 };
 
-module.exports.clear = () => {
+export const clear = () => {
     localStorage.clear();
 };
 
-module.exports.remove = (item) => {
+export const remove = (item) => {
     localStorage.removeItem(item);
 };
-
-module.exports.removeMatch = (string) => {
-    const reg = RegExp('^' + string + '.*$');
-    const test = (a) => reg.test(a);
-    const remove = (a) => localStorage.removeItem(a);
-    
-    Object.keys(localStorage)
-        .filter(test)
-        .forEach(remove);
-};
-

client/dom/storage.spec.js

@@ -0,0 +1,105 @@
+import {test, stub} from 'supertape';
+import * as storage from '#dom/storage';
+
+const {stringify} = JSON;
+
+test('cloudcmd: client: storage: set', async (t) => {
+    const {localStorage} = globalThis;
+    const setItem = stub();
+    
+    globalThis.localStorage = {
+        setItem,
+    };
+    
+    await storage.set('hello', 'world');
+    globalThis.localStorage = localStorage;
+    
+    t.calledWith(setItem, ['hello', 'world'], 'should call setItem');
+    t.end();
+});
+
+test('cloudcmd: client: storage: get', async (t) => {
+    const {localStorage} = globalThis;
+    const getItem = stub().returns('world');
+    
+    globalThis.localStorage = {
+        getItem,
+    };
+    
+    const result = await storage.get('hello');
+    
+    globalThis.localStorage = localStorage;
+    
+    t.equal(result, 'world');
+    t.end();
+});
+
+test('cloudcmd: client: storage: getJson', async (t) => {
+    const {localStorage} = globalThis;
+    const expected = {
+        hello: 'world',
+    };
+    
+    const getItem = stub().returns(stringify(expected));
+    
+    globalThis.localStorage = {
+        getItem,
+    };
+    
+    const result = await storage.getJson('hello');
+    
+    globalThis.localStorage = localStorage;
+    
+    t.deepEqual(result, expected);
+    t.end();
+});
+
+test('cloudcmd: client: storage: setJson', async (t) => {
+    const {localStorage} = globalThis;
+    const data = {
+        hello: 'world',
+    };
+    
+    const expected = stringify(data);
+    const setItem = stub();
+    
+    globalThis.localStorage = {
+        setItem,
+    };
+    
+    await storage.setJson('hello', data);
+    globalThis.localStorage = localStorage;
+    
+    t.calledWith(setItem, ['hello', expected]);
+    t.end();
+});
+
+test('cloudcmd: client: storage: remove', async (t) => {
+    const {localStorage} = globalThis;
+    const removeItem = stub();
+    
+    globalThis.localStorage = {
+        removeItem,
+    };
+    
+    await storage.remove('hello');
+    globalThis.localStorage = localStorage;
+    
+    t.calledWith(removeItem, ['hello'], 'should call removeItem');
+    t.end();
+});
+
+test('cloudcmd: client: storage: clear', async (t) => {
+    const {localStorage} = globalThis;
+    const clear = stub();
+    
+    globalThis.localStorage = {
+        clear,
+    };
+    
+    await storage.clear();
+    globalThis.localStorage = localStorage;
+    
+    t.calledWithNoArgs(clear, 'should call clear');
+    t.end();
+});

client/dom/upload-files.js

@@ -1,25 +1,19 @@
-'use strict';
-
 /* global CloudCmd */
+import {eachSeries} from 'execon';
+import wraptile from 'wraptile';
+import * as load from '#dom/load';
+import {alert} from '#dom/dialog';
+import {FS} from '#common/cloudfunc';
+import * as Images from '#dom/images';
+import {getCurrentDirPath} from './current-file.js';
 
-const {eachSeries} = require('execon');
-const wraptile = require('wraptile');
-
-const load = require('./load');
-const Images = require('./images');
-const {alert} = require('./dialog');
-
-const {FS} = require('../../common/cloudfunc');
-
-const onEnd = wraptile(_onEnd);
 const loadFile = wraptile(_loadFile);
+const onEnd = wraptile(_onEnd);
 
-const {getCurrentDirPath: getPathWhenRootEmpty} = require('.');
+export const uploadFiles = (dir, files) => {
-
-module.exports = (dir, files) => {
     if (!files) {
         files = dir;
-        dir = getPathWhenRootEmpty();
+        dir = getCurrentDirPath();
     }
     
     const n = files.length;
@@ -55,7 +49,8 @@ function _loadFile(dir, n, file, callback) {
     
     ++i;
     
-    load.put(api + path, file)
+    load
+        .put(api + path, file)
         .on('error', showError)
         .on('end', callback)
         .on('progress', (count) => {
@@ -70,4 +65,3 @@ function _loadFile(dir, n, file, callback) {
 function showError({message}) {
     alert(message);
 }
-

client/get-json-from-file-table.js

@@ -1,40 +1,13 @@
-'use strict';
-
 /* global DOM */
-
-const Info = DOM.CurrentInfo;
-
 /**
  * Функция генерирует JSON из html-таблицы файлов и
  * используеться при первом заходе в корень
  */
-module.exports = () => {
+export const getJsonFromFileTable = () => {
+    const Info = DOM.CurrentInfo;
     const path = DOM.getCurrentDirPath();
     const infoFiles = Info.files || [];
     
-    const notParent = (current) => {
-        const name = DOM.getCurrentName(current);
-        return name !== '..';
-    };
-    
-    const parse = (current) => {
-        const name = DOM.getCurrentName(current);
-        const size = DOM.getCurrentSize(current);
-        const owner = DOM.getCurrentOwner(current);
-        const mode = DOM.getCurrentMode(current);
-        const date = DOM.getCurrentDate(current);
-        const type = DOM.getCurrentType(current);
-        
-        return {
-            name,
-            size,
-            mode,
-            owner,
-            date,
-            type,
-        };
-    };
-    
     const files = infoFiles
         .filter(notParent)
         .map(parse);
@@ -47,3 +20,25 @@ module.exports = () => {
     return fileTable;
 };
 
+const notParent = (current) => {
+    const name = DOM.getCurrentName(current);
+    return name !== '..';
+};
+
+const parse = (current) => {
+    const name = DOM.getCurrentName(current);
+    const size = DOM.getCurrentSize(current);
+    const owner = DOM.getCurrentOwner(current);
+    const mode = DOM.getCurrentMode(current);
+    const date = DOM.getCurrentDate(current);
+    const type = DOM.getCurrentType(current);
+    
+    return {
+        name,
+        size,
+        mode,
+        owner,
+        date,
+        type,
+    };
+};

client/key/binder.js

@@ -0,0 +1,15 @@
+export const createBinder = () => {
+    let binded = false;
+    
+    return {
+        isBind() {
+            return binded;
+        },
+        setBind() {
+            binded = true;
+        },
+        unsetBind() {
+            binded = false;
+        },
+    };
+};

client/key/binder.spec.js

@@ -0,0 +1,28 @@
+import {test} from 'supertape';
+import {createBinder} from './binder.js';
+
+test('client: key: binder: isBind: default', (t) => {
+    const binder = createBinder();
+    
+    t.notOk(binder.isBind(), 'should not be bind by default');
+    t.end();
+});
+
+test('client: key: binder: setBind', (t) => {
+    const binder = createBinder();
+    
+    binder.setBind();
+    
+    t.ok(binder.isBind(), 'should be bind');
+    t.end();
+});
+
+test('client: key: binder: unsetBind', (t) => {
+    const binder = createBinder();
+    
+    binder.setBind();
+    binder.unsetBind();
+    
+    t.notOk(binder.isBind(), 'should not be bind');
+    t.end();
+});

client/key/index.spec.js

@@ -0,0 +1,56 @@
+import autoGlobals from 'auto-globals';
+import supertape from 'supertape';
+import {ESC} from './key.js';
+import {Key, _listener} from './index.js';
+import {getDOM, getCloudCmd} from './vim/globals.fixture.js';
+
+const test = autoGlobals(supertape);
+const {stub} = supertape;
+
+globalThis.DOM = getDOM();
+globalThis.CloudCmd = getCloudCmd();
+
+test('cloudcmd: client: key: enable vim', async (t) => {
+    const vim = stub();
+    const config = stub().returns(true);
+    const _config = stub();
+    
+    const event = {
+        keyCode: ESC,
+        key: 'Escape',
+        altKey: false,
+    };
+    
+    Key.setBind();
+    
+    await _listener(event, {
+        vim,
+        config,
+        _config,
+        switchKey: stub(),
+    });
+    
+    t.calledWith(vim, ['Escape', event]);
+    t.end();
+});
+
+test('cloudcmd: client: key: disable vim', async (t) => {
+    const _config = stub();
+    const config = stub();
+    
+    const event = {
+        keyCode: ESC,
+        key: 'Escape',
+        altKey: false,
+    };
+    
+    Key.setBind();
+    await _listener(event, {
+        config,
+        _config,
+        switchKey: stub(),
+    });
+    
+    t.calledWith(_config, ['vim', true]);
+    t.end();
+});

client/key/key.js

@@ -1,81 +1,58 @@
-'use strict';
+export const BACKSPACE = 8;
-
+export const TAB = 9;
-module.exports = {
+export const ENTER = 13;
-    BACKSPACE   : 8,
+export const CAPSLOCK = 20;
-    TAB         : 9,
+export const ESC = 27;
-    ENTER       : 13,
+export const SPACE = 32;
-    ESC         : 27,
+export const PAGE_UP = 33;
-    
+export const PAGE_DOWN = 34;
-    SPACE       : 32,
+export const END = 35;
-    PAGE_UP     : 33,
+export const HOME = 36;
-    PAGE_DOWN   : 34,
+export const LEFT = 37;
-    END         : 35,
+export const UP = 38;
-    HOME        : 36,
+export const RIGHT = 39;
-    
+export const DOWN = 40;
-    LEFT        : 37,
+export const INSERT = 45;
-    UP          : 38,
+export const DELETE = 46;
-    RIGHT       : 39,
+export const ZERO = 48;
-    DOWN        : 40,
+export const SEMICOLON = 52;
-    
+export const A = 65;
-    INSERT      : 45,
+export const C = 67;
-    DELETE      : 46,
+export const D = 68;
-    
+export const G = 71;
-    ZERO        : 48,
+export const J = 74;
-    
+export const K = 75;
-    SEMICOLON   : 52,
+export const L = 76;
-    
+export const M = 77;
-    COLON       : 54,
+export const O = 79;
-    
+export const P = 80;
-    A           : 65,
+export const Q = 81;
-    
+export const R = 82;
-    C           : 67,
+export const S = 83;
-    D           : 68,
+export const T = 84;
-    
+export const U = 85;
-    G           : 71,
+export const V = 86;
-    
+export const X = 88;
-    J           : 74,
+export const Z = 90;
-    K           : 75,
+export const INSERT_MAC = 96;
-    
+export const ASTERISK = 106;
-    M           : 77,
+export const PLUS = 107;
-    
+export const MINUS = 109;
-    O           : 79,
+export const F1 = 112;
-    P           : 80,
+export const F2 = 113;
-    Q           : 81,
+export const F3 = 114;
-    R           : 82,
+export const F4 = 115;
-    S           : 83,
+export const F5 = 116;
-    T           : 84,
+export const F6 = 117;
-    U           : 85,
+export const F7 = 118;
-    
+export const F8 = 119;
-    V           : 86,
+export const F9 = 120;
-    
+export const F10 = 121;
-    X           : 88,
+export const COLON = 186;
-    
+export const EQUAL = 187;
-    Z           : 90,
+export const HYPHEN = 189;
-    
+export const DOT = 190;
-    INSERT_MAC  : 96,
+export const SLASH = 191;
-    
+export const TRA = 192;
-    ASTERISK    : 106,
+export const BACKSLASH = 220;
-    PLUS        : 107,
+export const BRACKET_CLOSE = 221;
-    MINUS       : 109,
-    
-    F1          : 112,
-    F2          : 113,
-    F3          : 114,
-    F4          : 115,
-    F5          : 116,
-    F6          : 117,
-    F7          : 118,
-    F8          : 119,
-    F9          : 120,
-    F10         : 121,
-    
-    EQUAL       : 187,
-    HYPHEN      : 189,
-    DOT         : 190,
-    SLASH       : 191,
-    TRA         : 192, /* Typewritten Reverse Apostrophe (`) */
-    BACKSLASH   : 220,
-    
-    BRACKET_CLOSE: 221,
-};
-

client/key/set-current-by-char.js

@@ -1,18 +1,15 @@
 /* global DOM */
+import {escapeRegExp} from '#common/util';
 
-'use strict';
+export default function setCurrentByChar(char, charStore) {
-
+    const Info = DOM.CurrentInfo;
-const Info = DOM.CurrentInfo;
-const {escapeRegExp} = require('../../common/util');
-
-module.exports = function setCurrentByChar(char, charStore) {
     let firstByName;
     let skipCount = 0;
-    let setted = false;
+    let set = false;
     let i = 0;
     
     const escapeChar = escapeRegExp(char);
-    const regExp = new RegExp('^' + escapeChar + '.*$', 'i');
+    const regExp = new RegExp(`^${escapeChar}.*$`, 'i');
     const {files} = Info;
     const chars = charStore();
     const n = chars.length;
@@ -31,12 +28,14 @@ module.exports = function setCurrentByChar(char, charStore) {
     const isTest = (a) => regExp.test(a);
     const isRoot = (a) => a === '..';
     const not = (f) => (a) => !f(a);
+    
     const setCurrent = (name) => {
         const byName = DOM.getCurrentByName(name);
         
         if (!skipCount) {
-            setted = true;
+            set = true;
             DOM.setCurrentFile(byName);
+            
             return true;
         }
         
@@ -51,9 +50,8 @@ module.exports = function setCurrentByChar(char, charStore) {
         .filter(not(isRoot))
         .some(setCurrent);
     
-    if (!setted) {
+    if (!set) {
         DOM.setCurrentFile(firstByName);
         charStore([char]);
     }
-};
+}
-

client/key/vim/find.js

@@ -1,12 +1,10 @@
-'use strict';
+import {fullstore} from 'fullstore';
-
+import limier from 'limier';
-const fullstore = require('fullstore');
-const limier = require('limier');
 
 const searchStore = fullstore([]);
 const searchIndex = fullstore(0);
 
-module.exports.find = (value, names) => {
+export const find = (value, names) => {
     const result = limier(value, names);
     
     searchStore(result);
@@ -15,7 +13,7 @@ module.exports.find = (value, names) => {
     return result;
 };
 
-module.exports.findNext = () => {
+export const findNext = () => {
     const names = searchStore();
     const index = next(searchIndex(), names.length);
     
@@ -23,7 +21,7 @@ module.exports.findNext = () => {
     return names[searchIndex()];
 };
 
-module.exports.findPrevious = () => {
+export const findPrevious = () => {
     const names = searchStore();
     const index = previous(searchIndex(), names.length);
     
@@ -31,8 +29,8 @@ module.exports.findPrevious = () => {
     return names[index];
 };
 
-module.exports._next = next;
+export const _next = next;
-module.exports._previous = previous;
+export const _previous = previous;
 
 function next(index, length) {
     if (index === length - 1)
@@ -47,4 +45,3 @@ function previous(index, length) {
     
     return --index;
 }
-

client/key/vim/find.spec.js

@@ -1,16 +1,14 @@
-'use strict';
+import test from 'supertape';
-
+import {getDOM} from './globals.fixture.js';
-const test = require('supertape');
+import {
-const dir = './';
-
-const {getDOM} = require('./globals.fixture');
-
-global.DOM = getDOM();
-
-const {
     _next,
     _previous,
-} = require(dir + 'find');
+    find,
+    findNext,
+    findPrevious,
+} from './find.js';
+
+globalThis.DOM = getDOM();
 
 test('cloudcmd: client: vim: _next', (t) => {
     const result = _next(1, 2);
@@ -19,6 +17,13 @@ test('cloudcmd: client: vim: _next', (t) => {
     t.end();
 });
 
+test('cloudcmd: client: vim: _next: increment', (t) => {
+    const result = _next(0, 2);
+    
+    t.equal(result, 1, 'should return 1');
+    t.end();
+});
+
 test('cloudcmd: client: vim: _previous', (t) => {
     const result = _previous(0, 2);
     
@@ -26,3 +31,25 @@ test('cloudcmd: client: vim: _previous', (t) => {
     t.end();
 });
 
+test('cloudcmd: client: vim: _previous: decrement', (t) => {
+    const result = _previous(1, 2);
+    
+    t.equal(result, 0, 'should return 0');
+    t.end();
+});
+
+test('cloudcmd: client: vim: findNext: after find', (t) => {
+    find('a', ['alpha', 'beta', 'apple']);
+    const result = findNext();
+    
+    t.equal(result, 'beta', 'should return next found name');
+    t.end();
+});
+
+test('cloudcmd: client: vim: findPrevious: after find', (t) => {
+    find('a', ['alpha', 'beta', 'apple']);
+    const result = findPrevious();
+    
+    t.equal(result, 'apple', 'should return previous found name');
+    t.end();
+});

client/key/vim/globals.fixture.js

@@ -1,13 +1,12 @@
-'use strict';
+const noop = () => {};
 
-module.exports.getDOM = () => {
+export const getDOM = () => {
     const prompt = Promise.resolve.bind(Promise);
     const CurrentInfo = {
         element: {},
         files: [],
     };
     
-    const noop = () => {};
     const Buffer = {
         copy: noop,
         paste: noop,
@@ -28,16 +27,20 @@ module.exports.getDOM = () => {
         getCurrentName: noop,
         setCurrentByName: noop,
         toggleSelectedFile: noop,
+        prompNewDirectory: noop,
+        promptNewFile: noop,
     };
 };
 
-module.exports.getCloudCmd = () => {
+export const getCloudCmd = () => {
     const show = () => {};
     
     return {
-        Operation:  {
+        Operation: {
             show,
         },
+        
+        config: noop,
+        _config: noop,
     };
 };
-

client/key/vim/index.js

@@ -1,102 +1,167 @@
-'use strict';
+import vim from './vim.js';
+import * as finder from './find.js';
+import {
+    setCurrent,
+    selectFileNotParent,
+} from './set-current.js';
 
-/* global CloudCmd */
+export default (key, event, overrides = {}) => {
-/* global DOM */
+    const defaults = {
-
+        ...globalThis.DOM,
-const vim = require('./vim');
+        ...globalThis.CloudCmd,
-const finder = require('./find');
+    };
-
+    
-const Info = DOM.CurrentInfo;
+    const deps = {
-const {Dialog} = DOM;
+        ...defaults,
-
+        ...overrides,
-module.exports = async (key, event) => {
+    };
-    const operations = getOperations(event);
+    
-    await vim(key, operations);
+    const operations = getOperations(event, deps);
+    
+    vim(key, operations, deps);
 };
 
-const getOperations = (event) => {
+const getOperations = (event, deps) => {
+    const {
+        Info = globalThis.DOM.CurrentInfo,
+        CloudCmd = globalThis.CloudCmd,
+        Operation,
+        unselectFiles,
+        setCurrentFile,
+        setCurrentByName,
+        getCurrentName,
+        prompt = globalThis.DOM.Dialog.prompt,
+        preventDefault = event?.preventDefault?.bind(event),
+        stopImmediatePropagation = event?.preventDefault?.bind(event),
+        promptNewFile = globalThis.DOM.promptNewFile,
+        toggleSelectedFile,
+        Buffer = {},
+        createFindNext = _createFindNext,
+        createFindPrevious = _createFindPrevious,
+        createMakeFile = _createMakeFile,
+        renameCurrent,
+    } = deps;
+    
     return {
-        escape: DOM.unselectFiles,
+        makeFile: createMakeFile({
+            promptNewFile,
+            preventDefault,
+            stopImmediatePropagation,
+        }),
+        findNext: createFindNext({
+            setCurrentByName,
+        }),
+        findPrevious: createFindPrevious({
+            setCurrentByName,
+        }),
+        escape: unselectFiles,
+        rename: () => {
+            event.preventDefault();
+            renameCurrent();
+        },
         remove: () => {
-            CloudCmd.Operation.show('delete');
+            Operation.show('delete');
         },
+        operationCopy: () => {
+            event.preventDefault();
+            Operation.show('copy');
+        },
+        operationMove: () => {
+            event.preventDefault();
+            Operation.show('move');
+        },
+        
+        makeDirectory: () => {
+            event.stopImmediatePropagation();
+            event.preventDefault();
+            globalThis.DOM.promptNewDir();
+        },
+        
+        terminal: () => {
+            CloudCmd.Terminal.show();
+        },
+        
+        edit: () => {
+            CloudCmd.EditFileVim.show();
+        },
+        
         copy: () => {
-            DOM.Buffer.copy();
+            Buffer.copy();
-            DOM.unselectFiles();
+            unselectFiles();
         },
+        
         select: () => {
             const current = Info.element;
-            DOM.toggleSelectedFile(current);
+            toggleSelectedFile(current);
         },
-        paste: DOM.Buffer.paste,
+        
+        paste: Buffer.paste,
+        
         moveNext: ({count, isVisual, isDelete}) => {
             setCurrent('next', {
                 count,
                 isVisual,
                 isDelete,
+            }, {
+                Info,
+                setCurrentFile,
+                unselectFiles,
+                Operation,
             });
         },
+        
         movePrevious: ({count, isVisual, isDelete}) => {
             setCurrent('previous', {
                 count,
                 isVisual,
                 isDelete,
+            }, {
+                Info,
+                setCurrentFile,
+                unselectFiles,
+                Operation,
             });
         },
+        
         find: async () => {
-            event.preventDefault();
+            preventDefault();
-            const [, value] = await Dialog.prompt('Find', '');
+            const [, value] = await prompt('Find', '');
             
             if (!value)
                 return;
             
-            const names = Info.files.map(DOM.getCurrentName);
+            const names = Info.files.map(getCurrentName);
             const [result] = finder.find(value, names);
             
-            DOM.setCurrentByName(result);
+            setCurrentByName(result);
-        },
-        findNext: () => {
-            const name = finder.findNext();
-            DOM.setCurrentByName(name);
-        },
-        findPrevious: () => {
-            const name = finder.findPrevious();
-            DOM.setCurrentByName(name);
         },
     };
 };
 
-module.exports.selectFile = selectFile;
+export const selectFile = selectFileNotParent;
 
-function selectFile(current) {
+const _createFindPrevious = (overrides = {}) => () => {
-    const name = DOM.getCurrentName(current);
+    const {setCurrentByName} = overrides;
+    const name = finder.findPrevious();
     
-    if (name === '..')
+    setCurrentByName(name);
-        return;
+};
-    
-    DOM.selectFile(current);
-}
 
-function setCurrent(sibling, {count, isVisual, isDelete}) {
+const _createFindNext = (overrides = {}) => () => {
-    let current = Info.element;
+    const {setCurrentByName} = overrides;
-    const select = isVisual ? selectFile : DOM.unselectFile;
+    const name = finder.findNext();
     
-    select(current);
+    setCurrentByName(name);
-    
+};
-    const position = `${sibling}Sibling`;
-    for (let i = 0; i < count; i++) {
-        const next = current[position];
-        
-        if (!next)
-            break;
-        
-        current = next;
-        select(current);
-    }
-    
-    DOM.setCurrentFile(current);
-    
-    if (isDelete)
-        CloudCmd.Operation.show('delete');
-}
 
+const _createMakeFile = (overrides = {}) => () => {
+    const {
+        promptNewFile,
+        stopImmediatePropagation,
+        preventDefault,
+    } = overrides;
+    
+    stopImmediatePropagation();
+    preventDefault();
+    promptNewFile();
+};

client/key/vim/index.spec.js

@@ -1,46 +1,35 @@
-'use strict';
+import {test, stub} from 'supertape';
+import {getDOM, getCloudCmd} from './globals.fixture.js';
+import vim, {selectFile as vimSelectFile} from './index.js';
+import * as finder from './find.js';
 
-const {join} = require('path');
+globalThis.DOM = getDOM();
+globalThis.CloudCmd = getCloudCmd();
 
-const test = require('supertape');
+const {assign} = Object;
-const stub = require('@cloudcmd/stub');
+const {DOM} = globalThis;
-const mockRequire = require('mock-require');
-const {reRequire, stopAll} = mockRequire;
-
-const dir = '../';
-
-const pathVim = join(dir, 'vim');
-const pathFind = join(dir, 'vim', 'find');
-
-const {
-    getDOM,
-    getCloudCmd,
-} = require('./globals.fixture');
-
-global.DOM = getDOM();
-global.CloudCmd = getCloudCmd();
-
-const {DOM} = global;
 const {Buffer} = DOM;
 
-const vim = require(pathVim);
-
 test('cloudcmd: client: key: set next file: no', (t) => {
-    const element = {
+    const element = {};
+    const setCurrentFile = stub();
+    const unselectFiles = stub();
+    
+    const Info = {
+        element,
     };
     
-    const setCurrentFile = stub();
+    vim('j', {}, {
+        Info,
+        setCurrentFile,
+        unselectFiles,
+    });
     
-    global.DOM.CurrentInfo.element = element;
+    t.calledWith(setCurrentFile, [element], 'should set next file');
-    global.DOM.setCurrentFile = setCurrentFile;
-    
-    vim('j', {});
-    
-    t.ok(setCurrentFile.calledWith(element), 'should set next file');
     t.end();
 });
 
-test('cloudcmd: client: key: set next file current', (t) => {
+test('cloudcmd: client: key: set next file current: j', async (t) => {
     const nextSibling = 'hello';
     const element = {
         nextSibling,
@@ -48,17 +37,21 @@ test('cloudcmd: client: key: set next file current', (t) => {
     
     const setCurrentFile = stub();
     
-    global.DOM.CurrentInfo.element = element;
+    const Info = {
-    global.DOM.setCurrentFile = setCurrentFile;
+        element,
+    };
     
-    vim('j', {});
+    await vim('j', {}, {
-    
+        Info,
-    t.ok(setCurrentFile.calledWith(nextSibling), 'should set next file');
+        setCurrentFile,
+        unselectFiles: stub(),
+    });
     
+    t.calledWith(setCurrentFile, [nextSibling], 'should set next file');
     t.end();
 });
 
-test('cloudcmd: client: key: set next file current', (t) => {
+test('cloudcmd: client: key: set next file current: mjj', (t) => {
     const nextSibling = 'hello';
     const element = {
         nextSibling,
@@ -66,15 +59,21 @@ test('cloudcmd: client: key: set next file current', (t) => {
     
     const setCurrentFile = stub();
     
-    global.DOM.CurrentInfo.element = element;
+    const Info = {
-    global.DOM.setCurrentFile = setCurrentFile;
+        element,
+    };
     
-    vim('m', {});
+    const deps = {
-    vim('j', {});
+        Info,
-    vim('j', {});
+        setCurrentFile,
+        unselectFiles: stub(),
+    };
     
-    t.ok(setCurrentFile.calledWith(nextSibling), 'should set next file');
+    vim('m', {}, deps);
+    vim('j', {}, deps);
+    vim('j', {}, deps);
     
+    t.calledWith(setCurrentFile, [nextSibling], 'should set next file');
     t.end();
 });
 
@@ -86,38 +85,44 @@ test('cloudcmd: client: key: set next file current: g', (t) => {
     
     const setCurrentFile = stub();
     
-    global.DOM.CurrentInfo.element = element;
+    const Info = {
-    global.DOM.setCurrentFile = setCurrentFile;
+        element,
+    };
     
-    vim('g', {});
+    const deps = {
-    vim('j', {});
+        Info,
+        setCurrentFile,
+        unselectFiles: stub(),
+    };
     
-    t.ok(setCurrentFile.calledWith(nextSibling), 'should ignore g');
+    vim('g', {}, deps);
+    vim('j', {}, deps);
     
+    t.calledWith(setCurrentFile, [nextSibling], 'should ignore g');
     t.end();
 });
 
 test('cloudcmd: client: key: set +2 file current', (t) => {
     const last = {};
-    const nextSibling = {
-        nextSibling: last,
-    };
-    const element = {
-        nextSibling,
-    };
-    
     const setCurrentFile = stub();
+    const element = {};
     
-    global.DOM.CurrentInfo.element = element;
+    const Info = {
-    global.DOM.setCurrentFile = setCurrentFile;
+        element,
+    };
+    
+    const deps = {
+        setCurrentFile,
+        Info,
+        unselectFiles: stub(),
+    };
     
     const event = {};
     
-    vim('2', event);
+    vim('2', event, deps);
-    vim('j', event);
+    vim('j', event, deps);
-    
-    t.ok(setCurrentFile.calledWith(last), 'should set next file');
     
+    t.calledWith(setCurrentFile, [last], 'should set next file');
     t.end();
 });
 
@@ -126,25 +131,39 @@ test('cloudcmd: client: key: select +2 files from current before delete', (t) =>
     const nextSibling = {
         nextSibling: last,
     };
+    
     const element = {
         nextSibling,
     };
     
     const setCurrentFile = stub();
     
-    global.DOM.CurrentInfo.element = element;
+    const Info = {
-    global.DOM.setCurrentFile = setCurrentFile;
+        element,
-    global.DOM.selectFile = stub();
+    };
-    global.DOM.getCurrentName = () => false;
+    
-    global.CloudCmd.Operation.show = stub();
+    const Operation = {
+        show: stub(),
+    };
+    
+    const selectFile = stub();
+    const getCurrentName = stub().returns('x');
     
     const event = {};
     
-    vim('d', event);
+    const deps = {
-    vim('2', event);
+        Info,
-    vim('j', event);
+        setCurrentFile,
+        selectFile,
+        getCurrentName,
+        Operation,
+    };
     
-    t.ok(setCurrentFile.calledWith(last), 'should set next file');
+    vim('d', event, deps);
+    vim('2', event, deps);
+    vim('j', event, deps);
+    
+    t.calledWith(setCurrentFile, [last], 'should set next file');
     t.end();
 });
 
@@ -153,6 +172,7 @@ test('cloudcmd: client: key: delete +2 files from current', (t) => {
     const nextSibling = {
         nextSibling: last,
     };
+    
     const element = {
         nextSibling,
     };
@@ -160,20 +180,26 @@ test('cloudcmd: client: key: delete +2 files from current', (t) => {
     const setCurrentFile = stub();
     const show = stub();
     
-    global.DOM.CurrentInfo.element = element;
+    const deps = {
-    global.DOM.setCurrentFile = setCurrentFile;
+        Info: {
-    global.DOM.selectFile = stub();
+            element,
-    global.DOM.getCurrentName = () => false;
+        },
-    global.CloudCmd.Operation.show = show;
+        Operation: {
+            show,
+        },
+        setCurrentFile,
+        selectFile: stub(),
+        getCurrentName: stub().returns('x'),
+        unselectFiles: stub(),
+    };
     
     const event = {};
     
-    vim('d', event);
+    vim('d', event, deps);
-    vim('2', event);
+    vim('2', event, deps);
-    vim('j', event);
+    vim('j', event, deps);
-    
-    t.ok(show.calledWith('delete'), 'should call delete');
     
+    t.calledWith(show, ['delete'], 'should call delete');
     t.end();
 });
 
@@ -184,49 +210,84 @@ test('cloudcmd: client: key: set previous file current', (t) => {
     };
     
     const setCurrentFile = stub();
+    const unselectFiles = stub();
     
-    global.DOM.CurrentInfo.element = element;
+    const Info = {
-    global.DOM.setCurrentFile = setCurrentFile;
+        element,
+    };
     
-    vim('k', {});
+    const deps = {
+        Info,
+        setCurrentFile,
+        unselectFiles,
+    };
     
-    t.ok(setCurrentFile.calledWith(previousSibling), 'should set previous file');
+    vim('k', {}, deps);
+    
+    t.calledWith(setCurrentFile, [previousSibling], 'should set previous file');
     t.end();
 });
 
 test('cloudcmd: client: key: copy: no', (t) => {
     const copy = stub();
     
-    Buffer.copy = copy;
+    vim('y', {}, {
-    
+        unselectFiles: stub(),
-    vim('y', {});
+        Buffer: {
-    
+            copy,
-    t.notOk(copy.called, 'should not copy files');
+        },
+    });
     
+    t.notCalled(copy, 'should not copy files');
     t.end();
 });
 
 test('cloudcmd: client: key: copy', (t) => {
     const copy = stub();
+    const Info = {
+        element: {},
+    };
     
-    Buffer.copy = copy;
+    const toggleSelectedFile = stub();
+    const unselectFiles = stub();
     
-    vim('v', {});
+    const deps = {
-    vim('y', {});
+        Info,
+        unselectFiles,
+        toggleSelectedFile,
+        Buffer: {
+            copy,
+        },
+    };
     
-    t.ok(copy.calledWith(), 'should copy files');
+    vim('v', {}, deps);
+    vim('y', {}, deps);
+    
+    t.calledWithNoArgs(copy, 'should copy files');
     t.end();
 });
 
 test('cloudcmd: client: key: copy: unselectFiles', (t) => {
     const unselectFiles = stub();
+    const Info = {
+        element: {},
+    };
     
-    DOM.unselectFiles = unselectFiles;
+    const toggleSelectedFile = stub();
     
-    vim('v', {});
+    const deps = {
-    vim('y', {});
+        Info,
+        unselectFiles,
+        toggleSelectedFile,
+        Buffer: {
+            copy: stub(),
+        },
+    };
     
-    t.ok(unselectFiles.calledWith(), 'should unselect files');
+    vim('v', {}, deps);
+    vim('y', {}, deps);
+    
+    t.calledWithNoArgs(unselectFiles, 'should unselect files');
     t.end();
 });
 
@@ -235,63 +296,91 @@ test('cloudcmd: client: key: paste', (t) => {
     
     Buffer.paste = paste;
     
-    vim('p', {});
+    vim('p', {}, {
-    
+        Buffer,
-    t.ok(paste.calledWith(), 'should paste files');
+    });
     
+    t.calledWithNoArgs(paste, 'should paste files');
     t.end();
 });
 
 test('cloudcmd: client: key: selectFile: ..', (t) => {
+    const getCurrentName = stub().returns('..');
     const selectFile = stub();
-    const getCurrentName = stub();
-    
-    DOM.selectFile = selectFile;
-    DOM.getCurrentName = () => '..';
-    
     const current = {};
-    vim.selectFile(current);
     
-    t.notOk(getCurrentName.called, 'should not call selectFile');
+    vimSelectFile(current, {
+        selectFile,
+        getCurrentName,
+    });
+    
+    t.notCalled(selectFile, 'should not call selectFile');
     t.end();
 });
 
 test('cloudcmd: client: key: selectFile', (t) => {
     const selectFile = stub();
-    
+    const getCurrentName = stub().returns('x');
-    DOM.selectFile = selectFile;
-    DOM.getCurrentName = (a) => a.name;
-    
     const current = {};
     
-    vim.selectFile(current);
+    vimSelectFile(current, {
+        selectFile,
+        getCurrentName,
+    });
     
-    t.ok(selectFile.calledWith(current), 'should call selectFile');
+    t.calledWith(selectFile, [current], 'should call selectFile');
     t.end();
 });
 
-test('cloudcmd: client: key: set last file current', (t) => {
+test('cloudcmd: client: key: set last file current: shift + g', async (t) => {
     const last = 'last';
     const nextSibling = {
         nextSibling: last,
     };
+    
     const element = {
         nextSibling,
     };
     
     const setCurrentFile = stub();
     
-    global.DOM.CurrentInfo.element = element;
+    await vim('G', {}, {
-    global.DOM.setCurrentFile = setCurrentFile;
+        Info: {
-    
+            element,
-    vim('G', {});
+        },
-    
+        setCurrentFile,
-    t.ok(setCurrentFile.calledWith(last), 'should set last file');
+        unselectFiles: stub(),
+    });
     
+    t.calledWith(setCurrentFile, [last], 'should set last file');
     t.end();
 });
 
-test('cloudcmd: client: key: set first file current', (t) => {
+test('cloudcmd: client: key: set last file current: $', (t) => {
+    const last = 'last';
+    const nextSibling = {
+        nextSibling: last,
+    };
+    
+    const element = {
+        nextSibling,
+    };
+    
+    const setCurrentFile = stub();
+    
+    vim('$', {}, {
+        Info: {
+            element,
+        },
+        setCurrentFile,
+        unselectFiles: stub(),
+    });
+    
+    t.calledWith(setCurrentFile, [last], 'should set last file');
+    t.end();
+});
+
+test('cloudcmd: client: key: set first file current: gg', (t) => {
     const first = 'first';
     const previousSibling = {
         previousSibling: first,
@@ -301,66 +390,121 @@ test('cloudcmd: client: key: set first file current', (t) => {
         previousSibling,
     };
     
+    const Operation = {
+        show: stub(),
+    };
+    
+    const unselectFiles = stub();
     const setCurrentFile = stub();
     
-    global.DOM.CurrentInfo.element = element;
+    const deps = {
-    global.DOM.setCurrentFile = setCurrentFile;
+        Operation,
+        unselectFiles,
+        setCurrentFile,
+        Info: {
+            element,
+        },
+    };
     
-    vim('g', {});
+    vim('g', {}, deps);
-    vim('g', {});
+    vim('g', {}, deps);
     
-    t.ok(setCurrentFile.calledWith(first), 'should set first file');
+    t.calledWith(setCurrentFile, [first], 'should set first file');
+    t.end();
+});
+
+test('cloudcmd: client: key: set first file current: ^', async (t) => {
+    const first = 'first';
+    const previousSibling = {
+        previousSibling: first,
+    };
     
+    const element = {
+        previousSibling,
+    };
+    
+    const Operation = {
+        show: stub(),
+    };
+    
+    const unselectFiles = stub();
+    const setCurrentFile = stub();
+    
+    const deps = {
+        setCurrentFile,
+        Info: {
+            element,
+        },
+        unselectFiles,
+        Operation,
+    };
+    
+    await vim('^', {}, deps);
+    
+    t.calledWith(setCurrentFile, [first], 'should set first file');
     t.end();
 });
 
 test('cloudcmd: client: key: visual', (t) => {
-    const element = {
+    const element = {};
-    };
-    
     const toggleSelectedFile = stub();
     
-    global.DOM.CurrentInfo.element = element;
+    const Info = {
-    global.DOM.toggleSelectedFile = toggleSelectedFile;
+        element,
+    };
     
-    vim('v', {});
+    vim('v', {}, {
-    
+        Info,
-    t.ok(toggleSelectedFile.calledWith(element), 'should toggle selection');
+        toggleSelectedFile,
+    });
     
+    t.calledWith(toggleSelectedFile, [element], 'should toggle selection');
     t.end();
 });
 
 test('cloudcmd: client: key: ESC', (t) => {
-    const element = {
+    const element = {};
-    };
-    
     const unselectFiles = stub();
     
-    global.DOM.CurrentInfo.element = element;
+    const Info = {
-    global.DOM.unselectFiles = unselectFiles ;
+        element,
+    };
     
-    vim('Escape');
+    vim('Escape', null, {
+        Info,
+        unselectFiles,
+    });
     
-    t.ok(unselectFiles.calledWith(), 'should toggle selection');
+    t.calledWithNoArgs(unselectFiles, 'should toggle selection');
     t.end();
 });
 
-test('cloudcmd: client: key: Enter', (t) => {
+test('cloudcmd: client: key: Enter', async (t) => {
     const nextSibling = 'hello';
     const element = {
         nextSibling,
     };
     
+    const unselectFiles = stub();
     const setCurrentFile = stub();
     
-    DOM.CurrentInfo.element = element;
+    const Info = {
-    DOM.setCurrentFile = setCurrentFile;
+        element,
+    };
     
-    vim('Enter');
+    await vim('Enter', null, {
+        Info,
+        setCurrentFile,
+        unselectFiles,
+    });
     
-    vim('j');
+    await vim('j', null, {
+        Info,
+        setCurrentFile,
+        unselectFiles,
+    });
     
-    t.ok(setCurrentFile.calledWith(nextSibling), 'should set next file');
+    t.calledWith(setCurrentFile, [nextSibling], 'should set next file');
     t.end();
 });
 
@@ -368,50 +512,245 @@ test('cloudcmd: client: key: /', (t) => {
     const preventDefault = stub();
     const element = {};
     
-    DOM.CurrentInfo.element = element;
+    const Info = {
-    DOM.getCurrentName = () => '';
+        element,
+        files: [],
+    };
     
-    vim('/', {
+    const getCurrentName = stub().returns('');
+    
+    const event = {
         preventDefault,
+    };
+    
+    const prompt = stub().returns([]);
+    
+    vim('/', event, {
+        getCurrentName,
+        Info,
+        prompt,
     });
     
-    t.ok(preventDefault.calledWith(), 'should call preventDefault');
+    t.calledWithNoArgs(preventDefault);
+    t.end();
+});
+
+test('cloudcmd: client: find', (t) => {
+    assign(DOM.Dialog, {
+        prompt: stub().returns([]),
+    });
+    
+    const setCurrentByName = stub();
+    
+    assign(DOM, {
+        setCurrentByName,
+    });
+    
+    const event = {
+        preventDefault: stub(),
+    };
+    
+    vim('/', event);
+    
+    t.notCalled(setCurrentByName);
     t.end();
 });
 
 test('cloudcmd: client: key: n', (t) => {
     const findNext = stub();
+    const createFindNext = stub().returns(findNext);
     
-    mockRequire(pathFind, {
-        findNext,
-    });
-    
-    const vim = reRequire(pathVim);
     const event = {};
     
-    vim('n', event);
+    vim('n', event, {
+        createFindNext,
+    });
     
-    stopAll(pathFind);
+    t.calledWithNoArgs(findNext, 'should call findNext');
-    
-    t.ok(findNext.calledWith(), 'should call findNext');
     t.end();
 });
 
 test('cloudcmd: client: key: N', (t) => {
     const findPrevious = stub();
-    
+    const createFindPrevious = stub().returns(findPrevious);
-    mockRequire(pathFind, {
-        findPrevious,
-    });
-    
-    const vim = reRequire(dir + 'vim');
     const event = {};
     
-    vim('N', event);
+    vim('N', event, {
+        createFindPrevious,
+    });
     
-    stopAll(pathFind);
+    t.calledWithNoArgs(findPrevious);
-    
-    t.ok(findPrevious.calledWith(), 'should call findPrevious');
     t.end();
 });
 
+test('cloudcmd: client: key: make directory', async (t) => {
+    const {DOM} = globalThis;
+    
+    assign(DOM, {
+        promptNewDir: stub(),
+    });
+    
+    const event = {
+        stopImmediatePropagation: stub(),
+        preventDefault: stub(),
+    };
+    
+    await vim('m', event);
+    await vim('d', event);
+    
+    t.calledWithNoArgs(DOM.promptNewDir);
+    t.end();
+});
+
+test('cloudcmd: client: key: make file', (t) => {
+    const promptNewFile = stub();
+    
+    const event = {
+        stopImmediatePropagation: stub(),
+        preventDefault: stub(),
+    };
+    
+    vim('m', event);
+    vim('f', event, {
+        promptNewFile,
+    });
+    
+    t.calledWithNoArgs(promptNewFile);
+    t.end();
+});
+
+test('cloudcmd: client: vim: terminal', (t) => {
+    const CloudCmd = {
+        Terminal: {
+            show: stub(),
+        },
+    };
+    
+    const event = {};
+    
+    vim('t', event, {
+        CloudCmd,
+    });
+    vim('t', event, {
+        CloudCmd,
+    });
+    
+    t.calledWithNoArgs(CloudCmd.Terminal.show);
+    t.end();
+});
+
+test('cloudcmd: client: vim: edit', async (t) => {
+    globalThis.DOM = getDOM();
+    globalThis.CloudCmd = getCloudCmd();
+    
+    const {CloudCmd} = globalThis;
+    
+    assign(CloudCmd, {
+        EditFileVim: {
+            show: stub(),
+        },
+    });
+    
+    const event = {};
+    
+    await vim('e', event);
+    
+    t.calledWithNoArgs(CloudCmd.EditFileVim.show);
+    t.end();
+});
+
+test('cloudcmd: client: vim: rename', async (t) => {
+    const DOM = getDOM();
+    const renameCurrent = stub();
+    
+    assign(DOM, {
+        renameCurrent,
+    });
+    
+    const event = {
+        preventDefault: stub(),
+    };
+    
+    await vim('rr', event, DOM);
+    
+    t.calledWithNoArgs(renameCurrent);
+    t.end();
+});
+
+test('cloudcmd: client: key: cc: operationCopy', (t) => {
+    const show = stub();
+    const preventDefault = stub();
+    
+    const Operation = {
+        show,
+    };
+    
+    const event = {
+        preventDefault,
+    };
+    
+    vim('c', event, {
+        Operation,
+    });
+    
+    vim('c', event, {
+        Operation,
+    });
+    
+    t.calledWith(show, ['copy'], 'should show copy operation');
+    t.end();
+});
+
+test('cloudcmd: client: key: mm: operationMove', (t) => {
+    const show = stub();
+    const preventDefault = stub();
+    
+    const Operation = {
+        show,
+    };
+    
+    const event = {
+        preventDefault,
+    };
+    
+    vim('m', event, {
+        Operation,
+    });
+    
+    vim('m', event, {
+        Operation,
+    });
+    
+    t.calledWith(show, ['move'], 'should show move operation');
+    t.end();
+});
+
+test('cloudcmd: client: key: n: findNext: real', (t) => {
+    const setCurrentByName = stub();
+    
+    finder.find('a', ['alpha', 'beta', 'apple']);
+    
+    const event = {};
+    
+    vim('n', event, {
+        setCurrentByName,
+    });
+    
+    t.calledWith(setCurrentByName, ['beta'], 'should set current by next found name');
+    t.end();
+});
+
+test('cloudcmd: client: key: N: findPrevious: real', (t) => {
+    const setCurrentByName = stub();
+    
+    finder.find('a', ['alpha', 'beta', 'apple']);
+    
+    const event = {};
+    
+    vim('N', event, {
+        setCurrentByName,
+    });
+    
+    t.calledWith(setCurrentByName, ['apple'], 'should set current by previous found name');
+    t.end();
+});

client/key/vim/set-current.js

@@ -0,0 +1,33 @@
+/* global DOM */
+export function selectFileNotParent(current, {getCurrentName, selectFile} = DOM) {
+    const name = getCurrentName(current);
+    
+    if (name === '..')
+        return;
+    
+    selectFile(current);
+}
+
+export const setCurrent = (sibling, {count, isVisual, isDelete}, {Info, setCurrentFile, unselectFiles, Operation}) => {
+    let current = Info.element;
+    const select = isVisual ? selectFileNotParent : unselectFiles;
+    
+    select(current);
+    
+    const position = `${sibling}Sibling`;
+    
+    for (let i = 0; i < count; i++) {
+        const next = current[position];
+        
+        if (!next)
+            break;
+        
+        current = next;
+        select(current);
+    }
+    
+    setCurrentFile(current);
+    
+    if (isDelete)
+        Operation.show('delete');
+};

client/key/vim/vim.js

@@ -1,6 +1,5 @@
-'use strict';
+import {fullstore} from 'fullstore';
 
-const fullstore = require('fullstore');
 const store = fullstore('');
 const visual = fullstore(false);
 
@@ -21,10 +20,11 @@ const rmFirst = (a) => {
 
 const noop = () => {};
 
-module.exports = (key, operations) => {
+export default (key, operations = {}) => {
     const prevStore = store();
     const isVisual = visual();
     const value = store(prevStore.concat(key));
+    
     const {
         escape = noop,
         moveNext = noop,
@@ -36,6 +36,13 @@ module.exports = (key, operations) => {
         find = noop,
         findNext = noop,
         findPrevious = noop,
+        makeFile = noop,
+        makeDirectory = noop,
+        terminal = noop,
+        edit = noop,
+        operationCopy = noop,
+        operationMove = noop,
+        rename = noop,
     } = operations;
     
     if (key === 'Enter')
@@ -44,10 +51,11 @@ module.exports = (key, operations) => {
     if (key === 'Escape') {
         visual(false);
         escape();
+        
         return end();
     }
     
-    if (key === 'j') {
+    if (key === 'j' || key === 'w') {
         const {
             count,
             isDelete,
@@ -63,7 +71,7 @@ module.exports = (key, operations) => {
         return end();
     }
     
-    if (key === 'k') {
+    if (key === 'k' || key === 'b') {
         const {
             count,
             isDelete,
@@ -79,11 +87,8 @@ module.exports = (key, operations) => {
         return end();
     }
     
-    if (/^gg$/.test(value)) {
+    if (value === 'gg' || key === '^') {
-        const {
+        const {isDelete, isVisual} = handleDelete(prevStore);
-            isDelete,
-            isVisual,
-        } = handleDelete(prevStore);
         
         movePrevious({
             count: Infinity,
@@ -94,13 +99,49 @@ module.exports = (key, operations) => {
         return end();
     }
     
-    if (key === 'd' && (visual() || prevStore === 'd')) {
+    if (value === 'md') {
-        stopVisual();
+        makeDirectory();
-        remove();
         return end();
     }
     
-    if (key === 'G') {
+    if (value === 'tt') {
+        terminal();
+        return end();
+    }
+    
+    if (value === 'e') {
+        edit();
+        return end();
+    }
+    
+    if (value === 'cc') {
+        operationCopy();
+        return end();
+    }
+    
+    if (value === 'mm') {
+        operationMove();
+        return end();
+    }
+    
+    if (value === 'mf') {
+        makeFile();
+        return end();
+    }
+    
+    if (value === 'rr') {
+        rename();
+        return end();
+    }
+    
+    if (key === 'd' && (visual() || prevStore === 'd')) {
+        stopVisual();
+        remove();
+        
+        return end();
+    }
+    
+    if (key === 'G' || key === '$') {
         moveNext({
             count: Infinity,
             isVisual,
@@ -115,6 +156,7 @@ module.exports = (key, operations) => {
         
         stopVisual();
         copy();
+        
         return end();
     }
     
@@ -126,6 +168,7 @@ module.exports = (key, operations) => {
     if (/^v$/i.test(key)) {
         visual(!visual());
         select();
+        
         return end();
     }
     
@@ -143,6 +186,9 @@ module.exports = (key, operations) => {
         findPrevious();
         return end();
     }
+    
+    if (key === ' ')
+        return end();
 };
 
 function handleDelete(prevStore) {
@@ -172,4 +218,3 @@ function getNumber(value) {
     
     return parseInt(value);
 }
-

client/key/vim/vim.spec.js

@@ -1,7 +1,5 @@
-'use strict';
+import {test, stub} from 'supertape';
-
+import vim from './vim.js';
-const test = require('supertape');
-const vim = require('./vim');
 
 test('vim: no operations', (t) => {
     const result = vim('hello', {});
@@ -10,3 +8,93 @@ test('vim: no operations', (t) => {
     t.end();
 });
 
+test('vim: space', (t) => {
+    const moveNext = stub();
+    
+    vim(' ');
+    vim('j', {
+        moveNext,
+    });
+    
+    const args = [{
+        count: 1,
+        isDelete: false,
+        isVisual: false,
+    }];
+    
+    t.calledWith(moveNext, args);
+    t.end();
+});
+
+test('vim: ^', (t) => {
+    const movePrevious = stub();
+    
+    vim('^', {
+        movePrevious,
+    });
+    
+    const expected = {
+        count: Infinity,
+        isVisual: false,
+        isDelete: false,
+    };
+    
+    t.calledWith(movePrevious, [expected], 'should call movePrevious');
+    t.end();
+});
+
+test('vim: cc', (t) => {
+    const operationCopy = stub();
+    
+    vim('cc', {
+        operationCopy,
+    });
+    
+    t.calledWithNoArgs(operationCopy);
+    t.end();
+});
+
+test('vim: mm', (t) => {
+    const operationMove = stub();
+    
+    vim('mm', {
+        operationMove,
+    });
+    
+    t.calledWithNoArgs(operationMove);
+    t.end();
+});
+
+test('vim: w', (t) => {
+    const moveNext = stub();
+    
+    vim('w', {
+        moveNext,
+    });
+    
+    const expected = {
+        count: 1,
+        isVisual: false,
+        isDelete: false,
+    };
+    
+    t.calledWith(moveNext, [expected], 'should call moveNext');
+    t.end();
+});
+
+test('vim: b', (t) => {
+    const movePrevious = stub();
+    
+    vim('b', {
+        movePrevious,
+    });
+    
+    const expected = {
+        count: 1,
+        isVisual: false,
+        isDelete: false,
+    };
+    
+    t.calledWith(movePrevious, [expected], 'should call movePrevious');
+    t.end();
+});

client/listeners/get-index.js

@@ -1,11 +1,10 @@
-'use strict';
+import currify from 'currify';
 
-module.exports = (array, item) => {
+export const getIndex = currify((array, item) => {
     const index = array.indexOf(item);
     
     if (!~index)
         return 0;
     
     return index;
-};
+});
-

client/listeners/get-index.spec.js

@@ -1,9 +1,5 @@
-'use strict';
+import test from 'supertape';
-
+import {getIndex} from './get-index.js';
-const test = require('supertape');
-
-const dir = '../../../client/listeners';
-const getIndex = require(`${dir}/get-index`);
 
 test('cloudcmd: client: listeners: getIndex: not found', (t) => {
     const array = ['hello'];
@@ -13,9 +9,11 @@ test('cloudcmd: client: listeners: getIndex: not found', (t) => {
 });
 
 test('cloudcmd: client: listeners: getIndex: found', (t) => {
-    const array = ['hello', 'world'];
+    const array = [
+        'hello',
+        'world',
+    ];
     
     t.equal(getIndex(array, 'world'), 1, 'should return index');
     t.end();
 });
-

client/listeners/get-range.js

@@ -1,6 +1,4 @@
-'use strict';
+export const getRange = (indexFrom, indexTo, files) => {
-
-module.exports = (indexFrom, indexTo, files) => {
     if (indexFrom < indexTo)
         return files.slice(indexFrom, indexTo + 1);
     
@@ -9,4 +7,3 @@ module.exports = (indexFrom, indexTo, files) => {
     
     return [files[indexFrom]];
 };
-

client/listeners/get-range.spec.js

@@ -0,0 +1,52 @@
+import test from 'supertape';
+import {getRange} from './get-range.js';
+
+test('cloudcmd: client: listeners: getRange: direct', (t) => {
+    const expected = [
+        'hello',
+        'world',
+    ];
+    
+    const files = [
+        ...expected,
+        'how',
+        'come',
+    ];
+    
+    const result = getRange(0, 1, files);
+    
+    t.deepEqual(result, expected, 'should return range');
+    t.end();
+});
+
+test('cloudcmd: client: listeners: getRange: reverse', (t) => {
+    const expected = [
+        'hello',
+        'world',
+    ];
+    
+    const files = [
+        ...expected,
+        'how',
+        'come',
+    ];
+    
+    const result = getRange(1, 0, files);
+    
+    t.deepEqual(result, expected, 'should return range');
+    t.end();
+});
+
+test('cloudcmd: client: listeners: getRange: one', (t) => {
+    const expected = ['hello'];
+    const files = [
+        ...expected,
+        'how',
+        'come',
+    ];
+    
+    const result = getRange(0, 0, files);
+    
+    t.deepEqual(result, expected, 'should return range');
+    t.end();
+});

client/listeners/index.js

@@ -1,36 +1,30 @@
 /* global DOM, CloudCmd */
-
+import exec from 'execon';
-'use strict';
+import itype from 'itype';
-
+import currify from 'currify';
-const exec = require('execon');
+import {tryToCatch} from 'try-to-catch';
-const itype = require('itype');
+import clipboard from '@cloudcmd/clipboard';
-const currify = require('currify');
+import * as Events from '#dom/events';
-const tryToCatch = require('try-to-catch');
+import {uploadFiles} from '#dom/upload-files';
-const clipboard = require('@cloudcmd/clipboard');
+import {FS} from '#common/cloudfunc';
-
+import {getRange} from './get-range.js';
-const getRange = require('./get-range');
+import {getIndex} from './get-index.js';
-const getIndex = currify(require('./get-index'));
-const uploadFiles = require('../dom/upload-files');
-
-const {FS} = require('../../common/cloudfunc');
 
 const NBSP_REG = RegExp(String.fromCharCode(160), 'g');
 const SPACE = ' ';
 
-module.exports.init = () => {
+export async function init() {
     contextMenu();
     dragndrop();
     unload();
     pop();
     resize();
-    config();
     header();
-};
+    await config();
-
+}
-CloudCmd.Listeners = module.exports;
 
 const unselect = (event) => {
-    const isMac = /Mac/.test(window.navigator.platform);
+    const isMac = /Mac/.test(globalThis.navigator.platform);
     const {
         shiftKey,
         metaKey,
@@ -48,14 +42,9 @@ const execAll = currify((funcs, event) => {
         fn(event);
 });
 
-const Info = DOM.CurrentInfo;
-const {Events} = DOM;
 const EventsFiles = {
     mousedown: exec.with(execIfNotUL, setCurrentFileByEvent),
-    click: execAll([
+    click: execAll([onClick, exec.with(execIfNotMobile, unselect)]),
-        onClick,
-        unselect,
-    ]),
     dragstart: exec.with(execIfNotUL, onDragStart),
     dblclick: exec.with(execIfNotUL, onDblClick),
     touchstart: exec.with(execIfNotUL, onTouch),
@@ -66,6 +55,7 @@ let EXT;
 function header() {
     const fm = DOM.getFM();
     const isDataset = (el) => el.dataset;
+    
     const isPanel = (el) => {
         return /^js-(left|right)$/.test(el.dataset.name);
     };
@@ -77,8 +67,7 @@ function header() {
         if (parent.dataset.name !== 'js-fm-header')
             return;
         
-        const name = (el.dataset.name || '')
+        const name = (el.dataset.name || '').replace('js-', '');
-            .replace('js-', '');
         
         if (!/^(name|size|date)$/.test(name))
             return;
@@ -101,58 +90,58 @@ function getPath(el, path = []) {
 
 async function config() {
     const [, config] = await tryToCatch(DOM.Files.get, 'config');
-    const type = config && config.packer;
+    const type = config?.packer;
     
     EXT = DOM.getPackerExt(type);
 }
 
-module.exports.initKeysPanel = () => {
+export const initKeysPanel = () => {
     const keysElement = DOM.getById('js-keyspanel');
     
     if (!keysElement)
         return;
     
-    Events.addClick(keysElement, ({target}) => {
+    Events.addClick(keysElement, (event) => {
+        const {target} = event;
         const {id} = target;
+        
         const operation = (name) => {
             const {Operation} = CloudCmd;
-            const fn = Operation.show.bind(null, name);
             
-            return fn;
+            return Operation.show.bind(null, name);
         };
         
         const clickFuncs = {
-            'f1'        : CloudCmd.Help.show,
+            'f1': CloudCmd.Help.show,
-            'f2'        : initF2,
+            'f2': CloudCmd.UserMenu.show,
-            'f3'        : CloudCmd.View.show,
+            'f3': CloudCmd.View.show,
-            'f4'        : CloudCmd.EditFile.show,
+            'f4': CloudCmd.EditFile.show,
-            'f5'        : operation('copy'),
+            'f5': operation('copy'),
-            'f6'        : operation('move'),
+            'f6': operation('move'),
-            'f7'        : DOM.promptNewDir,
+            'f7': DOM.promptNewDir,
-            'f8'        : operation('delete'),
+            'f8': operation('delete'),
-            'f9'        : CloudCmd.Menu.show,
+            'f9': () => {
-            'f10'       : CloudCmd.Config.show,
+                event.stopPropagation();
-            '~'         : CloudCmd.Konsole.show,
+                CloudCmd.Menu.show();
-            'shift~'    : CloudCmd.Terminal.show,
+            },
-            'contact'   : CloudCmd.Contact.show,
+            'f10': CloudCmd.Config.show,
+            '~': CloudCmd.Konsole.show,
+            'shift~': CloudCmd.Terminal.show,
+            'contact': CloudCmd.Contact.show,
         };
         
         exec(clickFuncs[id]);
     });
 };
 
-function initF2() {
-    CloudCmd.UserMenu.show();
-}
-
 const getPanel = (side) => {
     if (!itype.string(side))
         return side;
     
-    return DOM.getByDataName('js-' + side);
+    return DOM.getByDataName(`js-${side}`);
 };
 
-module.exports.setOnPanel = (side) => {
+export const setOnPanel = (side) => {
     const panel = getPanel(side);
     
     const filesElement = DOM.getByDataName('js-files', panel);
@@ -168,6 +157,7 @@ function getPathListener(panel) {
 }
 
 function isNoCurrent(panel) {
+    const Info = DOM.CurrentInfo;
     const infoPanel = Info.panel;
     
     if (!infoPanel)
@@ -186,13 +176,13 @@ function decodePath(path) {
     
     return decodeURI(path)
         .replace(url, '')
-        .replace(prefixReg, '')
+        .replace(prefixReg, '') // browser doesn't replace % -> %25% do it for him
-    // browser doesn't replace % -> %25% do it for him
         .replace('%%', '%25%')
         .replace(NBSP_REG, SPACE) || '/';
 }
 
 async function onPathElementClick(panel, event) {
+    const Info = DOM.CurrentInfo;
     event.preventDefault();
     
     const element = event.target;
@@ -214,19 +204,26 @@ async function onPathElementClick(panel, event) {
     const {href} = element;
     const path = decodePath(href);
     
-    await CloudCmd.loadDir({
+    await CloudCmd.changeDir(path, {
-        path,
         isRefresh: false,
         panel: noCurrent ? panel : Info.panel,
     });
 }
 
 function copyPath(el) {
-    clipboard.writeText(el.parentElement.title)
+    clipboard
+        .writeText(el.parentElement.title)
         .then(CloudCmd.log)
         .catch(CloudCmd.log);
 }
 
+function execIfNotMobile(callback, event) {
+    const isMobile = DOM.getCSSVar('is-mobile');
+    
+    if (!isMobile)
+        callback(event);
+}
+
 function execIfNotUL(callback, event) {
     const {target} = event;
     const {tagName} = target;
@@ -241,14 +238,14 @@ function onClick(event) {
 }
 
 function toggleSelect(key, files) {
-    const isMac = /Mac/.test(window.navigator.platform);
+    const isMac = /Mac/.test(globalThis.navigator.platform);
     
     if (!key)
         throw Error('key should not be undefined!');
     
     const [file] = files;
     
-    if (isMac && key.meta || key.ctrl)
+    if (isMac && key.meta)
         return DOM.toggleSelectedFile(file);
     
     if (key.shift)
@@ -256,6 +253,7 @@ function toggleSelect(key, files) {
 }
 
 function changePanel(element) {
+    const Info = DOM.CurrentInfo;
     const {panel} = Info;
     const files = DOM.getByDataName('js-files', panel);
     const ul = getULElement(element);
@@ -265,21 +263,16 @@ function changePanel(element) {
 }
 
 async function onDblClick(event) {
+    event.preventDefault();
+    
     const current = getLIElement(event.target);
     const isDir = DOM.isCurrentIsDir(current);
     const path = DOM.getCurrentPath(current);
     
-    if (isDir) {
+    if (!isDir)
-        await CloudCmd.loadDir({
+        return CloudCmd.View.show();
-            path: path === '/' ? '/' : path + '/',
+    
-        });
+    await CloudCmd.changeDir(path);
-        
-        event.preventDefault();
-    } else {
-        CloudCmd.View.show();
-        
-        event.preventDefault();
-    }
 }
 
 async function onTouch(event) {
@@ -294,9 +287,7 @@ async function onTouch(event) {
     if (!isCurrent)
         return;
     
-    await CloudCmd.loadDir({
+    await CloudCmd.changeDir(DOM.getCurrentPath(current));
-        path: DOM.getCurrentPath(current),
-    });
 }
 
 /*
@@ -304,6 +295,7 @@ async function onTouch(event) {
   * in Chrome (HTML5)
   */
 function onDragStart(event) {
+    const Info = DOM.CurrentInfo;
     const {prefixURL} = CloudCmd;
     const element = getLIElement(event.target);
     const {isDir} = Info;
@@ -320,8 +312,8 @@ function onDragStart(event) {
     
     event.dataTransfer.setData(
         'DownloadURL',
-        'application/octet-stream' + ':' +
+        'application/octet-stream' + ':' + name +
-        name + ':' +
+        ':' +
         link,
     );
 }
@@ -344,6 +336,7 @@ function getULElement(element) {
 }
 
 function setCurrentFileByEvent(event) {
+    const Info = DOM.CurrentInfo;
     const BUTTON_LEFT = 0;
     
     const key = {
@@ -407,10 +400,7 @@ function dragndrop() {
     };
     
     const onDrop = (event) => {
-        const {
+        const {files, items} = event.dataTransfer;
-            files,
-            items,
-        } = event.dataTransfer;
         
         const {length: filesCount} = files;
         
@@ -420,7 +410,10 @@ function dragndrop() {
             return uploadFiles(files);
         
         const isFile = (item) => item.kind === 'file';
-        const dirFiles = Array.from(items).filter(isFile);
+        
+        const dirFiles = Array
+            .from(items)
+            .filter(isFile);
         
         if (dirFiles.length)
             return DOM.uploadDirectory(dirFiles);
@@ -432,7 +425,7 @@ function dragndrop() {
     };
     
     /**
-     * In Mac OS Chrome dropEffect = 'none'
+     * In macOS Chrome dropEffect = 'none'
      * so drop do not firing up when try
      * to upload file from download bar
      */
@@ -457,9 +450,9 @@ function dragndrop() {
 }
 
 function unload() {
-    DOM.Events.add(['unload', 'beforeunload'], (event) => {
+    Events.add(['unload', 'beforeunload'], (event) => {
         const {Key} = CloudCmd;
-        const isBind = Key && Key.isBind();
+        const isBind = Key?.isBind();
         
         if (isBind)
             return;
@@ -477,8 +470,8 @@ function pop() {
             return CloudCmd.route(location.hash);
         
         const history = false;
-        await CloudCmd.loadDir({
+        
-            path,
+        await CloudCmd.changeDir(path, {
             history,
         });
     });
@@ -486,7 +479,8 @@ function pop() {
 
 function resize() {
     Events.add('resize', () => {
-        const is = window.innerWidth < CloudCmd.MIN_ONE_PANEL_WIDTH;
+        const Info = DOM.CurrentInfo;
+        const is = globalThis.innerWidth < CloudCmd.MIN_ONE_PANEL_WIDTH;
         
         if (!is)
             return;
@@ -506,4 +500,3 @@ function resize() {
         DOM.changePanel();
     });
 }
-

client/load-module.js

@@ -1,19 +1,16 @@
-'use strict';
-
 /* global CloudCmd */
+import exec from 'execon';
+import {tryToCatch} from 'try-to-catch';
+import {js as loadJS} from 'load.js';
+import pascalCase from 'just-pascal-case';
 
-const exec = require('execon');
-const tryToCatch = require('try-to-catch');
-const loadJS = require('load.js').js;
-
-const pascalCase = require('just-pascal-case');
 const noJS = (a) => a.replace(/.js$/, '');
 
 /**
  * function load modules
  * @params = {name, path, func, dobefore, arg}
  */
-module.exports = function loadModule(params) {
+export const loadModule = (params) => {
     if (!params)
         return;
     
@@ -25,24 +22,24 @@ module.exports = function loadModule(params) {
     if (CloudCmd[name])
         return;
     
-    CloudCmd[name] = () => {
+    CloudCmd[name] = async () => {
         exec(doBefore);
-        const {prefix} = CloudCmd;
-        const pathFull = prefix + CloudCmd.DIRCLIENT_MODULES + path + '.js';
         
-        return loadJS(pathFull).then(async () => {
+        const {DIR_MODULES} = CloudCmd;
-            const newModule = async (f) => f && f();
+        const pathFull = `${DIR_MODULES}/${path}.js`;
-            const module = CloudCmd[name];
+        
-            
+        await loadJS(pathFull);
-            Object.assign(newModule, module);
+        const newModule = async (f) => f && f();
-            
+        const module = CloudCmd[name];
-            CloudCmd[name] = newModule;
+        
-            
+        Object.assign(newModule, module);
-            CloudCmd.log('init', name);
+        
-            await module.init();
+        CloudCmd[name] = newModule;
-            
+        CloudCmd.log('init', name);
-            return newModule;
+        
-        });
+        await module.init();
+        
+        return newModule;
     };
     
     CloudCmd[name].show = async (...args) => {
@@ -52,9 +49,8 @@ module.exports = function loadModule(params) {
         const [e, a] = await tryToCatch(m);
         
         if (e)
-            return console.error(e);
+            return;
         
-        await a.show(...args);
+        return await a.show(...args);
     };
 };
-

client/modules/cloud.js

@@ -1,31 +1,32 @@
 /* global CloudCmd, filepicker */
-
+import exec from 'execon';
-'use strict';
+import currify from 'currify';
-
+import load from 'load.js';
-const exec = require('execon');
+import {ajax} from '#dom/load';
-const currify = require('currify');
+import * as Files from '#dom/files';
-const load = require('load.js');
+import * as Images from '#dom/images';
 
 const {log} = CloudCmd;
 
-const {ajax} = require('../dom/load');
-const Files = require('../dom/files');
-const Images = require('../dom/images');
-
 const upload = currify(_upload);
 
 const Name = 'Cloud';
-CloudCmd[Name] = module.exports;
 
-module.exports.init = async () => {
+CloudCmd[Name] = {
+    init,
+    uploadFile,
+    saveFile,
+};
+
+export async function init() {
     const [modules] = await loadFiles();
     const {key} = modules.data.FilePicker;
     
     filepicker.setKey(key);
     Images.hide();
-};
+}
 
-module.exports.uploadFile = (filename, data) => {
+export function uploadFile(filename, data) {
     const mimetype = '';
     
     filepicker.store(data, {
@@ -34,17 +35,14 @@ module.exports.uploadFile = (filename, data) => {
     }, (fpFile) => {
         filepicker.exportFile(fpFile, log, log);
     });
-};
+}
 
-module.exports.saveFile = (callback) => {
+export function saveFile(callback) {
     filepicker.pick(upload(callback));
-};
+}
 
 function _upload(callback, file) {
-    const {
+    const {url, filename} = file;
-        url,
-        filename,
-    } = file;
     
     const responseType = 'arraybuffer';
     const success = exec.with(callback, filename);
@@ -56,7 +54,7 @@ function _upload(callback, file) {
     });
 }
 
-async function loadFiles() {
+function loadFiles() {
     const js = '//api.filepicker.io/v2/filepicker.js';
     
     return Promise.all([
@@ -64,4 +62,3 @@ async function loadFiles() {
         load.js(js),
     ]);
 }
-

client/modules/command-line.js

@@ -0,0 +1,31 @@
+/* global CloudCmd */
+import * as Dialog from '#dom/dialog';
+
+export function init() {}
+CloudCmd.CommandLine = {
+    init,
+    show,
+    hide,
+};
+
+export async function show() {
+    const [, cmd] = await Dialog.prompt('Command Line', '');
+    const TERMINAL = '^(t|terminal)';
+    
+    if (RegExp(`${TERMINAL}$`).test(cmd))
+        return await CloudCmd.Terminal.show();
+    
+    if (RegExp(TERMINAL).test(cmd)) {
+        const command = cmd.replace(RegExp(`${TERMINAL} `), '');
+        const exitCode = await CloudCmd.TerminalRun.show({
+            command: `bash -c '${command}'`,
+        });
+        
+        if (exitCode === -1)
+            await Dialog.alert(`☝️ Looks like Terminal is disabled, start Cloud Coammnder with '--terminal' flag.`);
+        
+        return;
+    }
+}
+
+export function hide() {}

client/modules/config/index.js

@@ -1,28 +1,23 @@
-'use strict';
+import '../../../css/config.css';
+import {rendy} from 'rendy';
+import currify from 'currify';
+import wraptile from 'wraptile';
+import squad from 'squad';
+import {promisify} from 'es6-promisify';
+import {tryToCatch} from 'try-to-catch';
+import load from 'load.js';
+import createElement from '@cloudcmd/create-element';
+import * as Events from '#dom/events';
+import * as Files from '#dom/files';
+import {getTitle} from '#common/cloudfunc';
+import * as Images from '#dom/images';
+import * as input from './input.js';
 
-/* global CloudCmd, DOM, io */
+const {CloudCmd, DOM} = globalThis;
 
-require('../../../css/config.css');
-
-const rendy = require('rendy');
-const currify = require('currify');
-const wraptile = require('wraptile');
-const squad = require('squad');
-const {promisify} = require('es6-promisify');
-const tryToCatch = require('try-to-catch');
-const load = require('load.js');
-const createElement = require('@cloudcmd/create-element');
-
-const input = require('./input');
-const Images = require('../../dom/images');
-const Events = require('../../dom/events');
-const Files = require('../../dom/files');
-
-const {getTitle} = require('../../../common/cloudfunc');
 const {Dialog, setTitle} = DOM;
 
 const Name = 'Config';
-CloudCmd[Name] = module.exports;
 
 const loadSocket = promisify(DOM.loadSocket);
 
@@ -46,28 +41,25 @@ let Template;
 
 const loadCSS = load.css;
 
-module.exports.init = async () => {
+export async function init() {
     if (!CloudCmd.config('configDialog'))
         return;
     
     showLoad();
     
-    const {prefix} = CloudCmd;
+    const {DIR_DIST} = CloudCmd;
     
     [Template] = await Promise.all([
         Files.get('config-tmpl'),
         loadSocket(),
-        loadCSS(prefix + '/dist/config.css'),
+        loadCSS(`${DIR_DIST}/config.css`),
         CloudCmd.View(),
     ]);
     
     initSocket();
-};
+}
 
-const {
+const {config, Key} = CloudCmd;
-    config,
-    Key,
-} = CloudCmd;
 
 let Element;
 
@@ -77,24 +69,20 @@ function getHost() {
         origin,
         protocol,
     } = location;
-    const href = origin || `${protocol}//${host}`;
     
-    return href;
+    return origin || `${protocol}//${host}`;
 }
 
 function initSocket() {
     const href = getHost();
-    const {
+    const {prefixSocket, prefix} = CloudCmd;
-        prefixSocket,
-        prefix,
-    } = CloudCmd;
     
     const ONE_MINUTE = 60 * 1000;
     
-    const socket = io.connect(href + prefixSocket + '/config', {
+    const socket = globalThis.io.connect(href + prefixSocket + '/config', {
         reconnectionAttempts: Infinity,
         reconnectionDelay: ONE_MINUTE,
-        path: prefix + '/socket.io',
+        path: `${prefix}/socket.io`,
     });
     
     const save = (data) => {
@@ -125,9 +113,7 @@ function authCheck(socket) {
 
 Config.save = saveHttp;
 
-module.exports.show = show;
+export async function show() {
-
-async function show() {
     if (!CloudCmd.config('configDialog'))
         return;
     
@@ -142,21 +128,27 @@ async function fillTemplate() {
     
     const {
         editor,
+        menu,
         packer,
         columns,
+        theme,
         configAuth,
+        configPort,
         ...obj
     } = input.convert(config);
     
-    obj[editor + '-selected'] = 'selected';
+    obj[`${menu}-selected`] = 'selected';
-    obj[packer + '-selected'] = 'selected';
+    obj[`${editor}-selected`] = 'selected';
-    obj[columns + '-selected'] = 'selected';
+    obj[`${packer}-selected`] = 'selected';
+    obj[`${columns}-selected`] = 'selected';
+    obj[`${theme}-selected`] = 'selected';
     obj.configAuth = configAuth ? '' : 'hidden';
+    obj.configPort = configPort ? '' : 'hidden';
     
     const innerHTML = rendy(Template, obj);
     
     Element = createElement('form', {
-        className   : 'config',
+        className: 'config',
         innerHTML,
     });
     
@@ -173,20 +165,20 @@ async function fillTemplate() {
     const getTarget = ({target}) => target;
     const handleChange = squad(onChange, getTarget);
     
-    Array.from(inputs)
+    Array
+        .from(inputs)
         .map(addKey(onKey))
         .map(addChange(handleChange));
     
     const autoSize = true;
+    
     CloudCmd.View.show(Element, {
         autoSize,
         afterShow,
     });
 }
 
-module.exports.hide = hide;
+export function hide() {
-
-function hide() {
     CloudCmd.View.hide();
 }
 
@@ -228,7 +220,7 @@ function onAuthChange(checked) {
     const elUsername = input.getElementByName('username', Element);
     const elPassword = input.getElementByName('password', Element);
     
-    elUsername.disabled =
+    elUsername.disabled = !checked;
     elPassword.disabled = !checked;
 }
 
@@ -238,13 +230,18 @@ function onNameChange(name) {
     }));
 }
 
-function onKey({keyCode, target}) {
+async function onKey({keyCode, target}) {
     switch(keyCode) {
     case Key.ESC:
         return hide();
     
     case Key.ENTER:
-        return onChange(target);
+        return await onChange(target);
     }
 }
 
+CloudCmd[Name] = {
+    init,
+    show,
+    hide,
+};

client/modules/config/input.js

@@ -1,23 +1,17 @@
-'use strict';
+import {encode} from '#common/entity';
 
-const currify = require('currify');
+const isBool = (a) => typeof a === 'boolean';
+const isString = (a) => typeof a === 'string';
 
-const isType = currify((type, object, name) => {
+const {keys} = Object;
-    return typeof object[name] === type;
-});
 
-const isBool = isType('boolean');
+export function getElementByName(selector, element) {
-
-module.exports.getElementByName = getElementByName;
-
-function getElementByName(selector, element) {
     const str = `[data-name="js-${selector}"]`;
     
-    return element
+    return element.querySelector(str);
-        .querySelector(str);
 }
 
-module.exports.getName = (element) => {
+export const getName = (element) => {
     const name = element
         .getAttribute('data-name')
         .replace(/^js-/, '');
@@ -25,17 +19,21 @@ module.exports.getName = (element) => {
     return name;
 };
 
-module.exports.convert = (config) => {
+export const convert = (config) => {
-    const result = {
+    const result = config;
-        ...config,
-    };
-    const array = Object.keys(config);
     
-    const filtered = array.filter(isBool(config));
+    for (const name of keys(config)) {
-    
-    for (const name of filtered) {
         const item = config[name];
-        result[name] = setState(item);
+        
+        if (isBool(item)) {
+            result[name] = setState(item);
+            continue;
+        }
+        
+        if (isString(item)) {
+            result[name] = encode(item);
+            continue;
+        }
     }
     
     return result;
@@ -48,7 +46,7 @@ function setState(state) {
     return '';
 }
 
-module.exports.getValue = (name, element) => {
+export const getValue = (name, element) => {
     const el = getElementByName(name, element);
     const {type} = el;
     
@@ -64,7 +62,7 @@ module.exports.getValue = (name, element) => {
     }
 };
 
-module.exports.setValue = (name, value, element) => {
+export const setValue = (name, value, element) => {
     const el = getElementByName(name, element);
     const {type} = el;
     
@@ -78,4 +76,3 @@ module.exports.setValue = (name, value, element) => {
         break;
     }
 };
-

client/modules/config/input.spec.js

@@ -0,0 +1,140 @@
+import {test, stub} from 'supertape';
+import {
+    convert,
+    getName,
+    getValue,
+    setValue,
+} from './input.js';
+
+test('cloudcmd: client: config: input: convert', (t) => {
+    const result = convert({
+        name: 'hello <world>',
+    });
+    
+    const expected = {
+        name: 'hello &lt;world&gt;',
+    };
+    
+    t.deepEqual(result, expected);
+    t.end();
+});
+
+test('cloudcmd: client: config: input: convert: bool', (t) => {
+    const result = convert({
+        auth: true,
+    });
+    
+    const expected = {
+        auth: ' checked',
+    };
+    
+    t.deepEqual(result, expected);
+    t.end();
+});
+
+test('cloudcmd: client: config: input: convert: bool false', (t) => {
+    const result = convert({
+        auth: false,
+    });
+    
+    const expected = {
+        auth: '',
+    };
+    
+    t.deepEqual(result, expected);
+    t.end();
+});
+
+test('cloudcmd: client: config: input: getName', (t) => {
+    const getAttribute = stub().returns('js-hello');
+    const element = {
+        getAttribute,
+    };
+    
+    const result = getName(element);
+    
+    t.equal(result, 'hello', 'should strip js- prefix');
+    t.end();
+});
+
+test('cloudcmd: client: config: input: getValue: checkbox', (t) => {
+    const querySelector = stub().returns({
+        type: 'checkbox',
+        checked: true,
+    });
+    
+    const element = {
+        querySelector,
+    };
+    
+    const result = getValue('auth', element);
+    
+    t.ok(result, 'should return checked value');
+    t.end();
+});
+
+test('cloudcmd: client: config: input: getValue: number', (t) => {
+    const querySelector = stub().returns({
+        type: 'number',
+        value: '42',
+    });
+    
+    const element = {
+        querySelector,
+    };
+    
+    const result = getValue('port', element);
+    
+    t.equal(result, 42, 'should return number');
+    t.end();
+});
+
+test('cloudcmd: client: config: input: getValue: default', (t) => {
+    const querySelector = stub().returns({
+        type: 'text',
+        value: 'hello',
+    });
+    
+    const element = {
+        querySelector,
+    };
+    
+    const result = getValue('name', element);
+    
+    t.equal(result, 'hello', 'should return value as is');
+    t.end();
+});
+
+test('cloudcmd: client: config: input: setValue: checkbox', (t) => {
+    const el = {
+        type: 'checkbox',
+        checked: false,
+    };
+    
+    const querySelector = stub().returns(el);
+    const element = {
+        querySelector,
+    };
+    
+    setValue('auth', true, element);
+    
+    t.ok(el.checked, 'should set checked');
+    t.end();
+});
+
+test('cloudcmd: client: config: input: setValue: default', (t) => {
+    const el = {
+        type: 'text',
+        value: 'old',
+    };
+    
+    const querySelector = stub().returns(el);
+    const element = {
+        querySelector,
+    };
+    
+    setValue('name', 'new', element);
+    
+    t.equal(el.value, 'new', 'should set value');
+    t.end();
+});

client/modules/contact.js

@@ -1,36 +1,34 @@
 /* global CloudCmd */
 /* global DOM */
+import olark from '@cloudcmd/olark';
+import * as Images from '#dom/images';
 
-'use strict';
+CloudCmd.Contact = {
-
+    init,
-CloudCmd.Contact = exports;
+    show,
-
+    hide,
-const olark = require('@cloudcmd/olark');
+};
-const Images = require('../dom/images');
 
 const {Events} = DOM;
 const {Key} = CloudCmd;
 
-module.exports.show = show;
+export function init() {
-module.exports.hide = hide;
-
-module.exports.init = () => {
     Events.addKey(onKey);
     
     olark.identify('6216-545-10-4223');
     olark('api.box.onExpand', show);
     olark('api.box.onShow', show);
     olark('api.box.onShrink', hide);
-};
+}
 
-function show() {
+export function show() {
     Key.unsetBind();
     Images.hide();
     
     olark('api.box.expand');
 }
 
-function hide() {
+export function hide() {
     Key.setBind();
     olark('api.box.hide');
 }
@@ -39,4 +37,3 @@ function onKey({keyCode}) {
     if (keyCode === Key.ESC)
         hide();
 }
-