@servicetitan/startup 27.4.0 → 28.1.0

package/src/cli/utils/__tests__/styles-copy.test.ts

@@ -5,10 +5,7 @@ import { stylesCopy, stylesCopyWatch } from '../styles-copy';
 import { styleExtensions } from '../index';
 
 jest.mock('cpx2', () => ({
-    copy: jest.fn().mockImplementation((...args: any[]) => {
-        const callback = args[args.length - 1];
-        callback(null);
-    }),
+    copySync: jest.fn(),
     watch: jest.fn(() => ({ on: (_eventName: string, listener: Function) => listener() })),
 }));
 jest.mock('../../../utils', () => ({
@@ -28,10 +25,9 @@ describe('[startup] Cli Utils (Styles)', () => {
         test('copies styles from source to destination', async () => {
             await subject();
 
-            expect(cpx.copy).toHaveBeenCalledWith(
+            expect(cpx.copySync).toHaveBeenCalledWith(
                 `${source}/**/*.{${styleExtensions.join()}}`,
-                destination,
-                expect.anything()
+                destination
             );
         });
     });

package/src/cli/utils/assets-copy.ts

@@ -1,15 +1,15 @@
 import cpx from 'cpx2';
-import util from 'util';
 
 import { getFolders, log } from '../../utils';
 import { assetExtensions } from '.';
 
-export async function assetsCopy() {
+export function assetsCopy() {
     const { source, destination } = getFolders();
 
     log.info('Copying asset files...');
 
-    await util.promisify(cpx.copy)(`${source}/**/*.{${assetExtensions.join()}}`, destination);
+    cpx.copySync(`${source}/**/*.{${assetExtensions.join()}}`, destination);
+    return Promise.resolve();
 }
 
 export async function assetsCopyWatch() {

package/src/cli/utils/cli-os.ts

@@ -6,9 +6,11 @@ import {
 } from 'child_process';
 import { log } from '../../utils';
 
+type RunCommandOptions = SpawnOptionsWithoutStdio & { quiet?: boolean };
+
 export const runCommand = (
     command: string | (string | false)[],
-    opts?: SpawnOptionsWithoutStdio
+    { quiet, ...spawnOptions }: RunCommandOptions = {}
 ): Promise<void> => {
     return new Promise((resolve, reject) => {
         const commandArray: string[] = Array.isArray(command)
@@ -28,15 +30,19 @@ export const runCommand = (
             return;
         }
 
-        log.info(`run command ${fullCommand}`);
+        if (!quiet) {
+            log.info(`run command ${fullCommand}`);
+        }
 
-        const proc = spawn(commandName, commandArray, opts);
+        const proc = spawn(commandName, commandArray, spawnOptions);
 
         proc.stdout.pipe(process.stdout);
         proc.stderr.pipe(process.stderr);
 
         proc.on('exit', function (code: any) {
-            log.info(`command finished with code ${code}`, fullCommand);
+            if (!quiet) {
+                log.info(`command finished with code ${code}`, fullCommand);
+            }
 
             if (code) {
                 reject();
@@ -47,9 +53,11 @@ export const runCommand = (
     });
 };
 
+type RunCommandOutputOptions = ExecSyncOptionsWithBufferEncoding & { quiet?: boolean };
+
 export const runCommandOutput = (
     command: string | (string | false)[],
-    options?: ExecSyncOptionsWithBufferEncoding
+    { quiet, ...execSyncOptions }: RunCommandOutputOptions = {}
 ): string => {
     const commandArray: string[] = Array.isArray(command)
         ? command
@@ -66,11 +74,15 @@ export const runCommandOutput = (
         throw new Error();
     }
 
-    log.info(`run command ${fullCommand}`);
+    if (!quiet) {
+        log.info(`run command ${fullCommand}`);
+    }
 
-    const result = execSync(fullCommand, options).toString();
+    const result = execSync(fullCommand, execSyncOptions).toString();
 
-    log.info('command finished', result);
+    if (!quiet) {
+        log.info('command finished', result);
+    }
 
     return result;
 };

package/src/cli/utils/styles-copy.ts

@@ -1,15 +1,15 @@
 import cpx from 'cpx2';
-import util from 'util';
 
 import { getFolders, log } from '../../utils';
 import { styleExtensions } from '.';
 
-export async function stylesCopy() {
+export function stylesCopy() {
     const { source, destination } = getFolders();
 
     log.info('Copying style files...');
 
-    await util.promisify(cpx.copy)(`${source}/**/*.{${styleExtensions.join()}}`, destination);
+    cpx.copySync(`${source}/**/*.{${styleExtensions.join()}}`, destination);
+    return Promise.resolve();
 }
 
 export async function stylesCopyWatch() {

package/src/utils/__tests__/get-branch-configs.test.ts

@@ -0,0 +1,36 @@
+import { fs, vol } from 'memfs';
+
+import { getBranchesConfigs } from '../get-branch-configs';
+
+jest.mock('fs', () => fs);
+
+describe(`[Startup] ${getBranchesConfigs.name}`, () => {
+    beforeEach(() => {
+        vol.reset();
+    });
+
+    const subject = () => getBranchesConfigs();
+
+    test('returns default configs', () => {
+        expect(subject()).toEqual({
+            develop: { publishTag: 'dev' },
+            dev: { publishTag: 'dev' },
+            next: { publishTag: 'next' },
+            master: { publishTag: 'prod' },
+        });
+    });
+
+    describe('when "branches" configs', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                'package.json': JSON.stringify({
+                    cli: { 'web-component': { branches: { qa: { publishTag: 'qs' } } } },
+                }),
+            });
+        });
+
+        test('returns configs', () => {
+            expect(subject()).toEqual({ qa: { publishTag: 'qs' } });
+        });
+    });
+});

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

@@ -1,4 +1,5 @@
 import { fs, vol } from 'memfs';
+import path from 'path';
 
 import {
     getConfiguration,
@@ -6,6 +7,8 @@ import {
     getESLintConfiguration,
     getJestConfiguration,
     getStylelintConfiguration,
+    getWebComponentBranchConfigs,
+    getWebComponentConfiguration,
     isBundle,
     isCustomStyleRules,
     isDevServerDisabled,
@@ -183,6 +186,67 @@ describe('[startup] Utils', () => {
         });
     });
 
+    describe(`${getWebComponentConfiguration.name}`, () => {
+        const subject = () => getWebComponentConfiguration();
+
+        itReturns(subject, undefined);
+
+        test('returns undefined', () => {
+            expect(subject()).toEqual(undefined);
+        });
+
+        describe('with "cli.web-component true"', () => {
+            beforeEach(() => mockPackageJson({ cli: { 'web-component': true } }));
+
+            test('returns empty object', () => {
+                expect(subject()).toEqual({});
+            });
+        });
+
+        describe('with "cli.web-component.{}"', () => {
+            beforeEach(() => {
+                mockPackageJson({ cli: { 'web-component': { branches: { foo: 'bar' } } } });
+            });
+
+            test('returns web-component config', () => {
+                expect(subject()).toEqual({ branches: { foo: 'bar' } });
+            });
+        });
+
+        describe('with "cli.web-component.path"', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    ...packageJsonFS({ cli: { 'web-component': './config.json' } }),
+                    'config.json': '',
+                });
+
+                jest.doMock(path.resolve('./config.json'), () => ({ branches: { foo: 'bar' } }), {
+                    virtual: true,
+                });
+            });
+
+            test('returns web-component config', () => {
+                expect(subject()).toEqual({ branches: { foo: 'bar' } });
+            });
+        });
+    });
+
+    describe(`${getWebComponentBranchConfigs.name}`, () => {
+        const subject = () => getWebComponentBranchConfigs();
+
+        itReturns(subject, undefined);
+
+        describe('with "cli.web-component.branches"', () => {
+            const content = { cli: { 'web-component': { branches: { foo: 'bar' } } } };
+
+            beforeEach(() => mockPackageJson(content));
+
+            test('returns "cli.web-component.branches"', () => {
+                expect(subject()).toEqual(content.cli['web-component'].branches);
+            });
+        });
+    });
+
     describe.each([
         {
             fn: isBundle,
@@ -221,6 +285,7 @@ describe('[startup] Utils', () => {
                 { cli: { 'web-component': true } },
                 { cli: { 'web-component': { legacyRoot: true } } },
                 { cli: { 'web-component': { legacyRoot: false } } },
+                { cli: { 'web-component': { branches: { develop: { publishTag: 'qa' } } } } },
             ],
         },
         {

package/src/utils/__tests__/get-jest-config.test.ts

@@ -19,13 +19,6 @@ describe('[startup] Utils', () => {
         testRunner: 'jest-circus/runner',
         transformIgnorePatterns: ['node_modules/(?!(@servicetitan|@react-hook|nanoid|axios)/)'],
         modulePathIgnorePatterns: ['<rootDir>/.*/__mocks__'],
-        transform: {
-            '^.+\\.jsx?$': [
-                'babel-jest',
-                { presets: [['@babel/preset-env', { targets: { node: 'current' } }]] },
-            ],
-            '^.+\\.tsx?$': ['ts-jest', { tsconfig: './tsconfig.test.json' }],
-        },
         moduleNameMapper: {
             '\\.(css|scss|less|png|svg|jpg|jpeg|gif|woff|woff2|eot|ttf|otf)$': 'identity-obj-proxy',
         },
@@ -34,6 +27,7 @@ describe('[startup] Utils', () => {
         coveragePathIgnorePatterns: ['^.+\\.d\\.ts$'],
         coverageReporters: ['html-spa', 'text', 'json', 'cobertura', 'lcov'],
         collectCoverageFrom: ['**/*.{ts,tsx}'],
+        preset: expect.stringMatching(/startup[\\\/]+jest/),
     };
 
     beforeEach(() => {

package/src/utils/__tests__/load-shared-dependencies.test.ts

@@ -1,10 +1,25 @@
 import { loadSharedDependencies } from '../load-shared-dependencies';
 
-describe('[Startup] utils:loadSharedDependencies', () => {
-    const getPackageDependencies = (...excluded: string[]) =>
-        Object.entries({
-            '@servicetitan/confirm': '^0.0.0',
+describe(`[startup] utils:${loadSharedDependencies.name}`, () => {
+    const defaultSharedDependencies = {
+        '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
+        '@servicetitan/anvil2': 'SharedDependencies.ServiceTitan.Anvil2',
+        'classnames': 'SharedDependencies.ClassNames',
+        'formstate': 'SharedDependencies.FormState',
+        'mobx': 'SharedDependencies.MobX',
+        'mobx-react': 'SharedDependencies.MobXReact',
+        'mobx-utils': 'SharedDependencies.MobXUtils',
+        'react': 'SharedDependencies.React',
+        'react-dom': 'SharedDependencies.ReactDOM',
+    };
+    let packageDependencies: Record<string, string> | undefined;
+    let sharedDependencies: Record<string, string> | undefined;
+
+    beforeEach(() => {
+        packageDependencies = {
+            // Default shared dependencies
             '@servicetitan/design-system': '^0.0.0',
+            '@servicetitan/anvil2': '^0.0.0',
             'classnames': '^0.0.0',
             'formstate': '^0.0.0',
             'mobx': '^0.0.0',
@@ -12,103 +27,82 @@ describe('[Startup] utils:loadSharedDependencies', () => {
             'mobx-utils': '^0.0.0',
             'react': '^0.0.0',
             'react-dom': '^0.0.0',
+            // Other dependencies
+            '@servicetitan/confirm': '^0.0.0',
             'react-input-mask': '^0.0.0',
-        }).reduce(
-            (out, [d, v]) => ({
-                ...out,
-                ...(excluded.includes(d) ? {} : { [d]: v }),
-            }),
-            {}
-        );
-
-    test('return default dependencies when manual are not configured', () => {
-        expect(loadSharedDependencies(getPackageDependencies(), undefined)).toEqual({
-            '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
-            'classnames': 'SharedDependencies.ClassNames',
-            'formstate': 'SharedDependencies.FormState',
-            'mobx': 'SharedDependencies.MobX',
-            'mobx-react': 'SharedDependencies.MobXReact',
-            'mobx-utils': 'SharedDependencies.MobXUtils',
-            'react': 'SharedDependencies.React',
-            'react-dom': 'SharedDependencies.ReactDOM',
-        });
+        };
+        sharedDependencies = undefined;
     });
 
-    test('return default dependencies except not used when manual are not configured', () => {
-        expect(loadSharedDependencies(getPackageDependencies('mobx-utils'), undefined)).toEqual({
-            '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
-            'classnames': 'SharedDependencies.ClassNames',
-            'formstate': 'SharedDependencies.FormState',
-            'mobx': 'SharedDependencies.MobX',
-            'mobx-react': 'SharedDependencies.MobXReact',
-            'react': 'SharedDependencies.React',
-            'react-dom': 'SharedDependencies.ReactDOM',
-        });
+    const subject = () => loadSharedDependencies(packageDependencies, sharedDependencies);
+
+    function omit(obj: Record<string, string>, ...exclude: string[]) {
+        return Object.fromEntries(Object.entries(obj).filter(([key]) => !exclude.includes(key)));
+    }
+
+    test('returns default shared dependencies', () => {
+        expect(subject()).toEqual(defaultSharedDependencies);
     });
 
-    test('return manual dependencies if set', () => {
-        expect(
-            loadSharedDependencies(getPackageDependencies(), {
-                '@servicetitan/confirm': 'SharedDependencies.ServiceTitan.Confirm',
-                'react-input-mask': 'SharedDependencies.ReactInputMask',
-            })
-        ).toEqual({
-            '@servicetitan/confirm': 'SharedDependencies.ServiceTitan.Confirm',
-            'react-input-mask': 'SharedDependencies.ReactInputMask',
+    describe('when package does not depend on default shared dependency', () => {
+        beforeEach(() => delete packageDependencies!['@servicetitan/design-system']);
+
+        test('omits the default shared dependency', () => {
+            expect(subject()).toEqual(
+                omit(defaultSharedDependencies, '@servicetitan/design-system')
+            );
         });
     });
 
-    test('return default dependencies within manual', () => {
-        expect(
-            loadSharedDependencies(getPackageDependencies(), {
-                defaults: '',
-            })
-        ).toEqual({
-            '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
-            'classnames': 'SharedDependencies.ClassNames',
-            'formstate': 'SharedDependencies.FormState',
-            'mobx': 'SharedDependencies.MobX',
-            'mobx-react': 'SharedDependencies.MobXReact',
-            'mobx-utils': 'SharedDependencies.MobXUtils',
-            'react': 'SharedDependencies.React',
-            'react-dom': 'SharedDependencies.ReactDOM',
+    describe('with explicit shared dependencies', () => {
+        beforeEach(() => (sharedDependencies = {}));
+
+        test('returns specified dependencies', () => {
+            expect(subject()).toEqual(sharedDependencies);
         });
-    });
 
-    test('clear default dependencies when configured', () => {
-        expect(
-            loadSharedDependencies(getPackageDependencies(), {
-                'defaults': '',
-                'mobx-utils': '',
-            })
-        ).toEqual({
-            '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
-            'classnames': 'SharedDependencies.ClassNames',
-            'formstate': 'SharedDependencies.FormState',
-            'mobx': 'SharedDependencies.MobX',
-            'mobx-react': 'SharedDependencies.MobXReact',
-            'react': 'SharedDependencies.React',
-            'react-dom': 'SharedDependencies.ReactDOM',
+        describe('when explicit shared dependencies includes "defaults"', () => {
+            beforeEach(() => (sharedDependencies!.defaults = ''));
+
+            test('returns default shared dependencies', () => {
+                expect(subject()).toEqual(defaultSharedDependencies);
+            });
+
+            describe('when explicit shared dependency has falsy value', () => {
+                beforeEach(() => {
+                    Object.assign(sharedDependencies!, { 'classnames': false, 'mobx-utils': '' });
+                });
+
+                test('omits the falsy dependency', () => {
+                    expect(subject()).toEqual(
+                        omit(defaultSharedDependencies, 'classnames', 'mobx-utils')
+                    );
+                });
+            });
+
+            describe('when explicit shared dependency has non-default packages', () => {
+                beforeEach(() => {
+                    Object.assign(sharedDependencies!, {
+                        '@servicetitan/confirm': 'SharedDependencies.ServiceTitan.Confirm',
+                        'react-input-mask': 'SharedDependencies.ReactInputMask',
+                    });
+                });
+
+                test('adds the non-default packages', () => {
+                    expect(subject()).toEqual({
+                        ...defaultSharedDependencies,
+                        ...omit(sharedDependencies!, 'defaults'),
+                    });
+                });
+            });
         });
     });
 
-    test('mixes default dependencies and configured', () => {
-        expect(
-            loadSharedDependencies(getPackageDependencies(), {
-                'defaults': '',
-                'mobx-utils': '',
-                'react-input-mask': 'SharedDependencies.ReactInputMask',
-                'react-something': 'SharedDependencies.ReactSomething',
-            })
-        ).toEqual({
-            '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
-            'classnames': 'SharedDependencies.ClassNames',
-            'formstate': 'SharedDependencies.FormState',
-            'mobx': 'SharedDependencies.MobX',
-            'mobx-react': 'SharedDependencies.MobXReact',
-            'react': 'SharedDependencies.React',
-            'react-dom': 'SharedDependencies.ReactDOM',
-            'react-input-mask': 'SharedDependencies.ReactInputMask',
+    describe('with no package dependencies', () => {
+        beforeEach(() => (packageDependencies = undefined));
+
+        test('returns empty object', () => {
+            expect(subject()).toEqual({});
         });
     });
 });

package/src/utils/get-branch-configs.ts

@@ -0,0 +1,17 @@
+import { getWebComponentBranchConfigs, WebComponentBranchConfigs } from './index';
+
+function getDefaultConfigs(): Record<string, WebComponentBranchConfigs> {
+    return {
+        develop: { publishTag: 'dev' },
+        dev: { publishTag: 'dev' },
+        next: { publishTag: 'next' },
+        master: { publishTag: 'prod' },
+    };
+}
+
+export function getBranchesConfigs(): Record<string, WebComponentBranchConfigs> {
+    const packageConfigs = getWebComponentBranchConfigs();
+    const defaultConfigs = getDefaultConfigs();
+
+    return packageConfigs ?? defaultConfigs;
+}

package/src/utils/get-configuration.ts

@@ -1,3 +1,4 @@
+import fs from 'fs';
 import path from 'path';
 
 import { Configuration as WebpackDevServerConfiguration } from 'webpack-dev-server';
@@ -5,6 +6,7 @@ import { ESLint } from 'eslint';
 import { LinterOptions } from 'stylelint';
 import { Config } from '@jest/types';
 import { readJson, readJsonSafe } from './read-json';
+import { log } from './log';
 
 export const allowedWebpackDevServerOptions = ['headers', 'port', 'proxy', 'static'] as const;
 
@@ -71,15 +73,24 @@ export enum CommandName {
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 
+export interface WebComponentBranchConfigs {
+    publishTag?: string;
+}
+
 interface WebComponentOptions {
-    legacyRoot: boolean;
+    legacyRoot?: boolean;
+    /**
+     * mapping of git branches to configs.
+     * Used to separate configs (ex publish tag) depending on current branch
+     */
+    branches?: Record<string, WebComponentBranchConfigs>;
 }
 
 type Configuration = {
     'legacy'?: boolean;
     'lint'?: { eslint: ESLintConfiguration; stylelint: StylelintConfiguration };
     'test'?: JestConfiguration;
-    'web-component'?: boolean | WebComponentOptions;
+    'web-component'?: boolean | string | WebComponentOptions;
     'webpack'?: false | WebpackConfiguration;
 } & {
     [key in CommandName]: NodeConfiguration;
@@ -120,6 +131,35 @@ export function getWebpackConfiguration(locationOrJson?: LocationOrJson) {
     return typeof webpack === 'object' ? webpack : {};
 }
 
+export function getWebComponentConfiguration(
+    locationOrJson: LocationOrJson = './'
+): WebComponentOptions | undefined {
+    const config = getConfigurationSafe(locationOrJson)['web-component'];
+
+    if (config === true) {
+        return {};
+    }
+
+    if (typeof config === 'object') {
+        return config;
+    }
+
+    if (typeof config === 'string') {
+        if (fs.existsSync(config)) {
+            return require(path.resolve(config));
+        }
+        log.warning(`could not find web-component configuration: "${config}"`);
+
+        return undefined;
+    }
+}
+
+export function getWebComponentBranchConfigs(locationOrJson: LocationOrJson = './') {
+    const config = getWebComponentConfiguration(locationOrJson);
+
+    return config?.branches;
+}
+
 export function isBundle(locationOrJson?: LocationOrJson) {
     return getConfiguration(locationOrJson).webpack !== false;
 }
@@ -142,15 +182,13 @@ export function isLegacy(locationOrJson?: LocationOrJson) {
 }
 
 export function isLegacyRoot() {
-    const config = getConfiguration()['web-component'];
-    return typeof config === 'object' && config.legacyRoot === true;
+    return getWebComponentConfiguration()?.legacyRoot === true;
 }
 
 export function isStyleCheckDisabled() {
     return getWebpackConfiguration()['disable-style-check'] === true;
 }
 
-export function isWebComponent() {
-    const config = getConfiguration()['web-component'];
-    return config === true || typeof config === 'object';
+export function isWebComponent(locationOrJson: LocationOrJson = './') {
+    return !!getWebComponentConfiguration(locationOrJson);
 }

package/src/utils/get-folders.ts

@@ -1,6 +1,6 @@
 import path from 'path';
 
-import { readJson } from '.';
+import { readJson } from './read-json';
 
 /**
  * Returns folders of sources and compilation target

package/src/utils/get-jest-config.ts

@@ -13,13 +13,6 @@ const getJestConfigBase = ({
     setupFiles?: string[];
     testPathIgnorePatterns?: string[];
 }) => {
-    const transform = {
-        '^.+\\.jsx?$': [
-            'babel-jest',
-            { presets: [['@babel/preset-env', { targets: { node: 'current' } }]] },
-        ],
-        '^.+\\.tsx?$': ['ts-jest', { tsconfig: './tsconfig.test.json' }],
-    };
     const moduleNameMapper = {
         '\\.(css|scss|less|png|svg|jpg|jpeg|gif|woff|woff2|eot|ttf|otf)$': 'identity-obj-proxy',
     };
@@ -30,7 +23,6 @@ const getJestConfigBase = ({
         testRunner: 'jest-circus/runner',
         transformIgnorePatterns: ['node_modules/(?!(@servicetitan|@react-hook|nanoid|axios)/)'],
         modulePathIgnorePatterns: ['<rootDir>/.*/__mocks__'],
-        transform,
         moduleNameMapper,
         testPathIgnorePatterns: [
             '\\.yalc',
@@ -41,6 +33,7 @@ const getJestConfigBase = ({
         coveragePathIgnorePatterns: ['^.+\\.d\\.ts$', ...coveragePathIgnorePatterns],
         coverageReporters: ['html-spa', 'text', 'json', 'cobertura', 'lcov'],
         collectCoverageFrom: ['**/*.{ts,tsx}'],
+        preset: path.join(__dirname, '../../jest'),
     };
 };
 
@@ -70,7 +63,7 @@ export const getJestConfigCLI = (args: Config.Argv): Config.Argv => {
         ...args,
     };
 
-    const { collectCoverageFrom, moduleNameMapper, transform, ...rest } = getJestConfigBase({
+    const { collectCoverageFrom, moduleNameMapper, ...rest } = getJestConfigBase({
         coveragePathIgnorePatterns,
         setupFiles,
         testPathIgnorePatterns,
@@ -80,7 +73,6 @@ export const getJestConfigCLI = (args: Config.Argv): Config.Argv => {
         collectCoverageFrom: JSON.stringify(collectCoverageFrom),
         globals: JSON.stringify(globals),
         moduleNameMapper: JSON.stringify(moduleNameMapper),
-        transform: JSON.stringify(transform),
         ...rest,
         ...config,
     };

package/src/webpack/__tests__/create-webpack-config-shared-dependencies.test.ts

@@ -33,7 +33,6 @@ jest.mock('../../utils', () => ({
     isCustomStyleRules: jest.fn(),
     isExposeSharedDependencies: jest.fn(),
     loadSharedDependencies: jest.fn(),
-    log: { debug: jest.fn(), info: jest.fn() },
 }));
 jest.mock('../utils', () => ({
     ...jest.requireActual('../utils'),