@nordicsemiconductor/pc-nrfconnect-shared 60.0.0-pre1

package/scripts/check-app-properties.ts

@@ -0,0 +1,197 @@
+#!/usr/bin/env ts-node
+
+/*
+ * Copyright (c) 2022 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import property from 'lodash/property';
+
+import { PackageJson } from '../src/utils/AppTypes';
+
+const format = (strings: string[]) =>
+    strings.map(string => `\`${string}\``).join(', ');
+
+const propertyIsMissing = (obj: unknown) => (propertyPath: string) => {
+    const value = property(propertyPath)(obj);
+    return value == null || value === '';
+};
+
+const fail = (message: string) => {
+    console.error(message);
+    process.exit(1);
+};
+
+const warn = (message: string) => {
+    console.warn(message);
+};
+
+const mustBeEmpty = (array: string[], errorMessage: string) => {
+    if (array.length !== 0) {
+        fail(`${errorMessage}: ${format(array)}`);
+    }
+};
+
+const mustContain = (
+    existingEntries: readonly string[],
+    mandatoryEntries: string[],
+    errorMessage: string
+) => {
+    const missingFileEntries = mandatoryEntries.filter(
+        entry => !existingEntries.includes(entry)
+    );
+
+    mustBeEmpty(missingFileEntries, errorMessage);
+};
+
+const mustContainOneOf = (
+    existingEntries: readonly string[],
+    oneOfTheseEntriesIsMandatory: string[],
+    errorMessage: string
+) => {
+    if (
+        !oneOfTheseEntriesIsMandatory.some(entry =>
+            existingEntries.includes(entry)
+        )
+    ) {
+        fail(`${errorMessage}: ${format(oneOfTheseEntriesIsMandatory)}`);
+    }
+};
+
+const checkMandatoryProperties = (packageJson: PackageJson) => {
+    const mandatoryProperties = [
+        `name`,
+        `version`,
+        `description`,
+        `displayName`,
+        `engines.nrfconnect`,
+    ];
+
+    const missingProperties = mandatoryProperties.filter(
+        propertyIsMissing(packageJson)
+    );
+
+    mustBeEmpty(
+        missingProperties,
+        'package.json is missing these mandatory properties'
+    );
+};
+
+const checkOptionalProperties = (packageJson: PackageJson) => {
+    if (propertyIsMissing(packageJson)('homepage')) {
+        warn('Please provide a property `homepage` in package.json.');
+    }
+
+    if (propertyIsMissing(packageJson)('repository.url')) {
+        warn('Please provide a property `repository.url` in package.json.');
+    } else if (existsSync('./.git')) {
+        const realGitUrl = execSync('git remote get-url origin', {
+            encoding: 'utf-8',
+        }).trimEnd();
+        const declaredGitUrl = packageJson.repository?.url;
+
+        const withoutPostfix = (gitUrl?: string) =>
+            gitUrl?.replace(/\.git$/, '');
+
+        const withoutProtocol = (gitUrl?: string) =>
+            gitUrl
+                ?.replace(/^git@github\.com:/, 'github.com/')
+                .replace(/^https:\/\//, '');
+
+        const stripped = (gitUrl?: string) =>
+            withoutProtocol(withoutPostfix(gitUrl));
+
+        if (stripped(realGitUrl) !== stripped(declaredGitUrl)) {
+            fail(
+                `package.json says the repository is located at \`${declaredGitUrl}\` but \`git remote get-url origin\` says it is at \`${realGitUrl}\`.`
+            );
+        }
+    }
+};
+
+const checkFileProperty = (packageJson: PackageJson) => {
+    mustContain(
+        packageJson.files ?? [],
+        ['LICENSE', 'dist/', 'Changelog.md'],
+        'These entries are missing in the property `files` in package.json'
+    );
+
+    mustContainOneOf(
+        packageJson.files ?? [],
+        ['resources/*', 'resources/icon.*', 'resources/'],
+        'One of these entries must be in the property `files` in package.json'
+    );
+};
+
+const changelogEntryRegexp = (version?: string) =>
+    new RegExp(`^## ${version}`, 'mi');
+
+const checkChangelog = (
+    packageJson: PackageJson,
+    checkChangelogHasCurrentEntry: boolean
+) => {
+    if (!existsSync('./Changelog.md')) {
+        fail('The mandatory file `Changelog.md` is missing.');
+    }
+
+    if (checkChangelogHasCurrentEntry) {
+        if (packageJson.version == null) {
+            fail('package.json must specify a `version`.');
+        }
+
+        const changelog = readFileSync('./Changelog.md', 'utf8');
+        if (!changelog.match(changelogEntryRegexp(packageJson.version))) {
+            fail(
+                `Found no entry for the current version packageJson.version ${packageJson.version} in \`Changelog.md\`.`
+            );
+        }
+
+        if (changelog.match(changelogEntryRegexp('unreleased'))) {
+            fail('There must not be an entry `unreleased` in `Changelog.md`.');
+        }
+    }
+};
+
+const filesIn = (directory: string) => {
+    try {
+        return readdirSync(directory);
+    } catch (error) {
+        fail(`Unable to read directory \`${directory}\`.`);
+        // Unreachable, but not understood by Typescript
+        throw new Error();
+    }
+};
+
+const checkMandatoryResources = () => {
+    mustContain(
+        filesIn('./resources'),
+        ['icon.svg', 'icon.icns', 'icon.ico', 'icon.png'],
+        'In the directory `resources` these files are missing'
+    );
+};
+
+const runChecks = ({
+    checkChangelogHasCurrentEntry,
+}: {
+    checkChangelogHasCurrentEntry: boolean;
+}) => {
+    const packageJson = <PackageJson>(
+        JSON.parse(readFileSync('./package.json', 'utf8'))
+    );
+
+    checkMandatoryProperties(packageJson);
+    checkOptionalProperties(packageJson);
+    checkFileProperty(packageJson);
+    checkChangelog(packageJson, checkChangelogHasCurrentEntry);
+    checkMandatoryResources();
+};
+
+const isRanAsAScript = require.main === module; // https://nodejs.org/docs/latest/api/modules.html#accessing-the-main-module
+if (isRanAsAScript) {
+    runChecks({ checkChangelogHasCurrentEntry: false });
+}
+
+export default runChecks;

package/scripts/check-for-typescript.ts

@@ -0,0 +1,41 @@
+#!/usr/bin/env ts-node
+
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import klaw from 'klaw';
+
+const launchNextCommand = () => {
+    const [, , command, ...args] = process.argv;
+
+    process.exit(
+        spawnSync(command, args, {
+            shell: true,
+            stdio: 'inherit',
+        }).status ?? undefined
+    );
+};
+
+const assertNoTypeScriptFilesExist = () => {
+    const excludeNodeModules = (path: string) => !path.endsWith('node_modules');
+
+    klaw('.', { filter: excludeNodeModules }).on('data', ({ path }) => {
+        if (path.endsWith('.ts') || path.endsWith('.tsx')) {
+            console.log(
+                "Your project contains TypeScript files (with the file ending .ts or .tsx), so it also must contain a file 'tsconfig.json'.\n"
+            );
+            process.exit(1);
+        }
+    });
+};
+
+if (existsSync('tsconfig.json')) {
+    launchNextCommand();
+} else {
+    assertNoTypeScriptFilesExist();
+}

package/scripts/esbuild-bootstrap.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+const { build } = require('./esbuild-renderer');
+
+build({
+    logLevel: 'warning',
+    entryPoints: ['./src/bootstrap.scss'],
+    outfile: 'dist/bootstrap.css',
+    sourcemap: false,
+});

package/scripts/esbuild-renderer.js

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2022 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+const fs = require('fs');
+const join = require('path').join;
+const { sassPlugin, postcssModules } = require('esbuild-sass-plugin');
+const esbuild = require('esbuild');
+const svgr = require('@svgr/core').transform;
+
+function options(additionalOptions) {
+    const { dependencies } = JSON.parse(
+        fs.readFileSync('package.json', 'utf8')
+    );
+
+    const outfile =
+        additionalOptions.entryPoints.length === 1
+            ? './dist/bundle.js'
+            : undefined;
+    const outdir = outfile ? undefined : './dist';
+
+    return {
+        format: 'cjs',
+        outfile,
+        outdir,
+        target: 'chrome89',
+        sourcemap: true,
+        metafile: false,
+        minify: process.argv.includes('--prod'),
+        bundle: true,
+        logLevel: 'info',
+        external: [
+            // node
+            'fs',
+            'zlib',
+            'os',
+            'http',
+            'child_process',
+            'crypto',
+            'path',
+            'https',
+            'net',
+            'stream',
+            'url',
+            'module',
+            'constants',
+            'buffer',
+
+            // launcher includes
+            'electron',
+            'serialport',
+            '@electron/remote',
+            'react',
+            '@nordicsemiconductor/nrf-device-lib-js',
+
+            // App dependencies
+            ...Object.keys(dependencies ?? {}),
+        ],
+        loader: {
+            '.json': 'json',
+            '.gif': 'file',
+            '.svg': 'file',
+            '.png': 'file',
+            '.woff': 'file',
+            '.woff2': 'file',
+            '.eot': 'file',
+            '.ttf': 'file',
+        },
+        plugins: [
+            sassPlugin({
+                filter: /\.(module|icss)\.scss/,
+                cssImports: true,
+                quietDeps: false,
+
+                transform: postcssModules({}),
+            }),
+            sassPlugin({
+                filter: /\.scss$/,
+                cssImports: true,
+                quietDeps: false,
+            }),
+            {
+                name: 'svgr',
+                setup(builder) {
+                    const filter = /^!!@svgr!(.*\.svg)$/;
+
+                    builder.onResolve({ filter }, args => {
+                        // Rename file to .svgr to let this plugin handle it.
+                        const [, shortpath] = filter.exec(args.path);
+                        const path = `${join(args.resolveDir, shortpath)}r`;
+                        return { path };
+                    });
+
+                    builder.onLoad({ filter: /\.svgr$/ }, async args => {
+                        const filePath = args.path.replace('.svgr', '.svg');
+                        const svg = await fs.promises.readFile(
+                            filePath,
+                            'utf8'
+                        );
+                        const plugins = ['@svgr/plugin-jsx'];
+                        const contents = await svgr(svg, { filePath, plugins });
+                        return {
+                            contents,
+                            loader: 'jsx',
+                        };
+                    });
+                },
+            },
+        ],
+        ...additionalOptions,
+    };
+}
+
+const build = additionalOptions => esbuild.build(options(additionalOptions));
+
+const watch = async additionalOptions => {
+    const context = await esbuild.context(options(additionalOptions));
+
+    await context.rebuild();
+    await context.watch();
+};
+
+module.exports.build = additionalOptions => {
+    if (process.argv.includes('--watch')) {
+        watch(additionalOptions);
+    } else {
+        build(additionalOptions);
+    }
+};

package/scripts/esbuild.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+const fs = require('fs');
+const join = require('path').join;
+const { build } = require('./esbuild-renderer');
+
+const entry = [
+    './src/index.jsx',
+    './lib/index.jsx',
+    './index.jsx',
+    './src/index.tsx',
+].find(fs.existsSync);
+
+build({ entryPoints: [entry] });
+
+const distFolder = join(process.cwd(), 'dist');
+if (!fs.existsSync(distFolder)) {
+    fs.mkdirSync(distFolder);
+}
+
+fs.copyFileSync(
+    join(
+        process.cwd(),
+        './node_modules/pc-nrfconnect-shared/scripts/nordic-publish.js'
+    ),
+    join(distFolder, 'nordic-publish.js')
+);
+
+fs.copyFileSync(
+    join(
+        process.cwd(),
+        './node_modules/pc-nrfconnect-shared/dist/bootstrap.css'
+    ),
+    join(distFolder, 'bootstrap.css')
+);
+
+if (process.argv.includes('--include-bootloader')) {
+    if (!fs.existsSync(`${process.cwd()}/fw`)) {
+        fs.mkdirSync(`${process.cwd()}/fw`);
+    }
+
+    fs.copyFileSync(
+        join(
+            process.cwd(),
+            './node_modules/pc-nrfconnect-shared/fw/bootloader/graviton_bootloader_v1.0.1-[nRF5_SDK_15.0.1-1.alpha_f76d012].zip'
+        ),
+        join(
+            process.cwd(),
+            './fw/graviton_bootloader_v1.0.1-[nRF5_SDK_15.0.1-1.alpha_f76d012].zip'
+        )
+    );
+}

package/scripts/installHusky.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env ts-node
+
+/*
+ * Copyright (c) 2022 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { existsSync } from 'fs';
+import { install as installHusky } from 'husky';
+import { cwd } from 'process';
+
+if (existsSync('.git')) {
+    installHusky();
+} else {
+    console.log(`Not installing husky, because ${cwd()} is no git repo.`);
+}