feat(scripts): add initial version of sorting

Author: travi

src/package/property-sorter.js

@@ -1,7 +1,7 @@
-import sortProperties from 'sort-object-keys';
+import sortObjectKeys from 'sort-object-keys';
 
-export default function (packageContents) {
-  return sortProperties(
+export default function sortProperties(packageContents) {
+  return sortObjectKeys(
     packageContents,
     [
       'name',

src/package/scripts/lifter.js

@@ -1,8 +1,9 @@
 import updateTestScript from './test-script-updater.js';
+import sortScripts from './scripts-sorter.js';
 
 export default function ({existingScripts, scripts}) {
   return {
-    scripts: updateTestScript({...existingScripts, ...scripts}),
+    scripts: sortScripts(updateTestScript({...existingScripts, ...scripts})),
     dependencies: {
       javascript: {
         development: ['npm-run-all2'],

src/package/scripts/lifter.test.js

@@ -3,19 +3,23 @@ import {when} from 'vitest-when';
 import {describe, expect, it, vi} from 'vitest';
 
 import updateTestScript from './test-script-updater.js';
+import sortScripts from './scripts-sorter.js';
 import liftScripts from './lifter.js';
 
+vi.mock('./scripts-sorter.js');
 vi.mock('./test-script-updater.js');
 
 describe('package.json scripts lifter', () => {
   it('should merge the provided scripts with the existing scripts', () => {
     const existingScripts = any.simpleObject();
     const scripts = any.simpleObject();
     const updatedScripts = any.simpleObject();
+    const sortedScripts = any.simpleObject();
     when(updateTestScript).calledWith({...existingScripts, ...scripts}).thenReturn(updatedScripts);
+    when(sortScripts).calledWith(updatedScripts).thenReturn(sortedScripts);
 
     expect(liftScripts({existingScripts, scripts})).toEqual({
-      scripts: updatedScripts,
+      scripts: sortedScripts,
       dependencies: {
         javascript: {
           development: ['npm-run-all2'],

src/package/scripts/script-comparator.js

@@ -0,0 +1,35 @@
+function sortTestScript() {
+  return -1;
+}
+
+function isPreScriptFor(a, b) {
+  return a.startsWith('pre') && a.slice(3) === b;
+}
+
+export default function compareScriptNames(a, b) {
+  if (isPreScriptFor(a, b)) {
+    return -1;
+  }
+
+  if (isPreScriptFor(b, a)) {
+    return 1;
+  }
+
+  if ('test' === a) {
+    return sortTestScript(a, b);
+  }
+
+  if ('test' === b) {
+    return -sortTestScript(b, a);
+  }
+
+  if (a.startsWith('lint:') && b.startsWith('test:')) {
+    return -1;
+  }
+
+  if (b.startsWith('lint:') && a.startsWith('test:')) {
+    return 1;
+  }
+
+  return 0;
+}

src/package/scripts/script-comparator.test.js

@@ -0,0 +1,29 @@
+import {describe, it, expect} from 'vitest';
+import any from '@travi/any';
+
+import compareScriptNames from './script-comparator.js';
+
+describe('script name comparator', () => {
+  it('should consider undefined sort orders as equivalent', async () => {
+    expect(compareScriptNames(any.word(), any.word())).toEqual(0);
+  });
+
+  it('should sort `pre` scripts ahead of their related scripts', async () => {
+    const baseScriptName = any.word();
+    expect(compareScriptNames(`pre${baseScriptName}`, baseScriptName)).toEqual(-1);
+    expect(compareScriptNames(baseScriptName, `pre${baseScriptName}`)).toEqual(1);
+
+    expect(compareScriptNames('pretest', 'test')).toEqual(-1);
+    expect(compareScriptNames('test', 'pretest')).toEqual(1);
+  });
+
+  it('should sort the `test` script ahead of any sub-test scripts', async () => {
+    expect(compareScriptNames('test', `test:${any.word()}`)).toEqual(-1);
+    expect(compareScriptNames(`test:${any.word()}`, 'test')).toEqual(1);
+  });
+
+  it('should sort `lint:` scripts above `test:` scripts', async () => {
+    expect(compareScriptNames(`lint:${any.word()}`, `test:${any.word()}`)).toEqual(-1);
+    expect(compareScriptNames(`test:${any.word()}`, `lint:${any.word()}`)).toEqual(1);
+  });
+});

src/package/scripts/scripts-sorter.js

@@ -0,0 +1,7 @@
+import sortObjectKeys from 'sort-object-keys';
+
+import compareScriptNames from './script-comparator.js';
+
+export default function sortScripts(scripts) {
+  return sortObjectKeys(scripts, compareScriptNames);
+}

src/package/scripts/scripts-sorter.test.js

@@ -0,0 +1,20 @@
+import sortObjectKeys from 'sort-object-keys';
+
+import {it, describe, expect, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import compareScriptNames from './script-comparator.js';
+import sortScripts from './scripts-sorter.js';
+
+vi.mock('sort-object-keys');
+
+describe('npm scripts sorter', () => {
+  it('should sort the scripts based on the defined order', async () => {
+    const unsortedScripts = any.simpleObject();
+    const sortedScripts = any.simpleObject();
+    when(sortObjectKeys).calledWith(unsortedScripts, compareScriptNames).thenReturn(sortedScripts);
+
+    expect(sortScripts(unsortedScripts)).toEqual(sortedScripts);
+  });
+});