@superdesk/build-tools 1.0.19 → 1.2.0-rc1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdesk/build-tools",
-  "version": "1.0.19",
+  "version": "1.2.0-rc1",
   "publishConfig": {
     "access": "public"
   },
@@ -14,7 +14,6 @@
     "gettext-extractor": "3.5.3",
     "gettext.js": "0.9.0",
     "glob": "7.1.7",
-    "lodash": "4.17.19",
     "rimraf": "3.0.2"
   }
 }

package/src/dev-link.js

@@ -0,0 +1,138 @@
+/**
+ * `dev-link` CLI command. Symlinks one or more local source repos into the
+ * current working directory's node_modules so a Superdesk template can be
+ * developed against unpublished local checkouts (e.g. superdesk-client-core,
+ * superdesk-planning) without using `npm link`.
+ *
+ * For each source path:
+ *   1. Read its package.json to get the package name. The symlink in
+ *      node_modules uses this name, not the directory name (so
+ *      superdesk-client-core correctly lands as node_modules/superdesk-core).
+ *   2. Run `npm install` in the source root, and also in any client/<subdir>
+ *      that has its own package.json (covers superdesk-planning's nested
+ *      client/planning-extension without hard-coding it).
+ *   3. Replace whatever is currently at node_modules/<package-name> with a
+ *      symlink to the source's absolute path.
+ *
+ * Pre-condition: node_modules must already exist in the cwd. The command
+ * errors out otherwise to catch the common mistake of linking before the
+ * template's own `npm install` has run.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const {execFileSync} = require('child_process');
+
+function readPkg(dir) {
+    return JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+}
+
+/**
+ * Returns every directory inside `sourceRoot` that contains a package.json
+ * we need to install. That is the root itself, plus any `client/*` subdir
+ * that ships its own package.json (covers the superdesk-planning layout
+ * where the host-build-relevant deps live under client/planning-extension).
+ */
+function findInstallTargets(sourceRoot) {
+    const targets = [];
+
+    if (fs.existsSync(path.join(sourceRoot, 'package.json'))) {
+        targets.push(sourceRoot);
+    }
+
+    const clientDir = path.join(sourceRoot, 'client');
+
+    if (fs.existsSync(clientDir) && fs.statSync(clientDir).isDirectory()) {
+        for (const entry of fs.readdirSync(clientDir, {withFileTypes: true})) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+
+            const nestedPkg = path.join(clientDir, entry.name, 'package.json');
+
+            if (fs.existsSync(nestedPkg)) {
+                targets.push(path.join(clientDir, entry.name));
+            }
+        }
+    }
+
+    return targets;
+}
+
+function npmInstall(dir) {
+    console.info(`  installing dependencies in ${dir}`);
+    execFileSync('npm', ['install'], {stdio: 'inherit', cwd: dir});
+}
+
+function ensureSymlink(target, linkPath) {
+    let existing;
+
+    try {
+        existing = fs.lstatSync(linkPath);
+    } catch (e) {
+        if (e.code !== 'ENOENT') {
+            throw e;
+        }
+    }
+
+    if (existing != null) {
+        if (existing.isSymbolicLink() || !existing.isDirectory()) {
+            fs.unlinkSync(linkPath);
+        } else {
+            fs.rmSync(linkPath, {recursive: true, force: true});
+        }
+    }
+
+    fs.symlinkSync(target, linkPath, 'dir');
+}
+
+function devLink(consumerDir, sources) {
+    const consumerNodeModules = path.join(consumerDir, 'node_modules');
+
+    if (!fs.existsSync(consumerNodeModules)) {
+        throw new Error(
+            `Consumer node_modules not found at ${consumerNodeModules}. `
+            + 'Run `npm install` in the template first, then re-run dev-link.'
+        );
+    }
+
+    for (const source of sources) {
+        const sourceAbs = path.resolve(consumerDir, source);
+
+        if (!fs.existsSync(sourceAbs)) {
+            throw new Error(`Source path does not exist: ${sourceAbs}`);
+        }
+
+        const pkg = readPkg(sourceAbs);
+        const packageName = pkg.name;
+
+        if (packageName == null) {
+            throw new Error(`Source ${sourceAbs} has no name field in package.json`);
+        }
+
+        console.info(`\n${packageName}  <-  ${sourceAbs}`);
+
+        for (const target of findInstallTargets(sourceAbs)) {
+            npmInstall(target);
+        }
+
+        const linkPath = path.join(consumerNodeModules, packageName);
+
+        ensureSymlink(sourceAbs, linkPath);
+        console.info(`  linked node_modules/${packageName}`);
+    }
+}
+
+function register(program, currentDir) {
+    program.command('dev-link <source...>')
+        .description(
+            'symlink one or more local source repos into the current node_modules '
+            + 'for local development. Runs `npm install` in each source (and in any '
+            + 'nested client/<extension> packages) before linking.'
+        )
+        .action((sources) => {
+            devLink(currentDir, sources);
+        });
+}
+
+module.exports = {register, devLink};

package/src/extensions/get-extension-directories-sync.js

@@ -110,7 +110,7 @@ function getExtensionDirectoriesSync(clientPath) {
                     .then((res) => res.default),
         }
      */
-    var extensionRegistrationPattern = /id:\W*'(.*)',\W*load:\W*import\('(.+?)'/g;
+    var extensionRegistrationPattern = /id:\W*['"](.*)['"],\W*load:\W*import\(['"](.+?)['"]/g;
 
     const matches = [];
 

package/src/extensions/install-extensions.js

@@ -83,6 +83,24 @@ module.exports = function installExtensions(clientDir) {
     directories.forEach(({extensionRootPath, extensionSrcPath}) => {
         // if src dir doesn't exist, assume that the extension is already built (e.g. when installed from npm)
         if (fs.existsSync(extensionSrcPath)) {
+            const pkgPath = path.join(extensionRootPath, 'package.json');
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+
+            // Extensions whose `main` points at TypeScript source are consumed
+            // directly by webpack's ts-loader. Skip compile and the legacy
+            // `correct*` fixups. Still install runtime `dependencies` so webpack
+            // can resolve them via the extension's nested node_modules walk.
+            // (When workspaces land, this per-extension install goes away.)
+            if (typeof pkg.main === 'string' && /\.(ts|tsx)$/.test(pkg.main)) {
+                if (pkg.dependencies && Object.keys(pkg.dependencies).length > 0) {
+                    execSync(
+                        'npm install --no-audit --omit=dev',
+                        {stdio: 'inherit', cwd: extensionRootPath}
+                    );
+                }
+                return;
+            }
+
             correctApiDefinitionsPath(extensionRootPath, clientDir);
 
             execSync(

package/src/index.js

@@ -9,6 +9,7 @@ const installExtensions = require('./extensions/install-extensions');
 const {mergeTranslationsFromExtensions} = require('./extensions/translations');
 const {extractTranslations} = require('./extensions/extract-translations');
 const {namespaceCSS, watchCSS} = require('./extensions/css');
+const devLink = require('./dev-link');
 
 const {Command} = require('commander');
 const program = new Command();
@@ -108,5 +109,7 @@ extensions
 
 program.addCommand(extensions);
 
+devLink.register(program, currentDir);
+
 program.version(require('../package.json').version);
 program.parse(process.argv);

package/src/po-to-json/index.js

@@ -1,7 +1,6 @@
 var fs = require('fs');
 var path = require('path');
 var execSync = require('child_process').execSync;
-var _ = require('lodash');
 const {isDirectory} = require('../utils');
 
 function getModuleDir(moduleName) {
@@ -90,7 +89,7 @@ function compileTranslationsPoToJson(translationsPoDir, translationsJsonDir) {
             return;
         }
 
-        if (_.endsWith(filename, '.po') !== true) {
+        if (filename.endsWith('.po') !== true) {
             return;
         }