jeans/arduino-ide
jeans/arduino-ide
1
0
Fork 0
mirror of https://github.com/arduino/arduino-ide.git synced 2025-07-09 04:16:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

build: use a local npm registry for app packaging

Browse Source 
Signed-off-by: Akos Kitta <a.kitta@arduino.cc>
This commit is contained in:
Akos Kitta 2022-12-08 16:37:12 +01:00 committed by Akos Kitta
parent 908ec4c544
commit 1d342cdbd0
12 changed files with 4021 additions and 2287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.eslintrc.js
View File

@ -15,7 +15,6 @@ module.exports = {
'.browser_modules/*',
'docs/*',
'scripts/*',
'electron/*',
'electron-app/*',
'plugins/*',
'arduino-ide-extension/src/node/cli-protocol',

2
arduino-ide-extension/src/browser/dialogs/cloud-share-sketch-dialog.tsx
View File

@ -2,7 +2,7 @@ import * as React from '@theia/core/shared/react';
import { inject, injectable } from '@theia/core/shared/inversify';
import { Widget } from '@theia/core/shared/@phosphor/widgets';
import { Message } from '@theia/core/shared/@phosphor/messaging';
import { clipboard } from 'electron';
import { clipboard } from '@theia/core/electron-shared/@electron/remote';
import { ReactWidget, DialogProps } from '@theia/core/lib/browser';
import { AbstractDialog } from '../theia/dialogs/dialogs';
import { CreateApi } from '../create/create-api';

2
arduino-ide-extension/src/browser/widgets/cloud-sketchbook/cloud-sketchbook-tree-widget.tsx
View File

@ -9,7 +9,7 @@ import { CloudUserCommands } from '../../auth/cloud-user-commands';
import { NodeProps } from '@theia/core/lib/browser/tree/tree-widget';
import { TreeNode } from '@theia/core/lib/browser/tree';
import { CompositeTreeNode } from '@theia/core/lib/browser';
import { shell } from 'electron';
import { shell } from '@theia/core/electron-shared/@electron/remote';
import { SketchbookTreeWidget } from '../sketchbook/sketchbook-tree-widget';
import { nls } from '@theia/core/lib/common';

17
electron/.gitignore vendored
View File

@ -1,22 +1,15 @@
# The working-copy folder we use to package the application.
working-copy/
# Ignore all Theia generated things.
*.log
src-gen/
node_modules/
build/yarn.lock
webpack.config.js
lib/
# The electron-builder output.
dist/
# `dotenv` can provide dynamic input for the elecrton-builder. e.g.: commitish for the build.
electron-builder.env
# The generated `package.json` under the `build` folder.
# The generated `package.json` and lock file under the `build` folder.
build/package.json
build/yarn.lock
# Resources the packager copies from dev to prod
build/resources/preload.html
# For the private npm package registry
packager/npm-registry/storage

1
electron/build/template-package.json
View File

@ -21,7 +21,6 @@
"build": "yarn download:plugins && theia build --mode production && yarn patch",
"rebuild": "yarn theia rebuild:electron",
"package": "cross-env DEBUG=* && electron-builder --publish=never",
"package:publish": "cross-env DEBUG=* && electron-builder --publish=always",
"download:plugins": "theia download:plugins",
"patch": "ncp ./patch/backend/main.js ./src-gen/backend/main.js"
},

464
electron/packager/index.js
View File

@ -1,9 +1,31 @@
//@ts-check
(async () => {
const toDispose = [];
const disposeAll = () => {
let disposable = toDispose.pop();
while (disposable) {
try {
disposable();
} catch (err) {
console.error(err);
}
disposable = toDispose.pop();
}
};
process.on('uncaughtException', (error) => {
disposeAll();
throw error;
});
process.on('unhandledRejection', (reason) => {
disposeAll();
throw reason;
});
const fs = require('fs');
const join = require('path').join;
const shell = require('shelljs');
const { echo, cp, mkdir, mv, rm } = shell;
shell.config.fatal = true;
const glob = require('glob');
const isCI = require('is-ci');
// Note, this will crash on PI if the available memory is less than desired heap size.
@ -21,175 +43,124 @@
echo(`📦 Building ${isRelease ? 'release ' : ''}version '${version}'...`);
const workingCopy = 'working-copy';
const repoRoot = join(__dirname, '..', '..');
/**
* Relative path from the `__dirname` to the root where the `arduino-ide-extension` and the `electron-app` folders are.
* This could come handy when moving the location of the `electron/packager`.
* Extensions are expected to be folders directly available from the repository root.
*/
const rootPath = join('..', '..');
// This is a HACK! We rename the root `node_modules` to something else. Otherwise, due to the hoisting,
// multiple Theia extensions will be picked up.
if (fs.existsSync(path(rootPath, 'node_modules'))) {
// We either do this or change the project structure.
echo(
"🔧 >>> [Hack] Renaming the root 'node_modules' folder to '.node_modules'..."
);
mv('-f', path(rootPath, 'node_modules'), path(rootPath, '.node_modules'));
echo(
"👌 <<< [Hack] Renamed the root 'node_modules' folder to '.node_modules'."
);
}
try {
//---------------------------+
// Clean the previous state. |
//---------------------------+
// rm -rf ../working-copy
rm('-rf', path('..', workingCopy));
// Clean up the `./electron/build` folder.
const resourcesToKeep = [
'patch',
'resources',
'scripts',
'template-package.json'
];
fs.readdirSync(path('..', 'build'))
.filter((filename) => resourcesToKeep.indexOf(filename) === -1)
.forEach((filename) => rm('-rf', path('..', 'build', filename)));
// Clean up the `./electron/build/resources` folder with Git.
// To avoid file duplication between bundled app and dev mode, some files are copied from `./electron-app` to `./electron/build` folder.
const foldersToSyncFromDev = ['resources'];
foldersToSyncFromDev.forEach((filename) =>
shell.exec(`git -C ${path('..', 'build', filename)} clean -ffxdq`, {
async: false,
})
);
const extensions = require('./extensions.json');
echo(
`Building the application with the following extensions:\n${extensions
.map((ext) => ` - ${ext}`)
.join(',\n')}`
);
const allDependencies = [...extensions, 'electron-app'];
//----------------------------------------------------------------------------------------------+
// Copy the following items into the `working-copy` folder. Make sure to reuse the `yarn.lock`. |
//----------------------------------------------------------------------------------------------+
mkdir('-p', path('..', workingCopy));
for (const filename of [
...allDependencies,
'yarn.lock',
'package.json',
'lerna.json',
'i18n',
]) {
cp('-rf', path(rootPath, filename), path('..', workingCopy));
try {
//---------------------------+
// Clean the previous state. |
//---------------------------+
// Clean up the `./electron/build` folder.
const resourcesToKeep = [
'patch',
'resources',
'scripts',
'template-package.json',
];
fs.readdirSync(join(repoRoot, 'electron', 'build'))
.filter((filename) => resourcesToKeep.indexOf(filename) === -1)
.forEach((filename) =>
rm('-rf', join(repoRoot, 'electron', 'build', filename))
);
// Clean up the `./electron/build/resources` folder with Git.
// To avoid file duplication between bundled app and dev mode, some files are copied from `./electron-app` to `./electron/build` folder.
const foldersToSyncFromDev = ['resources'];
foldersToSyncFromDev.forEach((filename) =>
shell.exec(
`git -C ${join(repoRoot, 'electron', 'build', filename)} clean -ffxdq`,
{
async: false,
}
)
);
//---------------------------------------------------------------------------------------------+
// Copy the patched `index.js` for the frontend, the Theia preload, etc. from `./electron-app` |
//---------------------------------------------------------------------------------------------+
//----------------------------------------------------+
// Copy the Theia preload, etc. from `./electron-app` |
//----------------------------------------------------+
for (const filename of foldersToSyncFromDev) {
cp(
'-rf',
path('..', workingCopy, 'electron-app', filename),
path('..', 'build')
join(repoRoot, 'electron-app', filename),
join(repoRoot, 'electron', 'build')
);
}
//----------------------------------------------+
// Sanity check: all versions must be the same. |
//----------------------------------------------+
verifyVersions(allDependencies);
verifyVersions(extensions);
//----------------------------------------------------------------------+
// Use the nightly patch version if not a release but requires publish. |
//----------------------------------------------------------------------+
if (!isRelease) {
for (const dependency of allDependencies) {
const pkg = require(`../working-copy/${dependency}/package.json`);
pkg.version = version;
for (const dependency in pkg.dependencies) {
if (allDependencies.indexOf(dependency) !== -1) {
pkg.dependencies[dependency] = version;
}
}
fs.writeFileSync(
path('..', workingCopy, dependency, 'package.json'),
JSON.stringify(pkg, null, 2)
);
}
}
verifyVersions(allDependencies);
//---------------------------------------------------------------------------------------------------+
// Save some time: no need to build the projects that are not needed in final app. Currently unused. |
//---------------------------------------------------------------------------------------------------+
//@ts-ignore
const rootPackageJson = require('../working-copy/package.json');
const workspaces = rootPackageJson.workspaces;
// We cannot remove the `electron-app`. Otherwise, there is not way to collect the unused dependencies.
const dependenciesToRemove = [];
for (const dependencyToRemove of dependenciesToRemove) {
const index = workspaces.indexOf(dependencyToRemove);
if (index !== -1) {
workspaces.splice(index, 1);
}
}
rootPackageJson.workspaces = workspaces;
fs.writeFileSync(
path('..', workingCopy, 'package.json'),
JSON.stringify(rootPackageJson, null, 2)
);
//-------------------------------------------------------------------------------------------------+
// Rebuild the extension with the copied `yarn.lock`. It is a must to use the same Theia versions. |
//-------------------------------------------------------------------------------------------------+
exec(
`yarn --network-timeout 1000000 --cwd ${path('..', workingCopy)}`,
`Building the ${productName} application`
);
//-------------------------------------------------------------------------------------------------------------------------+
// Test the application. With this approach, we cannot publish test results to GH Actions but save 6-10 minutes per builds |
//-------------------------------------------------------------------------------------------------------------------------+
exec(
`yarn --network-timeout 1000000 --cwd ${path('..', workingCopy)} test`,
`Testing the ${productName} application`
);
//-------------------------------------------------------------------------------------------------------------+
// Change the regular NPM dependencies to `local-paths`, so that we can build them without any NPM registries. |
//-------------------------------------------------------------------------------------------------------------+
//-------------------------------+
// Build and test the extensions |
//-------------------------------+
for (const extension of extensions) {
if (extension !== 'arduino-ide-extension') {
// Do not unlink self.
// @ts-ignore
rootPackageJson = require(`../working-copy/${extension}/package.json`);
// @ts-ignore
rootPackageJson.dependencies['arduino-ide-extension'] =
'file:../arduino-ide-extension';
fs.writeFileSync(
path('..', workingCopy, extension, 'package.json'),
JSON.stringify(rootPackageJson, null, 2)
exec(
`yarn --network-timeout 1000000 --cwd ${join(repoRoot, extension)}`,
`Building and testing ${extension}`
);
}
//------------------------+
// Publish the extensions |
//------------------------+
const npmrc = join(repoRoot, '.npmrc');
const storage = join(__dirname, 'npm-registry', 'storage');
rm('-rf', npmrc);
rm('-rf', storage);
// To avoid interactive npm login on the CI when publishing to the private registry.
// The actual token is fake and does not matter as the publishing is `$anonymous` anyway.
fs.writeFileSync(npmrc, '//localhost:4873/:_authToken=placeholder\n', {
encoding: 'utf8',
});
toDispose.push(() => rm('-rf', storage));
toDispose.push(() => rm('-rf', npmrc));
const npmProxyProcess = await startNpmRegistry(
join(__dirname, 'npm-registry', 'config.yml')
);
toDispose.push(() => {
if (!npmProxyProcess.killed) {
npmProxyProcess.kill();
}
});
for (const extension of extensions) {
const packageJsonPath = join(repoRoot, extension, 'package.json');
const versionToRestore = readJson(packageJsonPath).version;
exec(
`yarn --network-timeout 1000000 --cwd ${join(
repoRoot,
extension
)} publish --ignore-scripts --new-version ${version} --no-git-tag-version --registry http://localhost:4873`,
`Publishing ${extension}@${version} to the private npm registry`
);
// Publishing will change the version number, this should be reverted up after the build.
// A git checkout or reset could be easier, but this is safer to avoid wiping uncommitted dev state.
toDispose.push(() => {
const json = readJson(packageJsonPath);
json.version = versionToRestore;
writeJson(packageJsonPath, json);
});
}
//------------------------------------------------------------------------------------+
// Merge the `working-copy/package.json` with `electron/build/template-package.json`. |
//------------------------------------------------------------------------------------+
// @ts-ignore
const appPackageJson = require('../working-copy/electron-app/package.json');
//-----------------------------------------------------------------------------------------------------------+
// Merge the `./package.json` and `./electron-app/package.json` with `electron/build/template-package.json`. |
//-----------------------------------------------------------------------------------------------------------+
const rootPackageJson = readJson(join(repoRoot, 'package.json'));
const appPackageJson = readJson(
join(repoRoot, 'electron-app', 'package.json')
);
const dependencies = {};
for (const extension of extensions) {
dependencies[extension] = `file:../working-copy/${extension}`;
dependencies[extension] = version;
}
// @ts-ignore
appPackageJson.dependencies = {
...appPackageJson.dependencies,
...dependencies,
@ -199,80 +170,115 @@
...template.devDependencies,
};
// Deep-merging the Theia application configuration.
// @ts-ignore
const theia = merge(appPackageJson.theia || {}, template.theia || {});
const content = {
...appPackageJson,
...template,
theia,
// @ts-ignore
dependencies: appPackageJson.dependencies,
devDependencies: appPackageJson.devDependencies,
// VS Code extensions and the plugins folder is defined in the top level `package.json`. The template picks them up.
// VS Code extensions and the plugins folder is defined in the root `package.json`. The template picks them up.
theiaPluginsDir: rootPackageJson.theiaPluginsDir,
theiaPlugins: rootPackageJson.theiaPlugins,
};
fs.writeFileSync(
path('..', 'build', 'package.json'),
JSON.stringify(
writeJson(
join(repoRoot, 'electron', 'build', 'package.json'),
merge(content, template, {
arrayMerge: (_, sourceArray) => sourceArray,
}),
null,
2
)
})
);
echo(`📜 Effective 'package.json' for the ${productName} application is:
echo(`📜 Effective 'package.json' for the ${productName} application:
-----------------------
${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
${fs
.readFileSync(join(repoRoot, 'electron', 'build', 'package.json'))
.toString()}
-----------------------
`);
// Make sure the original `yarn.lock` file is used from the electron application.
if (fs.existsSync(path('..', 'build', 'yarn.lock'))) {
echo(`${path('..', 'build', 'yarn.lock')} must not exist.`);
if (fs.existsSync(join(repoRoot, 'electron', 'build', 'yarn.lock'))) {
echo(
`${join(repoRoot, 'electron', 'build', 'yarn.lock')} must not exist.`
);
shell.exit(1);
}
cp('-rf', path(rootPath, 'yarn.lock'), path('..', 'build'));
if (!fs.existsSync(path('..', 'build', 'yarn.lock'))) {
echo(`${path('..', 'build', 'yarn.lock')} does not exist.`);
cp('-rf', join(repoRoot, 'yarn.lock'), join(repoRoot, 'electron', 'build'));
if (!fs.existsSync(join(repoRoot, 'electron', 'build', 'yarn.lock'))) {
echo(
`${join(repoRoot, 'electron', 'build', 'yarn.lock')} does not exist.`
);
shell.exit(1);
}
// This is a HACK! We rename the root `node_modules` to something else. Otherwise, due to the hoisting,
// multiple Theia extensions will be picked up.
if (fs.existsSync(join(repoRoot, 'node_modules'))) {
// We either do this or change the project structure.
echo(
"🔧 >>> [Hack] Renaming the root 'node_modules' folder to '.node_modules'..."
);
mv('-f', join(repoRoot, 'node_modules'), join(repoRoot, '.node_modules'));
echo(
"👌 <<< [Hack] Renamed the root 'node_modules' folder to '.node_modules'."
);
}
toDispose.push(() => {
if (fs.existsSync(join(repoRoot, '.node_modules'))) {
echo(
"🔧 >>> [Restore] Renaming the root '.node_modules' folder to 'node_modules'..."
);
mv(
'-f',
join(repoRoot, '.node_modules'),
join(repoRoot, 'node_modules')
);
echo(
"👌 >>> [Restore] Renamed the root '.node_modules' folder to 'node_modules'."
);
}
});
//-------------------------------------------------------------------------------------------+
// Install all private and public dependencies for the electron application and build Theia. |
//-------------------------------------------------------------------------------------------+
exec(
`yarn --network-timeout 1000000 --cwd ${path('..', 'build')}`,
`yarn --network-timeout 1000000 --cwd ${join(
repoRoot,
'electron',
'build'
)} --registry http://localhost:4873`,
'Installing dependencies'
);
exec(
`yarn --network-timeout 1000000 --cwd ${path('..', 'build')} build`,
`yarn --cwd ${join(repoRoot, 'electron', 'build')} build`,
`Building the ${productName} application`
);
exec(
`yarn --network-timeout 1000000 --cwd ${path('..', 'build')} rebuild`,
'Rebuild native dependencies'
`yarn --cwd ${join(repoRoot, 'electron', 'build')} rebuild`,
'Rebuilding native dependencies'
);
//------------------------------------------------------------------------------+
// Create a throw away dotenv file which we use to feed the builder with input. |
//------------------------------------------------------------------------------+
const dotenv = 'electron-builder.env';
if (fs.existsSync(path('..', 'build', dotenv))) {
rm('-rf', path('..', 'build', dotenv));
if (fs.existsSync(join(repoRoot, 'electron', 'build', dotenv))) {
rm('-rf', join(repoRoot, 'electron', 'build', dotenv));
}
// For the releases we use the desired tag as is defined by `$(Release.Tag)` from Azure.
// For the preview builds we use the version from the `electron/build/package.json` with the short commit hash.
fs.writeFileSync(path('..', 'build', dotenv), `ARDUINO_VERSION=${version}`);
fs.writeFileSync(
join(repoRoot, 'electron', 'build', dotenv),
`ARDUINO_VERSION=${version}`
);
//-----------------------------------+
// Package the electron application. |
//-----------------------------------+
exec(
`yarn --network-timeout 1000000 --cwd ${path('..', 'build')} package`,
`Packaging your ${productName} application`
`yarn --cwd ${join(repoRoot, 'electron', 'build')} package`,
`Packaging the ${productName} application`
);
//-----------------------------------------------------------------------------------------------------+
@ -288,9 +294,16 @@ ${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
shell.exit(1);
}
}
echo(`🎉 Success. Your application is at: ${path('..', 'build', 'dist')}`);
echo(
`🎉 Success. The application is at: ${join(
repoRoot,
'electron',
'build',
'dist'
)}`
);
} finally {
restore();
disposeAll();
}
//--------+
@ -300,67 +313,24 @@ ${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
if (toEcho) {
echo(`⏱️ >>> ${toEcho}...`);
}
const { code, stderr, stdout } = shell.exec(command);
if (code !== 0) {
echo(`🔥 Error when executing ${command} => ${stderr}`);
shell.exit(1);
}
const { stdout } = shell.exec(command);
if (toEcho) {
echo(`👌 <<< ${toEcho}.`);
}
return stdout;
}
function cp(options, source, destination) {
shell.cp(options, source, destination);
assertNoError();
}
function rm(options, ...files) {
shell.rm(options, files);
assertNoError();
}
function mv(options, source, destination) {
shell.mv(options, source, destination);
assertNoError();
}
function mkdir(options, ...dir) {
shell.mkdir(options, dir);
assertNoError();
}
function echo(command) {
return shell.echo(command);
}
function assertNoError() {
const error = shell.error();
if (error) {
echo(error);
restore();
shell.exit(1);
}
}
function restore() {
if (fs.existsSync(path(rootPath, '.node_modules'))) {
echo(
"🔧 >>> [Restore] Renaming the root '.node_modules' folder to 'node_modules'..."
);
mv('-f', path(rootPath, '.node_modules'), path(rootPath, 'node_modules'));
echo(
"👌 >>> [Restore] Renamed the root '.node_modules' folder to 'node_modules'."
);
}
}
async function copyFilesToBuildArtifacts() {
echo(`🚢 Detected CI, moving build artifacts...`);
const { platform } = process;
const cwd = path('..', 'build', 'dist');
const targetFolder = path('..', 'build', 'dist', 'build-artifacts');
const cwd = join(repoRoot, 'electron', 'build', 'dist');
const targetFolder = join(
repoRoot,
'electron',
'build',
'dist',
'build-artifacts'
);
mkdir('-p', targetFolder);
const filesToCopy = [];
const channelFile = getChannelFile(platform);
@ -425,7 +395,7 @@ ${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
async function recalculateArtifactsHash() {
echo(`🚢 Detected CI, recalculating artifacts hash...`);
const { platform } = process;
const cwd = path('..', 'build', 'dist');
const cwd = join(repoRoot, 'electron', 'build', 'dist');
const channelFilePath = join(cwd, getChannelFile(platform));
const yaml = require('yaml');
@ -464,14 +434,14 @@ ${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
* @param {BufferEncoding|undefined} [encoding="base64"]
* @param {object|undefined} [options]
*/
async function hashFile(
function hashFile(
file,
algorithm = 'sha512',
encoding = 'base64',
options
) {
const crypto = require('crypto');
return await new Promise((resolve, reject) => {
return new Promise((resolve, reject) => {
const hash = crypto.createHash(algorithm);
hash.on('error', reject).setEncoding(encoding);
fs.createReadStream(
@ -493,17 +463,14 @@ ${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
}
/**
* Joins tha path from `__dirname`.
* @param {string[]} allDependencies
* @param {string} [expectedVersion]
*/
function path(...paths) {
return join(__dirname, ...paths);
}
function verifyVersions(allDependencies, expectedVersion) {
const versions = new Set();
for (const dependency of allDependencies) {
versions.add(
require(`../working-copy/${dependency}/package.json`).version
readJson(join(repoRoot, dependency, 'package.json')).version
);
}
if (versions.size !== 1) {
@ -527,4 +494,41 @@ ${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
}
}
}
/**
* @param {string} configPath
* @return {Promise<import('child_process').ChildProcess>}
*/
function startNpmRegistry(configPath) {
return new Promise((resolve, reject) => {
const fork = require('child_process').fork(
require.resolve('verdaccio/bin/verdaccio'),
['-c', configPath]
);
fork.on('message', (msg) => {
if (typeof msg === 'object' && 'verdaccio_started' in msg) {
resolve(fork);
}
});
fork.on('error', reject);
fork.on('disconnect', reject);
});
}
/**
* @param {string} path
* @param {object} jsonObject
*/
function writeJson(path, jsonObject) {
fs.writeFileSync(path, JSON.stringify(jsonObject, null, 2) + '\n');
}
/**
* @param {string} path
* @return {object}
*/
function readJson(path) {
const raw = fs.readFileSync(path, { encoding: 'utf8' });
return JSON.parse(raw);
}
})();

19
electron/packager/npm-registry/config.yml Normal file
View File

@ -0,0 +1,19 @@
storage: ./storage
uplinks:
npmjs:
url: 'https://registry.npmjs.org/'
packages:
'**':
access: $all
publish: $anonymous
unpublish: $anonymous
proxy: npmjs
server:
keepAliveTimeout: 60
listen:
- 'localhost:4873'
max_body_size: 100mb
log:
type: stdout
format: pretty
level: warn

3
electron/packager/package.json
View File

@ -13,9 +13,9 @@
"author": "Arduino SA",
"license": "AGPL-3.0-or-later",
"dependencies": {
"7zip-min": "^1.1.1",
"@types/file-type": "^10.9.1",
"@types/temp": "^0.8.32",
"7zip-min": "^1.1.1",
"chai": "^4.2.0",
"crypto": "^1.0.1",
"dateformat": "^3.0.3",
@ -28,6 +28,7 @@
"shelljs": "^0.8.3",
"sinon": "^9.0.1",
"temp": "^0.9.1",
"verdaccio": "6-next",
"yaml": "^1.10.2",
"yargs": "^12.0.5"
},

38
electron/packager/test/utils.test.js
View File

@ -7,13 +7,13 @@ const testMe = require('../utils');
const sinon = require('sinon');
describe('utils', () => {
describe('adjustArchiveStructure', () => {
let consoleStub;
beforeEach(() => {
consoleStub = sinon.stub(console, 'log').value(() => { });
consoleStub = sinon.stub(console, 'log').value(() => {
/* NOOP */
});
});
afterEach(() => {
@ -34,8 +34,15 @@ describe('utils', () => {
it('should reject when target directory does not exist', async () => {
try {
const zip = path.join(__dirname, 'resources', 'zip-with-base-folder.zip');
await testMe.adjustArchiveStructure(zip, path.join(__dirname, 'some', 'missing', 'path'));
const zip = path.join(
__dirname,
'resources',
'zip-with-base-folder.zip'
);
await testMe.adjustArchiveStructure(
zip,
path.join(__dirname, 'some', 'missing', 'path')
);
throw new Error('Expected a rejection');
} catch (e) {
expect(e).to.be.an.instanceOf(Error);
@ -45,7 +52,11 @@ describe('utils', () => {
it('should reject when target is a file', async () => {
try {
const zip = path.join(__dirname, 'resources', 'zip-with-base-folder.zip');
const zip = path.join(
__dirname,
'resources',
'zip-with-base-folder.zip'
);
await testMe.adjustArchiveStructure(zip, path.join(__filename));
throw new Error('Expected a rejection');
} catch (e) {
@ -56,7 +67,10 @@ describe('utils', () => {
it('should be a NOOP when the zip already has the desired base folder', async () => {
const zip = path.join(__dirname, 'resources', 'zip-with-base-folder.zip');
const actual = await testMe.adjustArchiveStructure(zip, track.mkdirSync());
const actual = await testMe.adjustArchiveStructure(
zip,
track.mkdirSync()
);
expect(actual).to.be.equal(zip);
});
@ -92,7 +106,13 @@ describe('utils', () => {
const verifyOut = track.mkdirSync();
await unpack(actual, verifyOut);
expect(fs.lstatSync(path.join(verifyOut, 'zip-with-symlink', 'folder', 'symlinked-sub')).isSymbolicLink()).to.be.true;
expect(
fs
.lstatSync(
path.join(verifyOut, 'zip-with-symlink', 'folder', 'symlinked-sub')
)
.isSymbolicLink()
).to.be.true;
});
it('should adjust the archive structure if base folder is not present', async () => {
@ -113,7 +133,5 @@ describe('utils', () => {
expect(subs).to.have.lengthOf(3);
expect(subs.sort()).to.be.deep.equal(['a.txt', 'b.txt', 'foo']);
});
});
});

1881
electron/packager/yarn.lock
View File

File diff suppressed because it is too large Load Diff

5
package.json
View File

@ -25,7 +25,7 @@
"husky": "^6.0.0",
"ignore-styles": "^5.0.1",
"jsdom": "^11.5.1",
"lerna": "^3.20.2",
"lerna": "^6.1.0",
"lint-staged": "^11.0.0",
"node-gyp": "^9.3.0",
"prettier": "^2.3.1",
@ -38,8 +38,7 @@
},
"resolutions": {
"@types/react": "18.0.0",
"@types/react-dom": "18.0.0",
"electron-rebuild": "3.2.9"
"@types/react-dom": "18.0.0"
},
"scripts": {
"prepare": "lerna run prepare && yarn download:plugins",

3883
yarn.lock
View File

File diff suppressed because it is too large Load Diff