@servicetitan/startup 34.3.0-beta.2 → 35.0.0

package/src/{core/check-resource → webpack/configs/plugins/ignore-plugin}/__tests__/check-resource.test.ts

@@ -1,4 +1,4 @@
-import { BuildContext } from '../../types';
+import { Context } from '../../../types';
 import { checkResource } from '../check-resource';
 import { isOptionalPeerDependency } from '../is-optional-peer-dependency';
 import { isOptionalReactDomPeerDependency } from '../is-optional-react-dom-peer-dependency';
@@ -8,7 +8,7 @@ jest.mock('../is-optional-react-dom-peer-dependency');
 
 describe(`${checkResource.name}`, () => {
     const context = 'node_modules/web-components/dist';
-    let packageContext: BuildContext;
+    let packageContext: Partial<Context>;
     let resource: string;
 
     beforeEach(() => {
@@ -16,28 +16,15 @@ describe(`${checkResource.name}`, () => {
 
         resource = '@servicetitan/foo';
         packageContext = {
-            build: {
-                name: 'application',
-                isProduction: false,
-            },
-            package: {
+            packageData: {
                 name: 'application',
                 version: '1.0.0',
-                destination: 'dist',
-                source: 'src',
                 dependencies: {},
-                sharedDependencies: {},
-                isWebComponent: false,
-                isLegacyRoot: false,
-                isExposeSharedDependencies: false,
-            },
-            options: {
-                bundlerConfig: {},
             },
         };
     });
 
-    const subject = () => checkResource(packageContext)(resource, context);
+    const subject = () => checkResource(packageContext as any)(resource, context);
 
     function itReturns(value: boolean) {
         test(`returns ${value}`, () => expect(subject()).toBe(value));
@@ -51,7 +38,7 @@ describe(`${checkResource.name}`, () => {
         itReturns(true);
 
         describe('when resource is package dependency', () => {
-            beforeEach(() => (packageContext.package.dependencies[resource] = '*'));
+            beforeEach(() => (packageContext.packageData!.dependencies[resource] = '*'));
 
             itReturns(false);
         });

package/src/{core/check-resource → webpack/configs/plugins/ignore-plugin}/check-resource.ts

@@ -1,12 +1,12 @@
-import { log } from '../../utils';
-import { BuildContext } from '../types';
+import { log } from '../../../../utils';
+import { Context } from '../../types';
 import { isOptionalPeerDependency } from './is-optional-peer-dependency';
 import { isOptionalReactDomPeerDependency } from './is-optional-react-dom-peer-dependency';
 
-export function checkResource(packageContext: BuildContext) {
+export function checkResource(packageContext: Context) {
     return function (resource: string, context: string) {
         if (
-            !packageContext.package.dependencies[resource] &&
+            !packageContext.packageData.dependencies[resource] &&
             isOptionalPeerDependency(resource, context)
         ) {
             log.debug('check-resource', `${JSON.stringify({ resource, context })} => true`);

package/src/{core/check-resource → webpack/configs/plugins/ignore-plugin}/get-package-json.ts

@@ -1,8 +1,8 @@
 import fs from 'fs';
 import path from 'path';
-import { log, readJson } from '../../utils';
+import { log, readJson } from '../../../../utils';
 
-const containsNodeModules = /[\\/](node_modules|\.yalc|uikit)[\\/]/;
+const containsNodeModules = /[\\/](node_modules|\.yalc)[\\/]/;
 const isNodeModules = /(node_modules|\.yalc)/;
 
 export function getPackageJson(context: string) {

package/src/webpack/configs/plugins/ignore-plugin/ignore-plugin.ts

@@ -1,55 +1,13 @@
-import { Compiler } from 'webpack';
-import { BuildContext, checkResource } from '../../../../core';
-import { Overrides } from '../../../types';
+import { IgnorePlugin } from 'webpack';
+import { Context, Overrides } from '../../types';
+import { checkResource } from './check-resource';
 
-/**
- * TODO: backward compatibility
- * TODO: rename things
- * Custom plugin to replace optional peer dependencies with an empty module
- * Follows the same pattern as IgnorePlugin by tapping into normalModuleFactory hooks
- */
-class ReplaceOptionalDependenciesPlugin {
-    private readonly checkResource: (resource: string, context: string) => boolean;
-    private readonly emptyModulePath: string;
-
-    constructor(checkResource: (resource: string, context: string) => boolean) {
-        this.checkResource = checkResource;
-        this.emptyModulePath = require.resolve('./empty-module.js');
-    }
-
-    apply(compiler: Compiler) {
-        compiler.hooks.normalModuleFactory.tap(
-            'ReplaceOptionalDependenciesPlugin',
-            normalModuleFactory => {
-                normalModuleFactory.hooks.beforeResolve.tap(
-                    'ReplaceOptionalDependenciesPlugin',
-                    resolveData => {
-                        if (!resolveData) {
-                            return;
-                        }
-
-                        const { request, context } = resolveData;
-
-                        // Check if this module should be replaced
-                        if (this.checkResource(request, context)) {
-                            // Replace the request with the empty module path
-                            resolveData.request = this.emptyModulePath;
-                        }
-                    }
-                );
-            }
-        );
-    }
-}
-
-export function ignorePlugin(context: BuildContext, _: Overrides) {
+export function ignorePlugin(context: Context, _: Overrides) {
     /**
-     * Ignore optional peer dependencies by replacing them with an empty module
+     * Ignore optional peer dependencies
      * @see {@link: file://./../../../../../../web-components/src/register.tsx}
      * @see {@link: file://./../../../../../../web-components/src/render.ts}
      * @see {@link: file://./../../../../../../ko-bridge/src/ko-binding-handlers.tsx}
      */
-    const shouldIgnore = checkResource(context);
-
-    return new ReplaceOptionalDependenciesPlugin(shouldIgnore);
+    return new IgnorePlugin({ checkResource: checkResource(context) });
 }

package/src/webpack/configs/plugins/mini-css-extract-plugin.ts

@@ -1,16 +1,11 @@
 import MiniCssExtractPlugin from 'mini-css-extract-plugin';
-import { BuildContext } from '../../../core';
-import { Overrides } from '../../types';
+import { Context, Overrides } from '../types';
 
-export function miniCssExtractPlugin(context: BuildContext, overrides: Overrides) {
-    const { isProduction } = context.build;
-    const { isExposeSharedDependencies, isWebComponent } = context.package;
-    const { isCustomStyleRules, emitExposedDependencies } = context.options.bundlerConfig;
+export function miniCssExtractPlugin(context: Context, overrides: Overrides) {
+    const { isCustomStyleRules, isExposeSharedDependencies, isProduction, isWebComponent } =
+        context;
 
-    if (
-        (!isCustomStyleRules || emitExposedDependencies) &&
-        (isProduction || isWebComponent || isExposeSharedDependencies)
-    ) {
+    if (!isCustomStyleRules && (isProduction || isWebComponent || isExposeSharedDependencies)) {
         return new MiniCssExtractPlugin({
             filename: isProduction ? '[name].[contenthash].bundle.css' : '[name].bundle.css',
             ...overrides.plugins?.MiniCssExtractPlugin,

package/src/webpack/configs/plugins/moment-locales-plugin.ts

@@ -1,10 +1,9 @@
-import { BuildContext } from '../../../core';
-import { Overrides } from '../../types';
+import { Context, Overrides } from '../types';
 
 const MomentLocalesPlugin: typeof import('moment-locales-webpack-plugin') | undefined =
     isMomentInstalled() ? require('moment-locales-webpack-plugin') : undefined;
 
-export function momentLocalesPlugin(_: BuildContext, _overrides: Overrides) {
+export function momentLocalesPlugin(_: Context, _overrides: Overrides) {
     return (
         MomentLocalesPlugin &&
         new MomentLocalesPlugin({

package/src/webpack/configs/plugins/remove-empty-scripts-plugin.ts

@@ -1,9 +1,8 @@
 import RemoveEmptyScriptsPlugin from 'webpack-remove-empty-scripts';
-import { BuildContext } from '../../../core';
-import { Overrides } from '../../types';
+import { Context, Overrides } from '../types';
 
-export function removeEmptyScriptsPlugin(context: BuildContext, _overrides: Overrides) {
-    const { emitExposedDependencies } = context.options.bundlerConfig;
+export function removeEmptyScriptsPlugin(context: Context, _overrides: Overrides) {
+    const { emitExposedDependencies } = context;
     if (!emitExposedDependencies) {
         return;
     }

package/src/webpack/configs/plugins/virtual-modules-plugin.ts

@@ -1,28 +1,80 @@
 import fs from 'fs';
 import path from 'path';
 import VirtualModulesPlugin from 'webpack-virtual-modules';
-import { BuildContext, getDesignSystemPath, virtualModules } from '../../../core';
-import { Overrides } from '../../types';
+import { Context, Overrides } from '../types';
 
-export function virtualModulesPlugin(context: BuildContext, _: Overrides) {
-    const { destination } = context.package;
+export function virtualModulesPlugin(context: Context, _: Overrides) {
+    const { destination } = context;
 
-    const modules = virtualModules(context);
-    const webpackModules: ConstructorParameters<typeof VirtualModulesPlugin>[0] = {};
+    const modules: ConstructorParameters<typeof VirtualModulesPlugin>[0] = {};
 
-    if (modules.index) {
+    if (context.isWebComponent) {
         const indexPath = path.join(process.cwd(), destination, 'index');
-        webpackModules[indexPath] = modules.index;
+        modules[indexPath] = indexCode(context);
     }
 
-    if (modules.designSystem) {
+    if (needsToIncludeDesignSystem(context)) {
         const designSystemPath = getDesignSystemPath(context);
         if (!fs.existsSync(designSystemPath)) {
-            webpackModules[designSystemPath] = modules.designSystem;
+            modules[designSystemPath] = designSystemCode();
         }
     }
 
-    return Object.keys(webpackModules).length
-        ? new VirtualModulesPlugin(webpackModules)
-        : undefined;
+    return Object.keys(modules).length ? new VirtualModulesPlugin(modules) : undefined;
+}
+
+export function getDesignSystemPath({ destination }: Context) {
+    return path.join(process.cwd(), destination, 'design-system.css');
+}
+
+function designSystemCode() {
+    return [
+        `@import '~@servicetitan/tokens/core/tokens.css';`,
+        `@import '~@servicetitan/anvil-fonts/dist/css/anvil-fonts.css';`,
+        `@import '~@servicetitan/design-system/dist/system.min.css';`,
+    ].join('\n');
+}
+
+function indexCode(context: Context) {
+    const { embed = false, headless, isLegacyRoot, sharedDependencies } = context;
+    if (headless) {
+        return headlessIndex();
+    }
+
+    const options = `{ legacyRoot: ${isLegacyRoot}, sharedDependenciesNames: ${JSON.stringify(
+        Object.keys(sharedDependencies)
+    )} }`;
+    return [
+        ...(needsToIncludeDesignSystem(context) ? [`require('./design-system.css');`] : []),
+        `import { register } from '@servicetitan/web-components';`,
+        `import { App } from './app';`,
+        `register(App, ${embed}, ${options});`,
+    ].join('\n');
+}
+
+function needsToIncludeDesignSystem({
+    embed,
+    emitExposedDependencies,
+    headless,
+    isWebComponent,
+    packageData,
+    sharedDependencies,
+}: Context) {
+    return (
+        (!!emitExposedDependencies && !!sharedDependencies['@servicetitan/design-system']) ||
+        (isWebComponent &&
+            !headless &&
+            // Depends on design system
+            !!packageData.dependencies['@servicetitan/design-system'] &&
+            // ... and is not light bundle with private copy of design system
+            !(embed && !!sharedDependencies['@servicetitan/design-system']))
+    );
+}
+
+function headlessIndex() {
+    return [
+        "import { registerHeadless } from '@servicetitan/web-components';",
+        "import { connectedCallback, disconnectedCallback } from './headless';",
+        'registerHeadless(connectedCallback, disconnectedCallback);',
+    ].join('\n');
 }

package/src/webpack/configs/plugins/watch-run-plugin.ts

@@ -1,10 +1,9 @@
 import path from 'path';
 import { Compiler } from 'webpack';
-import { BuildContext } from '../../../core';
 import { log } from '../../../utils';
-import { Overrides } from '../../types';
+import { Context, Overrides } from '../types';
 
-export function watchRunPlugin(_context: BuildContext, _overrides: Overrides) {
+export function watchRunPlugin(_context: Context, _overrides: Overrides) {
     /* istanbul ignore next: debug only */
     if (log.debug('modified-files').enabled) {
         return new WatchRunPlugin();

package/src/webpack/configs/plugins-config.ts

@@ -1,6 +1,4 @@
 import { Configuration } from 'webpack';
-import { BuildContext } from '../../core';
-import { Overrides } from '../types';
 import {
     assetsManifestPlugin,
     bundleAnalyzerPlugin,
@@ -17,11 +15,12 @@ import {
     virtualModulesPlugin,
     watchRunPlugin,
 } from './plugins';
+import { Context, Overrides } from './types';
 
 type Config = Configuration['plugins'];
 type Result = Pick<Configuration, 'plugins'>;
 
-export function pluginsConfig(context: BuildContext, overrides: Overrides): Result {
+export function pluginsConfig(context: Context, overrides: Overrides): Result {
     const plugins: Config = [
         assetsManifestPlugin,
         bundleAnalyzerPlugin,

package/src/webpack/configs/resolve-config.ts

@@ -1,11 +1,10 @@
 import { Configuration } from 'webpack';
-import { BuildContext } from '../../core';
-import { Overrides } from '../types';
+import { Context, Overrides } from './types';
 
 type Config = Configuration['resolve'];
 type Result = Pick<Configuration, 'resolve'>;
 
-export function resolveConfig(_context: BuildContext, _: Overrides): Result {
+export function resolveConfig(_context: Context, _: Overrides): Result {
     const resolve: Config = {
         extensions: ['.js'],
     };

package/src/webpack/configs/rules/css-rules.ts

@@ -1,12 +1,11 @@
 import path from 'path';
 import { RuleSetRule } from 'webpack';
-import { BuildContext } from '../../../core';
 import { log } from '../../../utils';
 import { cssLoader, styleLoader } from '../loaders';
+import { Context } from '../types';
 
-export function cssRules(context: BuildContext): RuleSetRule[] {
-    const { isExposeSharedDependencies, sharedDependencies } = context.package;
-    const { emitExposedDependencies } = context.options.bundlerConfig;
+export function cssRules(context: Context): RuleSetRule[] {
+    const { emitExposedDependencies, isExposeSharedDependencies, sharedDependencies } = context;
     const result: RuleSetRule[] = [
         {
             test: /\.module.css$/,

package/src/webpack/configs/rules/font-rules.ts

@@ -1,7 +1,7 @@
 import { RuleSetRule } from 'webpack';
-import { BuildContext } from '../../../core';
+import { Context } from '../types';
 
-export function fontRules(_: BuildContext): RuleSetRule[] {
+export function fontRules(_: Context): RuleSetRule[] {
     return [
         {
             test: /\.(woff|woff2|eot|ttf|otf)$/i,

package/src/webpack/configs/rules/image-rules.ts

@@ -1,7 +1,7 @@
 import { RuleSetRule } from 'webpack';
-import { BuildContext } from '../../../core';
+import { Context } from '../types';
 
-export function imageRules(_: BuildContext): RuleSetRule[] {
+export function imageRules(_: Context): RuleSetRule[] {
     return [
         {
             test: /\.(png|jpg|jpeg|gif)$/i,

package/src/webpack/configs/rules/js-rules.ts

@@ -1,10 +1,8 @@
 import path from 'path';
 import { RuleSetRule } from 'webpack';
-import { BuildContext } from '../../../core';
+import { Context } from '../types';
 
-export function jsRules(context: BuildContext): RuleSetRule[] {
-    const { destination } = context.package;
-    const { codeCoverage } = context.options;
+export function jsRules({ codeCoverage, destination }: Context): RuleSetRule[] {
     const result: RuleSetRule[] = [
         {
             enforce: 'pre',

package/src/webpack/configs/rules/less-rules.ts

@@ -1,8 +1,8 @@
 import { RuleSetRule } from 'webpack';
-import { BuildContext } from '../../../core';
 import { cssLoader, lessLoader, styleLoader } from '../loaders';
+import { Context } from '../types';
 
-export function lessRules(context: BuildContext): RuleSetRule[] {
+export function lessRules(context: Context): RuleSetRule[] {
     return [
         {
             test: /\.module.less$/,

package/src/webpack/configs/rules/scss-rules.ts

@@ -1,8 +1,8 @@
 import { RuleSetRule } from 'webpack';
-import { BuildContext } from '../../../core';
 import { cssLoader, styleLoader } from '../loaders';
+import { Context } from '../types';
 
-export function scssRules(context: BuildContext): RuleSetRule[] {
+export function scssRules(context: Context): RuleSetRule[] {
     return [
         {
             test: /\.module.scss$/,

package/src/webpack/configs/rules/svg-rules.ts

@@ -1,7 +1,7 @@
 import { RuleSetRule } from 'webpack';
-import { BuildContext } from '../../../core';
+import { Context } from '../types';
 
-export function svgRules(_: BuildContext): RuleSetRule[] {
+export function svgRules(_: Context): RuleSetRule[] {
     // Using [\\\/] because Windows uses backslash as path separator
     const librariesRegEx = /node_modules[\\\/]@servicetitan[\\\/]anvil2/;
 

package/src/webpack/configs/rules-config.ts

@@ -1,30 +1,26 @@
 import { RuleSetRule } from 'webpack';
-import { BuildContext } from '../../core';
-import { Overrides } from '../types';
 import { getModuleEntryPath } from '../utils';
 import { cssRules, fontRules, imageRules, jsRules, lessRules, scssRules, svgRules } from './rules';
+import { Context, Overrides } from './types';
 
 interface Result {
     rules: RuleSetRule[];
 }
 
-export function rulesConfig(context: BuildContext, _: Overrides): Result {
+export function rulesConfig(context: Context, _: Overrides): Result {
     const rules = [jsRules, imageRules, fontRules, svgRules, sharedDependenciesRules].flatMap(fn =>
         fn(context)
     );
 
-    if (
-        !context.options.bundlerConfig.isCustomStyleRules ||
-        context.options.bundlerConfig.emitExposedDependencies
-    ) {
+    if (!context.isCustomStyleRules) {
         rules.push(...[scssRules, lessRules, cssRules].flatMap(fn => fn(context)));
     }
 
     return { rules };
 }
 
-function sharedDependenciesRules(context: BuildContext): RuleSetRule[] {
-    const { isExposeSharedDependencies, sharedDependencies } = context.package;
+function sharedDependenciesRules(context: Context): RuleSetRule[] {
+    const { isExposeSharedDependencies, sharedDependencies } = context;
     if (!isExposeSharedDependencies) {
         return [];
     }

package/src/webpack/configs/stats-config.ts

@@ -1,11 +1,10 @@
 import { Configuration } from 'webpack';
-import { BuildContext } from '../../core';
-import { Overrides } from '../types';
+import { Context, Overrides } from './types';
 
 type Config = Configuration['stats'];
 type Result = Pick<Configuration, 'stats'>;
 
-export function statsConfig(_context: BuildContext, _: Overrides): Result {
+export function statsConfig(_context: Context, _: Overrides): Result {
     const stats: Config = {
         all: false,
         errors: true,

package/src/webpack/configs/types.ts

@@ -0,0 +1,38 @@
+import { getPackageData, loadSharedDependencies, MinifyOptions } from '../../utils';
+import { Options } from '../types';
+export type { Overrides } from '../types';
+
+export interface Context extends Options {
+    codeCoverage?: boolean;
+    destination: string;
+    isCustomStyleRules?: boolean;
+    isExposeSharedDependencies?: boolean;
+    isLegacyRoot?: boolean;
+    isProduction?: boolean;
+    isWebComponent?: boolean;
+    minify?: MinifyOptions;
+    name: string;
+    packageData: ReturnType<typeof getPackageData>;
+    sharedDependencies: ReturnType<typeof loadSharedDependencies>;
+    source: string;
+}
+
+export interface EntryPoint {
+    css?: string[];
+    js?: string[];
+}
+
+export interface EntryPoints {
+    full?: EntryPoint;
+    light?: EntryPoint;
+    headless?: EntryPoint;
+}
+
+export interface Metadata {
+    name: string;
+    version: string;
+    bundledWith: Record<string, string | undefined>;
+    sharedDependencies: Record<string, string>;
+    dependencies: Record<string, string>;
+    entrypoints: EntryPoints;
+}

package/src/{core → webpack/configs}/utils/__tests__/build-metadata.test.ts

@@ -1,11 +1,11 @@
 import { fs, vol } from 'memfs';
-import { getStartupVersion } from '../../../utils/get-startup-version';
+import { getStartupVersion } from '../../../../utils/get-startup-version';
 import { buildMetadata, BuildMetadataParams } from '../build-metadata';
 import { getLaunchDarklySdkVersion } from '../get-launchdarkly-sdk-version';
 import { getWebComponentsVersion } from '../get-web-components-version';
 
 jest.mock('fs', () => fs);
-jest.mock('../../../utils/get-startup-version');
+jest.mock('../../../../utils/get-startup-version');
 jest.mock('../get-launchdarkly-sdk-version');
 jest.mock('../get-web-components-version');
 

package/src/{core → webpack/configs}/utils/__tests__/generate-metadata.test.ts

@@ -1,8 +1,8 @@
 import { fs, vol } from 'memfs';
 
 import * as mockedFs from 'fs';
-import { createPackage } from '../../../__mocks__';
-import { BuildContext } from '../../types';
+import { createPackage } from '../../../../__mocks__';
+import { Context } from '../../types';
 import { buildMetadata } from '../build-metadata';
 import { generateMetadata } from '../generate-metadata';
 
@@ -16,7 +16,7 @@ function generatedMetadata(dest: string) {
 describe(`[startup] ${generateMetadata.name}`, () => {
     const pkg = createPackage({});
     const destination = 'dist';
-    let context: BuildContext;
+    let context: Partial<Context>;
 
     const mockMetadata = {
         name: pkg.name,
@@ -36,30 +36,16 @@ describe(`[startup] ${generateMetadata.name}`, () => {
         jest.mocked(buildMetadata).mockReturnValue(mockMetadata);
 
         context = {
-            build: {
-                name: pkg.name,
-                isProduction: false,
-            },
-            package: {
-                name: pkg.name,
-                version: pkg.version,
-                destination,
-                source: 'src',
-                dependencies: { foo: '1.0.1' },
-                sharedDependencies: { react: 'SharedDependencies.React' },
-                isWebComponent: false,
-                isLegacyRoot: false,
-                isExposeSharedDependencies: false,
-            },
-            options: {
-                bundlerConfig: {},
-            },
+            destination,
+            name: pkg.name,
+            packageData: { name: pkg.name, version: pkg.version, dependencies: { foo: '1.0.1' } },
+            sharedDependencies: { react: 'SharedDependencies.React' },
         };
     });
 
     afterEach(() => vol.reset());
 
-    const subject = () => generateMetadata(context);
+    const subject = () => generateMetadata(context as any);
 
     function itWritesMetadataToDestination(destination: string) {
         test('writes metadata to output file', () => {
@@ -74,10 +60,10 @@ describe(`[startup] ${generateMetadata.name}`, () => {
 
         expect(buildMetadata).toHaveBeenCalledWith({
             destination,
-            name: context.build.name,
-            version: context.package.version,
-            dependencies: context.package.dependencies,
-            sharedDependencies: context.package.sharedDependencies,
+            name: context.name,
+            version: context.packageData!.version,
+            dependencies: context.packageData!.dependencies,
+            sharedDependencies: context.sharedDependencies,
         });
     });
 
@@ -86,7 +72,7 @@ describe(`[startup] ${generateMetadata.name}`, () => {
     describe('when destination directory does not exist', () => {
         const nestedDestination = 'nested/path/dist';
 
-        beforeEach(() => (context.package.destination = nestedDestination));
+        beforeEach(() => (context.destination = nestedDestination));
 
         test('creates destination directory', () => {
             subject();

package/src/{core → webpack/configs}/utils/build-metadata.ts

@@ -1,5 +1,5 @@
 import path from 'path';
-import { getStartupVersion, readJsonSafe } from '../../utils';
+import { getStartupVersion, readJsonSafe } from '../../../utils';
 import { EntryPoints, Metadata } from '../types';
 import { getLaunchDarklySdkVersion } from './get-launchdarkly-sdk-version';
 import { getWebComponentsVersion } from './get-web-components-version';

package/src/{core → webpack/configs}/utils/generate-metadata.ts

@@ -1,12 +1,11 @@
 import fs from 'fs';
 import path from 'path';
-import { log } from '../../utils';
-import { BuildContext } from '../types';
+import { log } from '../../../utils';
+import { Context } from '../types';
 import { buildMetadata } from './build-metadata';
 
-export function generateMetadata(context: BuildContext) {
-    const { destination, sharedDependencies, version, dependencies } = context.package;
-    const { name } = context.build;
+export function generateMetadata(context: Context) {
+    const { destination, name, packageData, sharedDependencies } = context;
 
     if (!fs.existsSync(destination)) {
         fs.mkdirSync(destination, { recursive: true });
@@ -15,8 +14,8 @@ export function generateMetadata(context: BuildContext) {
     const metadata = buildMetadata({
         destination,
         name,
-        version,
-        dependencies,
+        version: packageData.version,
+        dependencies: packageData.dependencies,
         sharedDependencies,
     });