@servicetitan/startup 32.0.1 → 32.2.0

package/src/cli/commands/review/rules/require-explicit-side-effects.ts

@@ -1,26 +1,26 @@
 import { ErrorSeverity, Package, PackageError, PackageRule, Project } from '../types';
-import { applyFilter, isLibrary } from '../utils';
+import { checkPackages, isLibrary } from '../utils';
 
 export class RequireExplicitSideEffects implements PackageRule {
     get id() {
         return 'require-explicit-side-effects';
     }
 
-    run({ config, packages }: Project): PackageError[] {
-        const ruleConfig = config.rules?.[this.id];
-        return applyFilter(ruleConfig, packages, ({ name }) => name).reduce((result, pkg) => {
-            if (this.needsSideEffects(pkg)) {
-                result.push({
-                    id: this.id,
-                    message: `package "${pkg.name}" omits sideEffects property`,
-                    severity: ErrorSeverity.warning,
-                    location: pkg.location,
-                });
-            }
-            return result;
-        }, [] as PackageError[]);
+    run(project: Project): PackageError[] {
+        return checkPackages(this, project, this.checkSideEffects);
     }
 
+    private readonly checkSideEffects = (pkg: Package) => {
+        if (this.needsSideEffects(pkg)) {
+            return {
+                id: this.id,
+                message: `package "${pkg.name}" omits sideEffects property`,
+                severity: ErrorSeverity.warning,
+                location: pkg.location,
+            };
+        }
+    };
+
     private needsSideEffects(pkg: Package) {
         return (
             isLibrary(pkg) &&

package/src/cli/commands/review/rules/require-one-collection-version.ts

@@ -132,9 +132,7 @@ export class RequireOneCollectionVersion implements PackageRule {
         return new Set(
             Object.entries(versions)
                 .slice(1)
-                .flatMap(([_version, dependencies]) =>
-                    Object.entries(dependencies).map(([pkg]) => pkg)
-                )
+                .flatMap(([_version, dependencies]) => Object.keys(dependencies))
         );
     }
 

package/src/cli/commands/review/rules/require-project-version-in-root-node-modules.ts

@@ -65,15 +65,11 @@ export class RequireProjectVersionInRootNodeModules implements PackageRule {
         /* istanbul ignore next: debug only */
         log.debug(`review:${this.id}`, () => JSON.stringify(dependencies, null, 2));
 
-        entries.forEach(([name, version]) =>
-            execSync(`npm pkg set dependencies["${name}"]="${version}"`, { stdio: 'inherit' })
-        );
-
-        execSync('npx startup install --fix --quiet', { stdio: 'inherit' });
-
-        entries.forEach(([name]) =>
-            execSync(`npm pkg delete dependencies["${name}"]`, { stdio: 'inherit' })
-        );
+        [
+            ...entries.map(([name, version]) => `npm pkg set dependencies["${name}"]="${version}"`),
+            'npx startup install --fix --quiet',
+            ...entries.map(([name]) => `npm pkg delete dependencies["${name}"]`),
+        ].forEach(command => execSync(command, { stdio: 'inherit' }));
     }
 
     private formatDetails(mismatches: Mismatch[]) {

package/src/cli/commands/review/rules/require-servicetitan-scope.ts

@@ -1,26 +1,26 @@
 import { ErrorSeverity, Package, PackageError, PackageRule, Project } from '../types';
-import { applyFilter, isLibrary } from '../utils';
+import { checkPackages, isLibrary } from '../utils';
 
 export class RequireServiceTitanScope implements PackageRule {
     get id() {
         return 'require-servicetitan-scope';
     }
 
-    run({ config, packages }: Project): PackageError[] {
-        const ruleConfig = config.rules?.[this.id];
-        return applyFilter(ruleConfig, packages, ({ name }) => name).reduce((result, pkg) => {
-            if (this.needsScope(pkg)) {
-                result.push({
-                    id: this.id,
-                    message: `package "${pkg.name}" should have @servicetitan scope`,
-                    severity: ErrorSeverity.warning,
-                    location: pkg.location,
-                });
-            }
-            return result;
-        }, [] as PackageError[]);
+    run(project: Project): PackageError[] {
+        return checkPackages(this, project, this.checkScope);
     }
 
+    private readonly checkScope = (pkg: Package) => {
+        if (this.needsScope(pkg)) {
+            return {
+                id: this.id,
+                message: `package "${pkg.name}" should have @servicetitan scope`,
+                severity: ErrorSeverity.warning,
+                location: pkg.location,
+            };
+        }
+    };
+
     private needsScope(pkg: Package) {
         return isLibrary(pkg) && pkg.private !== true && !pkg.name.startsWith('@servicetitan/');
     }

package/src/cli/commands/review/types.ts

@@ -8,7 +8,17 @@ export interface Project {
     config: ReviewConfiguration;
     dependencies: Dependencies;
     // Only using this subset of package-lock.json
-    packageLock: { packages: Record<string, { version: string }>; location: string };
+    packageLock: {
+        packages: Record<
+            string,
+            {
+                version: string;
+                dependencies?: Record<string, string>;
+                peerDependencies?: Record<string, string>;
+            }
+        >;
+        location: string;
+    };
     packages: Package[];
 }
 
@@ -33,6 +43,7 @@ export interface Package {
     main?: string;
     module?: string;
     name: string;
+    peerDependencies?: Record<string, string>;
     private?: boolean;
     sideEffects?: any;
     workspaces?: string[];
@@ -67,6 +78,9 @@ export interface ReviewConfiguration {
     rules?: { [id: string]: RuleConfiguration };
 }
 
-export type RuleConfiguration = Level | [Level] | [Level, { exclude?: string[] }];
+export type RuleConfiguration =
+    | Level
+    | [Level]
+    | [Level, { exclude?: string[] | Record<string, string[]> }];
 
 export type Level = 'warn' | 'error' | 'off';

package/src/cli/commands/review/utils/check-packages.ts

@@ -0,0 +1,19 @@
+import { Package, PackageError, Project } from '../types';
+import { applyFilter } from './apply-filter';
+
+type CheckFn<T> = (pkg: Package) => PackageError<T>[] | PackageError<T> | undefined;
+
+export function checkPackages<T>(
+    { id }: { id?: string },
+    { config, packages }: Project,
+    fn: CheckFn<T>
+) {
+    const ruleConfig = id ? config.rules?.[id] : undefined;
+    return applyFilter(ruleConfig, packages, ({ name }) => name).reduce((result, pkg) => {
+        const error = fn(pkg);
+        if (Array.isArray(error)) {
+            return [...result, ...error];
+        }
+        return error ? [...result, error] : result;
+    }, []);
+}

package/src/cli/commands/review/utils/index.ts

@@ -1,4 +1,5 @@
 export * from './apply-filter';
+export * from './check-packages';
 export * from './collate-dependencies';
 export * from './compare-version';
 export * from './format-depends-on';

package/src/cli/commands/test/runners/__tests__/vitest.test.ts

@@ -66,6 +66,10 @@ describe(`[startup] Test ${Vitest.name}`, () => {
         expect(vitest.close).toHaveBeenCalled();
     });
 
+    function expectCallsVitestWithConfig(config: Record<string, any>) {
+        expect(startVitest).toHaveBeenCalledWith('test', [], {}, { test: config });
+    }
+
     describe('with package.json config', () => {
         const packageJSONConfig: ViteUserConfig['test'] = { bail: 1, globals: false };
 
@@ -78,19 +82,40 @@ describe(`[startup] Test ${Vitest.name}`, () => {
         test('merges package.json config with default config', async () => {
             await subject();
 
-            expect(startVitest).toHaveBeenCalledWith(
-                'test',
-                [],
-                {},
-                { test: { ...defaultConfig, ...packageJSONConfig } }
-            );
+            expectCallsVitestWithConfig({ ...defaultConfig, ...packageJSONConfig });
+        });
+
+        describe('with omitDefault', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    'package.json': JSON.stringify({
+                        cli: {
+                            vitest: {
+                                ...packageJSONConfig,
+                                omitDefault: ['coverage.include', 'environment'],
+                            },
+                        },
+                    }),
+                });
+            });
+
+            test('omits specified defaults', async () => {
+                await subject();
+
+                const { environment, coverage, ...restDefault } = defaultConfig;
+                const { include, ...restCoverage } = coverage as any;
+                const defaultSansOmitted = { coverage: restCoverage, ...restDefault };
+
+                expectCallsVitestWithConfig({ ...defaultSansOmitted, ...packageJSONConfig });
+            });
         });
     });
 
     describe('with vite test config', () => {
-        const viteTestConfig: ViteUserConfig['test'] = { name: 'foo', watch: false };
+        let viteTestConfig: NonNullable<ViteUserConfig['test']>;
 
         beforeEach(() => {
+            viteTestConfig = { name: 'foo', watch: false };
             jest.mocked(resolveConfig).mockResolvedValue({
                 viteConfig: { test: viteTestConfig },
             } as any);
@@ -99,13 +124,57 @@ describe(`[startup] Test ${Vitest.name}`, () => {
         test('merges vite test config with default config', async () => {
             await subject();
 
-            expect(startVitest).toHaveBeenCalledWith(
-                'test',
-                [],
-                {},
-                { test: { ...defaultConfig, ...viteTestConfig } }
-            );
+            expectCallsVitestWithConfig({ ...defaultConfig, ...viteTestConfig });
         });
+
+        describe('with "coverage.include"', () => {
+            const defaultCoverageInclude = (defaultConfig.coverage as any).include;
+            const include = ['packages/foo'];
+
+            beforeEach(() => {
+                Object.assign(viteTestConfig, {
+                    coverage: { include },
+                });
+            });
+
+            test('merges default and custom "coverage.include"', async () => {
+                await subject();
+
+                expectCallsVitestWithConfig(
+                    expect.objectContaining({
+                        coverage: {
+                            ...defaultConfig.coverage,
+                            include: [...defaultCoverageInclude, ...include],
+                        },
+                    })
+                );
+            });
+
+            describe('when omitDefault contains "coverage.include"', () => {
+                beforeEach(() => {
+                    vol.fromJSON({
+                        'package.json': JSON.stringify({
+                            cli: { vitest: { omitDefault: ['coverage.include'] } },
+                        }),
+                    });
+                });
+
+                test('omits default "coverage.include"', async () => {
+                    await subject();
+
+                    expectCallsVitestWithConfig(
+                        expect.objectContaining({
+                            coverage: {
+                                ...defaultConfig.coverage,
+                                include,
+                            },
+                        })
+                    );
+                });
+            });
+        });
+
+        test('can use omitDefault to replace coverage.include', () => {});
     });
 
     describe('with command line options', () => {

package/src/cli/commands/test/runners/vitest.ts

@@ -1,6 +1,6 @@
 import { configDefaults, coverageConfigDefaults, mergeConfig, ViteUserConfig } from 'vitest/config';
 import { startVitest, parseCLI, resolveConfig } from 'vitest/node';
-import { getVitestConfiguration, log } from '../../../../utils';
+import { getVitestConfiguration, log, omit } from '../../../../utils';
 
 type VitestConfig = NonNullable<ViteUserConfig['test']>;
 
@@ -58,8 +58,10 @@ function getDefaultConfig(): VitestConfig {
 async function getUserConfig(): Promise<ViteUserConfig> {
     const { viteConfig } = await resolveConfig();
 
+    const { omitDefault = [], ...config } = getVitestConfiguration();
+
     const result = mergeConfig(
-        mergeConfig(getDefaultConfig(), getVitestConfiguration()),
+        mergeConfig(omit(getDefaultConfig(), omitDefault), config),
         viteConfig.test ?? {}
     );
 

package/src/cli/utils/__tests__/cli-git.test.ts

@@ -50,31 +50,33 @@ describe('[startup] Cli Utils (Git)', () => {
             });
         }
 
-        test(`clones ${webUrl} to destination directory`, async () => {
+        test(`clones ${sshUrl} to destination directory`, async () => {
             await subject();
 
-            expect(runCommand).toHaveBeenCalledWith(`git clone -q ${webUrl} ${destination}`, {
-                quiet: true,
-            });
+            expect(runCommand).toHaveBeenCalledWith(
+                `git clone -q ${sshUrl} ${destination}`,
+                expect.anything()
+            );
         });
 
         itReturns(true);
 
-        describe(`when cloning ${webUrl} fails`, () => {
+        describe(`when cloning ${sshUrl} fails`, () => {
             beforeEach(() => jest.mocked(runCommand).mockRejectedValueOnce('Nope!'));
 
-            test(`clones ${sshUrl} to destination directory`, async () => {
+            test(`clones ${webUrl} to destination directory`, async () => {
                 await subject();
 
-                expect(runCommand).toHaveBeenCalledWith(
-                    `git clone -q ${sshUrl} ${destination}`,
-                    expect.anything()
-                );
+                expect(runCommand).toHaveBeenCalledWith(`git clone -q ${webUrl} ${destination}`, {
+                    quiet: true,
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    env: expect.objectContaining({ GIT_TERMINAL_PROMPT: '0' }),
+                });
             });
 
             itReturns(true);
 
-            describe(`when cloning ${sshUrl} also fails`, () => {
+            describe(`when cloning ${webUrl} also fails`, () => {
                 beforeEach(() => {
                     jest.mocked(runCommand).mockRejectedValue('Nope!');
                 });
@@ -93,7 +95,7 @@ describe('[startup] Cli Utils (Git)', () => {
             });
             afterEach(() => (process.env = originalEnv));
 
-            test(`adds token to ${webUrl}`, async () => {
+            test(`clones ${webUrl} with token to destination directory`, async () => {
                 await subject();
 
                 const urlWithToken = webUrl.replace('github.com', `oauth2:${token}@github.com`);
@@ -123,34 +125,34 @@ describe('[startup] Cli Utils (Git)', () => {
         const webUrl = `https://github.com/servicetitan/${name}.git`;
         const sshUrl = `git@github.com:servicetitan/${name}.git`;
 
-        test(`checks if ${webUrl} is reachable`, () => {
+        test(`checks if ${sshUrl} is reachable`, () => {
             subject();
 
-            expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${webUrl}`, {
+            expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${sshUrl}`, {
                 quiet: true,
             });
         });
 
         itReturns(true);
 
-        describe(`when ${webUrl} is not reachable`, () => {
+        describe(`when ${sshUrl} is not reachable`, () => {
             beforeEach(() => {
                 jest.mocked(runCommandOutput).mockImplementationOnce(() => {
                     throw new Error('Oops!');
                 });
             });
 
-            test(`checks if ${sshUrl} is reachable`, () => {
+            test(`checks if ${webUrl} is reachable`, () => {
                 subject();
 
-                expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${sshUrl}`, {
+                expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${webUrl}`, {
                     quiet: true,
                 });
             });
 
             itReturns(true);
 
-            describe(`when ${sshUrl} is also unreachable`, () => {
+            describe(`when ${webUrl} is also unreachable`, () => {
                 beforeEach(() =>
                     jest.mocked(runCommandOutput).mockImplementation(() => {
                         throw new Error('Oops');

package/src/cli/utils/__tests__/maybe-create-git-folder.test.ts

@@ -36,7 +36,7 @@ describe(`[startup] Utils`, () => {
             test('creates .git folder', () => {
                 subject();
 
-                expect(mkdirSpy).toHaveBeenCalledWith('.git');
+                expect(mkdirSpy).toHaveBeenCalledWith('.git', { recursive: true });
             });
 
             describe('when command is Init', () => {

package/src/cli/utils/bundle.ts

@@ -180,7 +180,7 @@ async function runWatch(config: Configuration) {
     return new Promise<void>((_0, reject) => {
         const watching = compiler.watch({}, e => {
             if (e) {
-                watching.close(() => {
+                watching?.close(() => {
                     reject(e);
                 });
             }

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

@@ -25,7 +25,11 @@ export async function gitCloneRepo(params: Repo & { destination: string }) {
             log.debug('git:clone-repo', `running ${command}`);
 
             // eslint-disable-next-line no-await-in-loop
-            await runCommand(command, { quiet: true });
+            await runCommand(command, {
+                quiet: true,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            });
             return true;
         } catch {
             // ignore error
@@ -50,10 +54,7 @@ function getGitUrls({ owner, name }: Repo) {
     const webUrl = `https://github.com/${owner}/${name}.git`;
     const sshUrl = `git@github.com:${owner}/${name}.git`;
 
-    const urls = [webUrl, sshUrl];
-    if (isCI() && !!process.env.GITHUB_TOKEN) {
-        urls.unshift(webUrl.replace('github.com', `oauth2:${process.env.GITHUB_TOKEN}@github.com`));
-    }
-
-    return urls;
+    return isCI() && !!process.env.GITHUB_TOKEN
+        ? [webUrl.replace('github.com', `oauth2:${process.env.GITHUB_TOKEN}@github.com`)]
+        : [sshUrl, webUrl];
 }

package/src/cli/utils/maybe-create-git-folder.ts

@@ -19,6 +19,11 @@ export function maybeCreateGitFolder(command: Newable<Command>) {
         return;
     }
     if (!fs.existsSync('.git')) {
-        fs.mkdirSync('.git');
+        /*
+         * Using {recursive: true} to ignore if directory exists. This happens
+         * when parallel process creates the directory after we've checked
+         * whether it exists.
+         */
+        fs.mkdirSync('.git', { recursive: true });
     }
 }

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

@@ -2,6 +2,7 @@ import { Config } from '@jest/types';
 import path from 'path';
 import { getJestConfiguration } from '../get-configuration';
 import { getDestinationFolders } from '../get-destination-folders';
+import { pick } from '../pick';
 
 import { getJestConfigCLI } from '../get-jest-config';
 
@@ -76,5 +77,48 @@ describe('[startup] Utils', () => {
                 expect.objectContaining({ transform: JSON.stringify(transform) })
             );
         });
+
+        describe('with "omitDefault"', () => {
+            beforeEach(() => {
+                jest.mocked(getJestConfiguration).mockReturnValue({
+                    omitDefault: Object.keys(defaultConfig),
+                });
+            });
+
+            test('omits specified defaults', () => {
+                expect(pick(subject(), getJestConfiguration().omitDefault!)).toEqual({});
+            });
+        });
+
+        describe.each(['coveragePathIgnorePatterns', 'setupFiles', 'testPathIgnorePatterns'])(
+            'with custom "%s"',
+            key => {
+                let customConfig: Record<string, string[]>;
+
+                beforeEach(() => {
+                    customConfig = { [key]: ['foo'] };
+                    jest.mocked(getJestConfiguration).mockReturnValue(customConfig);
+                });
+
+                test('appends custom value to default', () => {
+                    expect(subject()).toEqual(
+                        expect.objectContaining({
+                            [key]: [
+                                ...defaultConfig[key],
+                                ...(getJestConfiguration()[key] as string[]),
+                            ],
+                        })
+                    );
+                });
+
+                describe('when default is omitted', () => {
+                    beforeEach(() => (customConfig.omitDefault = [key]));
+
+                    test('returns only custom value', () => {
+                        expect(subject()[key]).toEqual(customConfig[key]);
+                    });
+                });
+            }
+        );
     });
 });

package/src/utils/get-configuration.ts

@@ -51,7 +51,9 @@ export interface StylelintConfiguration extends Partial<LinterOptions> {
     disabled?: boolean;
 }
 
-export type JestConfiguration = Omit<Config.Argv, '_' | '$0'>;
+export interface JestConfiguration extends Omit<Config.Argv, '_' | '$0'> {
+    omitDefault?: string[];
+}
 
 export interface NodeConfiguration {
     // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -82,7 +84,9 @@ export enum CommandName {
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 
-export type VitestConfiguration = ViteUserConfig['test'];
+export type VitestConfiguration = ViteUserConfig['test'] & {
+    omitDefault?: string[];
+};
 
 export interface WebComponentBranchConfigs {
     publishTag?: string;

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

@@ -3,16 +3,9 @@ import path from 'path';
 import { getJestConfiguration } from './get-configuration';
 import { getDestinationFolders } from './get-destination-folders';
 import { toArray } from './to-array';
+import { omit } from './omit';
 
-function getDefaultJestConfiguration({
-    coveragePathIgnorePatterns = [],
-    setupFiles = [],
-    testPathIgnorePatterns = [],
-}: {
-    coveragePathIgnorePatterns?: string[];
-    setupFiles?: string[];
-    testPathIgnorePatterns?: string[];
-}) {
+function getDefaultJestConfiguration() {
     const moduleNameMapper = {
         '\\.(css|scss|less|png|svg|svg\\?\\w+|jpg|jpeg|gif|woff|woff2|eot|ttf|otf)$':
             'identity-obj-proxy',
@@ -20,21 +13,21 @@ function getDefaultJestConfiguration({
 
     return {
         collectCoverageFrom: ['**/*.{ts,tsx}'],
-        coveragePathIgnorePatterns: ['^.+\\.d\\.ts$', ...coveragePathIgnorePatterns],
+        coveragePathIgnorePatterns: ['^.+\\.d\\.ts$'],
         coverageReporters: ['html-spa', 'text', 'json', 'cobertura', 'lcov'],
         moduleNameMapper,
         modulePathIgnorePatterns: ['<rootDir>/.*/__mocks__'],
         preset: path.join(__dirname, '../../jest'),
-        setupFiles: [path.join(__dirname, '../../jest/setup.js'), ...toArray(setupFiles)],
+        setupFiles: [path.join(__dirname, '../../jest/setup.js')],
         testEnvironment: 'jsdom',
-        testPathIgnorePatterns: [
-            '\\.yalc',
-            ...getDestinationFolders(),
-            ...toArray(testPathIgnorePatterns),
-        ],
+        testPathIgnorePatterns: ['\\.yalc', ...getDestinationFolders()],
         testRunner: 'jest-circus/runner',
         transformIgnorePatterns: ['node_modules/(?!(@servicetitan|@react-hook|nanoid|axios)/)'],
         verbose: true,
+    } as Omit<Config.Argv, 'collectCoverageFrom' | 'moduleNameMapper' | 'setupFiles'> & {
+        collectCoverageFrom: string[];
+        moduleNameMapper: Record<string, string>;
+        setupFiles: string[];
     };
 }
 
@@ -42,13 +35,21 @@ function getDefaultJestConfiguration({
  * Get Jest config for running it using jest CLI (see jest runCLI function)
  */
 export function getJestConfigCLI(args: Config.Argv): Config.Argv {
-    const { coveragePathIgnorePatterns, setupFiles, testPathIgnorePatterns, ...config } = {
+    const {
+        coveragePathIgnorePatterns,
+        omitDefault = [],
+        setupFiles,
+        testPathIgnorePatterns,
+        ...config
+    } = {
         ...getJestConfiguration(),
         ...args,
     };
 
+    const defaultConfig = omit(getDefaultJestConfiguration(), omitDefault);
+
     return stringifyForCLI({
-        ...getDefaultJestConfiguration({
+        ...mergeArrayValues(defaultConfig, {
             coveragePathIgnorePatterns,
             setupFiles,
             testPathIgnorePatterns,
@@ -57,6 +58,23 @@ export function getJestConfigCLI(args: Config.Argv): Config.Argv {
     });
 }
 
+function mergeArrayValues(
+    config: any,
+    arrayValues: {
+        coveragePathIgnorePatterns?: string | string[];
+        setupFiles?: string | string[];
+        testPathIgnorePatterns?: string | string[];
+    }
+) {
+    return Object.keys(arrayValues).reduce((result, key: keyof typeof arrayValues) => {
+        const newValue = arrayValues[key];
+        if (newValue) {
+            result[key] = [...toArray(result[key]), ...toArray(newValue)];
+        }
+        return result;
+    }, config);
+}
+
 function stringifyForCLI(config: any): Config.Argv {
     return ['collectCoverageFrom', 'globals', 'moduleNameMapper', 'transform'].reduce(
         (result, key) => {

package/src/utils/index.ts

@@ -14,6 +14,7 @@ export * from './get-tsconfig';
 export * from './load-shared-dependencies';
 export * from './log';
 export * from './log-errors';
+export * from './omit';
 export * from './pick';
 export * from './read-json';
 export * from './to-array';