@servicetitan/startup 35.0.0 → 35.2.0-far-1776.0

package/dist/webpack/configs/utils/get-launchdarkly-sdk-version.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/webpack/configs/utils/get-launchdarkly-sdk-version.ts"],"sourcesContent":["import path from 'path';\nimport { readJson } from '../../../utils';\n\nexport function getLaunchDarklySdkVersion() {\n    try {\n        return readJson<{ version: string }>(\n            path.join(\n                path.dirname(require.resolve('launchdarkly-js-client-sdk')),\n                '../package.json'\n            )\n        ).version;\n    } catch {\n        // ignore\n    }\n}\n"],"names":["getLaunchDarklySdkVersion","readJson","path","join","dirname","require","resolve","version"],"mappings":";;;;+BAGgBA;;;eAAAA;;;6DAHC;uBACQ;;;;;;AAElB,SAASA;IACZ,IAAI;QACA,OAAOC,IAAAA,eAAQ,EACXC,aAAI,CAACC,IAAI,CACLD,aAAI,CAACE,OAAO,CAACC,QAAQC,OAAO,CAAC,gCAC7B,oBAENC,OAAO;IACb,EAAE,eAAM;IACJ,SAAS;IACb;AACJ"}
+{"version":3,"sources":["../../../../src/webpack/configs/utils/get-launchdarkly-sdk-version.ts"],"sourcesContent":["import { getPackageVersion } from '../../../utils';\n\nexport function getLaunchDarklySdkVersion() {\n    return getPackageVersion('launchdarkly-js-client-sdk');\n}\n"],"names":["getLaunchDarklySdkVersion","getPackageVersion"],"mappings":";;;;+BAEgBA;;;eAAAA;;;uBAFkB;AAE3B,SAASA;IACZ,OAAOC,IAAAA,wBAAiB,EAAC;AAC7B"}

package/dist/webpack/configs/utils/get-web-components-version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-web-components-version.d.ts","sourceRoot":"","sources":["../../../../src/webpack/configs/utils/get-web-components-version.ts"],"names":[],"mappings":"AAGA,wBAAgB,uBAAuB,WAItC"}
+{"version":3,"file":"get-web-components-version.d.ts","sourceRoot":"","sources":["../../../../src/webpack/configs/utils/get-web-components-version.ts"],"names":[],"mappings":"AAEA,wBAAgB,uBAAuB,WAQtC"}

package/dist/webpack/configs/utils/get-web-components-version.js

@@ -8,15 +8,13 @@ Object.defineProperty(exports, "getWebComponentsVersion", {
         return getWebComponentsVersion;
     }
 });
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _utils = require("../../../utils");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
 function getWebComponentsVersion() {
-    return (0, _utils.readJson)(_path.default.join(_path.default.dirname(require.resolve('@servicetitan/web-components')), '../package.json')).version;
+    const version = (0, _utils.getPackageVersion)('@servicetitan/web-components');
+    if (!version) {
+        throw new Error('Unable to resolve @servicetitan/web-components version from package-lock.json');
+    }
+    return version;
 }
 
 //# sourceMappingURL=get-web-components-version.js.map

package/dist/webpack/configs/utils/get-web-components-version.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/webpack/configs/utils/get-web-components-version.ts"],"sourcesContent":["import path from 'path';\nimport { readJson } from '../../../utils';\n\nexport function getWebComponentsVersion() {\n    return readJson<{ version: string }>(\n        path.join(path.dirname(require.resolve('@servicetitan/web-components')), '../package.json')\n    ).version;\n}\n"],"names":["getWebComponentsVersion","readJson","path","join","dirname","require","resolve","version"],"mappings":";;;;+BAGgBA;;;eAAAA;;;6DAHC;uBACQ;;;;;;AAElB,SAASA;IACZ,OAAOC,IAAAA,eAAQ,EACXC,aAAI,CAACC,IAAI,CAACD,aAAI,CAACE,OAAO,CAACC,QAAQC,OAAO,CAAC,kCAAkC,oBAC3EC,OAAO;AACb"}
+{"version":3,"sources":["../../../../src/webpack/configs/utils/get-web-components-version.ts"],"sourcesContent":["import { getPackageVersion } from '../../../utils';\n\nexport function getWebComponentsVersion() {\n    const version = getPackageVersion('@servicetitan/web-components');\n    if (!version) {\n        throw new Error(\n            'Unable to resolve @servicetitan/web-components version from package-lock.json'\n        );\n    }\n    return version;\n}\n"],"names":["getWebComponentsVersion","version","getPackageVersion","Error"],"mappings":";;;;+BAEgBA;;;eAAAA;;;uBAFkB;AAE3B,SAASA;IACZ,MAAMC,UAAUC,IAAAA,wBAAiB,EAAC;IAClC,IAAI,CAACD,SAAS;QACV,MAAM,IAAIE,MACN;IAER;IACA,OAAOF;AACX"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@servicetitan/startup",
-    "version": "35.0.0",
+    "version": "35.2.0-far-1776.0",
     "description": "CLI to create multi-package Lerna projects with TypeScript and React",
     "homepage": "https://docs.st.dev/docs/frontend/uikit/startup",
     "repository": {
@@ -20,6 +20,7 @@
             "default": "./dist/index.js",
             "types": "./dist/index.d.ts"
         },
+        "./cypress-config": "./dist/cypress-config/index.js",
         "./jest-preset": "./jest/jest-preset.js",
         "./jest-resolver": "./dist/jest/resolver.js",
         "./jest-svg-transformer": "./dist/jest/svg-transformer.js",
@@ -56,16 +57,16 @@
         "@jest/core": "~30.3.0",
         "@jest/types": "~30.3.0",
         "@jsdevtools/coverage-istanbul-loader": "^3.0.5",
-        "@servicetitan/eslint-config": "35.0.0",
-        "@servicetitan/install": "35.0.0",
-        "@servicetitan/startup-utils": "35.0.0",
-        "@servicetitan/stylelint-config": "35.0.0",
+        "@servicetitan/eslint-config": "35.1.0",
+        "@servicetitan/install": "35.1.0",
+        "@servicetitan/startup-utils": "35.1.0",
+        "@servicetitan/stylelint-config": "35.1.0",
         "@svgr/webpack": "^8.1.0",
         "@swc/cli": "^0.5.0",
         "@swc/core": "1.15.18",
         "@types/debug": "^4.1.12",
         "@types/jest": "~30.0.0",
-        "@vitest/coverage-v8": "^4.0.18",
+        "@vitest/coverage-v8": "^4.1.0",
         "chalk": "~4.1.2",
         "cli-table3": "^0.6.5",
         "cpx2": "8.0.0",
@@ -87,31 +88,32 @@
         "json5": "^2.2.3",
         "lerna": "~9.0.5",
         "less": "~4.5.1",
-        "less-loader": "~12.3.1",
+        "less-loader": "~12.3.2",
         "less-plugin-npm-import": "~2.1.0",
         "lodash.kebabcase": "^4.1.1",
         "lodash.memoize": "^4.1.2",
         "memfs": "~4.56.11",
-        "mini-css-extract-plugin": "~2.10.0",
+        "mini-css-extract-plugin": "~2.10.1",
         "moment-locales-webpack-plugin": "~1.2.0",
         "multimatch": "~8.0.0",
         "patch-package": "^8.0.1",
         "portfinder": "~1.0.38",
         "postcss": "~8.5.8",
         "prettier": "~3.8.1",
-        "sass": "~1.97.3",
+        "sass": "~1.98.0",
         "sass-loader": "~16.0.7",
         "semver": "~7.7.4",
         "source-map-loader": "~5.0.0",
         "style-loader": "~4.0.0",
         "stylelint": "~16.26.1",
+        "swc-loader": "^0.2.7",
         "terminal-link": "^5.0.0",
-        "terser-webpack-plugin": "^5.3.16",
+        "terser-webpack-plugin": "^5.4.0",
         "ts-jest": "29.4.6",
         "ts-node": "~10.9.2",
         "typed-css-modules": "~0.9.1",
         "typescript": "5.9.3",
-        "vitest": "^4.0.18",
+        "vitest": "^4.1.0",
         "webpack": "~5.105.4",
         "webpack-assets-manifest": "~6.5.1",
         "webpack-bundle-analyzer": "^5.2.0",
@@ -143,6 +145,5 @@
     },
     "cli": {
         "webpack": false
-    },
-    "gitHead": "3a5f2e6cad93c4e898091fb3d51310ccb26a91ee"
+    }
 }

package/src/cli/commands/__tests__/mfe-generate-metadata.test.ts

@@ -35,6 +35,7 @@ describe(`[startup] ${MfeGenerateMetadata.name}`, () => {
 
     const mockParentPackageJson = {
         name: 'parent-package',
+        workspaces: ['packages/*'],
         dependencies: { 'some-dep': '^1.0.0' },
     };
 
@@ -109,10 +110,28 @@ describe(`[startup] ${MfeGenerateMetadata.name}`, () => {
             });
         });
 
-        test('throws error', async () => {
-            await expect(subject()).rejects.toThrow(
-                'this command must be run inside a web-component directory'
-            );
+        test('does not throw error', async () => {
+            await expect(subject()).resolves.not.toThrow();
+        });
+    });
+
+    describe('when tsconfig.json does not exist', () => {
+        beforeEach(() => {
+            vol.reset();
+            vol.fromJSON({
+                './package.json': JSON.stringify(mockPackageJson),
+                '../../package.json': JSON.stringify(mockParentPackageJson),
+            });
+        });
+
+        test('does not throw error', async () => {
+            await expect(subject()).resolves.not.toThrow();
+        });
+
+        test('outputs metadata with empty entrypoints', async () => {
+            await subject();
+
+            expect(getMetadataFromStdout().entrypoints).toEqual({});
         });
     });
 

package/src/cli/commands/mfe-generate-metadata.ts

@@ -4,7 +4,6 @@ import {
     getFolders,
     getPackageData,
     getPackageName,
-    isWebComponent,
     loadSharedDependencies,
     log,
     logErrors,
@@ -26,13 +25,14 @@ export class MfeGenerateMetadata extends Command<typeof options> {
 
     @logErrors
     async execute() {
-        if (!isWebComponent()) {
-            throw new Error('this command must be run inside a web-component directory');
-        }
-
         const { output } = this.args;
 
-        const { destination } = getFolders();
+        let destination: string;
+        try {
+            ({ destination } = getFolders());
+        } catch {
+            destination = 'dist';
+        }
         const name = getPackageName();
         const packageData = getPackageData();
         const sharedDependencies = loadSharedDependencies(

package/src/cypress-config/__tests__/webpack-config.test.ts

@@ -0,0 +1,124 @@
+import { fs, vol } from 'memfs';
+import { getSwcOptions } from '../../cli/tasks';
+import { TSConfig } from '../../cli/utils';
+import { getBaseTsConfig } from '../../utils';
+import { Overrides, rulesConfig } from '../../webpack/configs';
+import { webpackConfig } from '../webpack-config';
+
+jest.mock('fs', () => fs);
+jest.mock('../../webpack/configs');
+jest.mock('../../cli/tasks');
+
+describe(`[startup/cypress-config] ${webpackConfig.name}`, () => {
+    const mockRules: any[] = [
+        { test: /\.css$/, use: ['css-loader'] },
+        { test: /\.module\.less$/, use: ['style-loader', 'less-loader'] },
+    ];
+    const mockSwcOptions: any = { jsc: 'foobar' };
+    const mockTsConfig = { compilerOptions: { target: 'es2020' } };
+    const mockFallbackTsConfig = { compilerOptions: { target: 'es2018' } };
+    const fallbackConfig = getBaseTsConfig();
+
+    let overrides: Overrides | undefined;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.mocked(rulesConfig).mockReturnValue({ rules: mockRules });
+        jest.mocked(getSwcOptions).mockReturnValue(mockSwcOptions);
+        vol.fromJSON({
+            'tsconfig.json': JSON.stringify(mockTsConfig),
+            [fallbackConfig]: JSON.stringify(mockFallbackTsConfig),
+        });
+        overrides = undefined;
+    });
+
+    afterEach(() => vol.reset());
+
+    const subject = () => webpackConfig(overrides);
+
+    test('gets rules with non-production context', () => {
+        subject();
+
+        expect(rulesConfig).toHaveBeenCalledWith(
+            expect.objectContaining({ isProduction: false }),
+            expect.anything()
+        );
+    });
+
+    test('includes all rules from rulesConfig', () => {
+        const result = subject();
+
+        for (const rule of mockRules) {
+            expect(result.module!.rules).toContainEqual(rule);
+        }
+    });
+
+    test('adds swc-loader rule for TypeScript files', () => {
+        const result = subject();
+
+        expect(result.module!.rules).toContainEqual(
+            expect.objectContaining({
+                test: /\.tsx?$/,
+                exclude: /node_modules/,
+                use: { loader: 'swc-loader', options: mockSwcOptions },
+            })
+        );
+    });
+
+    test('passes tsconfig content to getSwcOptions', () => {
+        subject();
+
+        const tsConfigArg = jest.mocked(getSwcOptions).mock.calls[0][0];
+        expect(tsConfigArg).toStrictEqual(new TSConfig('tsconfig.json'));
+    });
+
+    describe('when no tsconfig is found', () => {
+        beforeEach(() => fs.rmSync('tsconfig.json'));
+
+        test('gets default swc config from base.json', () => {
+            subject();
+
+            const tsConfigArg = jest.mocked(getSwcOptions).mock.calls[0][0];
+            expect(tsConfigArg).toStrictEqual(new TSConfig(fallbackConfig));
+        });
+    });
+
+    test('includes resolve extensions for TypeScript and JavaScript', () => {
+        expect(subject().resolve!.extensions).toEqual(['.ts', '.tsx', '.js', '.jsx']);
+    });
+
+    describe('with overrides', () => {
+        beforeEach(() => (overrides = { plugins: { MiniCssExtractPlugin: {} } }));
+
+        test('passes overrides through to rulesConfig', () => {
+            subject();
+
+            expect(rulesConfig).toHaveBeenCalledWith(expect.anything(), overrides);
+        });
+
+        describe('with configuration overrides', () => {
+            beforeEach(
+                () =>
+                    (overrides = {
+                        configuration: {
+                            devtool: 'eval-source-map',
+                            resolve: {
+                                alias: {
+                                    '@': '/src',
+                                },
+                            },
+                        },
+                    })
+            );
+
+            test('merges configuration overrides into result', () => {
+                const result = subject();
+
+                expect(result.devtool).toBe(overrides!.configuration!.devtool);
+                expect(result.resolve?.alias).toEqual(overrides!.configuration!.resolve!.alias);
+                expect(result.resolve?.extensions).toEqual(['.ts', '.tsx', '.js', '.jsx']);
+                expect(result.module?.rules).toBeDefined();
+            });
+        });
+    });
+});

package/src/cypress-config/index.ts

@@ -0,0 +1 @@
+export * from './webpack-config';

package/src/cypress-config/webpack-config.ts

@@ -0,0 +1,58 @@
+import { inspect } from 'node:util';
+import type { Configuration } from 'webpack';
+import merge from 'webpack-merge';
+import { getSwcOptions } from '../cli/tasks';
+import { TSConfig } from '../cli/utils';
+import { getTsConfigWithFallback, log } from '../utils';
+import { Context, Overrides, rulesConfig } from '../webpack/configs';
+
+export function webpackConfig(overrides?: Overrides): Configuration {
+    const context = getContext();
+    const rules = getRules(context, overrides ?? {});
+
+    /* istanbul ignore next: debug only */
+    log.debug('cypress-config:webpack-config', () => inspect({ rules }, { depth: null }));
+
+    const config: Configuration = {
+        module: {
+            rules,
+        },
+        resolve: {
+            extensions: ['.ts', '.tsx', '.js', '.jsx'],
+        },
+    };
+
+    return merge(config, overrides?.configuration ?? {});
+}
+
+function getContext(): Context {
+    return {
+        destination: '',
+        isProduction: false,
+        name: '',
+        packageData: {} as any,
+        sharedDependencies: {},
+        source: '',
+    };
+}
+
+function getRules(context: Context, overrides: Overrides) {
+    const { rules } = rulesConfig(context, overrides);
+
+    return [getSwcLoaderRule(), ...rules];
+}
+
+function getSwcLoaderRule() {
+    const tsConfig = new TSConfig(getTsConfigWithFallback());
+
+    const swcOptions = getSwcOptions(tsConfig);
+
+    return {
+        test: /\.tsx?$/,
+        exclude: /node_modules/,
+        use: {
+            loader: 'swc-loader',
+            options: swcOptions,
+        },
+    };
+}

package/src/storybook-config/__tests__/swc.test.ts

@@ -2,16 +2,19 @@ import { SwcOptions } from '@swc/cli';
 import { fs, vol } from 'memfs';
 import { getSwcOptions } from '../../cli/tasks';
 import { TSConfig } from '../../cli/utils';
+import { getBaseTsConfig } from '../../utils';
 import { swc } from '../swc';
 
 jest.mock('fs', () => fs);
 
 describe(`[startup/storybook-config] ${swc.name}`, () => {
+    const baseJsonPath = getBaseTsConfig();
     const config: SwcOptions = { env: { bugfixes: true } };
     let tsConfig: TSConfig;
 
     function setTsConfig(config: Record<string, any> = {}) {
         return vol.fromJSON({
+            [baseJsonPath]: JSON.stringify({ compilerOptions: { sourceMap: true } }),
             'tsconfig.json': JSON.stringify(config),
         });
     }
@@ -34,4 +37,12 @@ describe(`[startup/storybook-config] ${swc.name}`, () => {
             expect(subject().jsc.target).toBeUndefined();
         });
     });
+
+    describe('when no tsconfig is found', () => {
+        beforeEach(() => fs.rmSync('tsconfig.json'));
+
+        test('gets default swc config from base.json', () => {
+            expect(subject()).toEqual({ ...config, ...getSwcOptions(new TSConfig(baseJsonPath)) });
+        });
+    });
 });

package/src/storybook-config/swc.ts

@@ -2,10 +2,10 @@ import type { SwcOptions } from '@swc/cli';
 import { inspect } from 'node:util';
 import { getSwcOptions } from '../cli/tasks';
 import { TSConfig } from '../cli/utils';
-import { getTsConfig, log } from '../utils';
+import { getTsConfigWithFallback, log } from '../utils';
 
 export function swc(config: SwcOptions) {
-    const tsConfig = new TSConfig(getTsConfig());
+    const tsConfig = new TSConfig(getTsConfigWithFallback());
     const swcOptions = getSwcOptions(tsConfig);
 
     /*

package/src/utils/__tests__/find-package-lock.test.ts

@@ -0,0 +1,35 @@
+import { fs, vol } from 'memfs';
+import path from 'node:path';
+import { findPackageLock } from '../find-package-lock';
+
+jest.mock('fs', () => fs);
+
+describe(`[startup] ${findPackageLock.name}`, () => {
+    afterEach(() => vol.reset());
+
+    const subject = () => findPackageLock();
+
+    describe('when package-lock.json exists in cwd', () => {
+        beforeEach(() => {
+            vol.fromJSON({ './package-lock.json': '{}' });
+        });
+
+        test('returns path', () => {
+            expect(subject()).toBe(path.resolve('./package-lock.json'));
+        });
+    });
+
+    describe('when package-lock.json exists in parent directory', () => {
+        beforeEach(() => {
+            vol.fromJSON({ '../package-lock.json': '{}' });
+        });
+
+        test('returns path', () => {
+            expect(subject()).toBe(path.resolve('../package-lock.json'));
+        });
+    });
+
+    test('returns undefined when no package-lock.json exists', () => {
+        expect(subject()).toBeUndefined();
+    });
+});

package/src/utils/__tests__/get-package-data.test.ts

@@ -1,47 +1,118 @@
+import { fs, vol } from 'memfs';
 import { getPackageData, getPackageDependencyVersion } from '../get-package-data';
-import { readJson } from '../read-json';
 
-jest.mock('../read-json', () => ({ readJson: jest.fn() }));
+jest.mock('fs', () => fs);
 
 describe(`[startup] Utils`, () => {
     describe(`${getPackageData.name}`, () => {
-        const packageJson = './package.json';
-        const ancestorPackageJson = '../../package.json';
-        let packages: Record<string, Record<string, any>>;
-
-        beforeEach(() => {
-            packages = {
-                [ancestorPackageJson]: { dependencies: { foo: '1.0.0', bar: '2.0.0' } },
-                [packageJson]: {
+        afterEach(() => vol.reset());
+
+        const subject = () => getPackageData();
+
+        describe('when root package.json with workspaces exists', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    './package.json': JSON.stringify({
+                        name: 'packageName',
+                        dependencies: { foo: '1.1.0', baz: '3.0.0' },
+                    }),
+                    '../package.json': JSON.stringify({
+                        workspaces: ['packages/*'],
+                        dependencies: { foo: '1.0.0', bar: '2.0.0' },
+                    }),
+                });
+            });
+
+            test('returns merged dependencies (local overrides root)', () => {
+                expect(subject()).toEqual({
                     name: 'packageName',
-                    dependencies: { foo: '1.1.0', baz: '3.0.0' },
-                },
-            };
-            jest.mocked(readJson).mockImplementation(path => packages[path] ?? {});
+                    dependencies: { foo: '1.1.0', bar: '2.0.0', baz: '3.0.0' },
+                });
+            });
         });
 
-        const subject = () => getPackageData();
+        describe('when no root package.json found', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    './package.json': JSON.stringify({
+                        name: 'rootPackage',
+                        workspaces: ['packages/*'],
+                        dependencies: { foo: '1.0.0' },
+                    }),
+                });
+            });
+
+            test('returns only local dependencies', () => {
+                expect(subject()).toEqual({
+                    name: 'rootPackage',
+                    dependencies: { foo: '1.0.0' },
+                });
+            });
+        });
+
+        describe('when root has lerna.json with packages instead of workspaces', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    './package.json': JSON.stringify({
+                        name: 'packageName',
+                        version: '2.0.0',
+                        dependencies: { foo: '1.0.0' },
+                    }),
+                    '../package.json': JSON.stringify({
+                        dependencies: { bar: '2.0.0' },
+                    }),
+                    '../lerna.json': JSON.stringify({
+                        packages: ['packages/*'],
+                    }),
+                });
+            });
+
+            test('returns dependencies from root discovered via lerna.json', () => {
+                expect(subject()).toEqual({
+                    name: 'packageName',
+                    version: '2.0.0',
+                    dependencies: { bar: '2.0.0', foo: '1.0.0' },
+                });
+            });
+        });
+
+        describe('when root has lerna.json but no package.json at root level', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    './package.json': JSON.stringify({
+                        name: 'packageName',
+                        version: '3.0.0',
+                        dependencies: { foo: '1.0.0' },
+                    }),
+                    '../lerna.json': JSON.stringify({
+                        packages: ['packages/*'],
+                    }),
+                });
+            });
 
-        test(`returns merged dependencies from ${packageJson} and ${ancestorPackageJson}`, () => {
-            expect(subject()).toEqual({
-                name: packages[packageJson].name,
-                dependencies: {
-                    ...packages[ancestorPackageJson].dependencies,
-                    ...packages[packageJson].dependencies,
-                },
+            test('returns only local dependencies', () => {
+                expect(subject()).toEqual({
+                    name: 'packageName',
+                    version: '3.0.0',
+                    dependencies: { foo: '1.0.0' },
+                });
             });
         });
 
-        describe(`when ${packageJson} contains sharedDependencies`, () => {
+        describe('when package.json contains sharedDependencies', () => {
             const sharedDependencies = { react: 'SharedDependencies.React' };
 
             beforeEach(() => {
-                Object.assign(packages[packageJson], {
-                    cli: { webpack: { 'shared-dependencies': sharedDependencies } },
+                vol.fromJSON({
+                    './package.json': JSON.stringify({
+                        name: 'packageName',
+                        dependencies: { foo: '1.0.0' },
+                        cli: { webpack: { 'shared-dependencies': sharedDependencies } },
+                    }),
                 });
             });
 
-            test('returns sharedDependencies', () => {
+            test('result contains sharedDependencies', () => {
                 expect(subject()).toEqual(expect.objectContaining({ sharedDependencies }));
             });
         });