/**

* Link the root-level monorepo packages to the framework directories of the examples monorepo.

*/

import fse from 'fs-extra';

import path from 'path';

import glob from 'glob';

import yargs from 'yargs';

import { hideBin } from 'yargs/helpers';

import { fileURLToPath } from 'url';

import {

displayConfirmationMessage,

displayErrorMessage,

displayWarningMessage

} from '../../scripts/utils/index.mjs';

import examplesPackageJson from '../package.json' with { type: 'json' };

import mainPackageJson from '../../package.json' with { type: 'json' };

const __dirname = path.dirname(fileURLToPath(import.meta.url));

const exampleFrameworkSubdirs = examplesPackageJson.internal.framework_dirs;

const hotWorkspaces = mainPackageJson.workspaces;

const isPackageRequired = (packageName, packageLocation) => {

const frameworkName = packageName.split('/').pop() || null;

const isLegacyAngularExample = packageLocation.includes('/angular-9/') || packageLocation.includes('/angular-10/');

return (

// If the required package is handsontable

packageName === 'handsontable' ||

packageLocation.includes(frameworkName) ||

// If the required package is @handsontable/angular-wrapper

(frameworkName === 'angular' && packageName === '@handsontable/angular-wrapper' && !isLegacyAngularExample) ||

// If it's in the framework directory

packageLocation.split('/').pop().includes(frameworkName) ||

// If it's deeper in the framework directory

packageLocation.includes(`/${frameworkName}/`)

);

};

const packagesToLink = [];

const linkPackage = (sourceLocation, linkLocation, packageName, exampleDir = false) => {

const mainDependencyLocationPath = `${sourceLocation}/${packageName}`;

const destinationDependencyLocationPath = `${linkLocation}/${packageName}`;

if (isPackageRequired(packageName, linkLocation) && fse.pathExistsSync(path.resolve(mainDependencyLocationPath))) {

try {

const destinationPath = path.resolve(destinationDependencyLocationPath);

// Check if destination exists and remove it appropriately

if (fse.pathExistsSync(destinationPath)) {

const stats = fse.lstatSync(destinationPath);

if (stats.isSymbolicLink() || stats.isFile()) {

// Remove symlinks and files with unlinkSync

fse.unlinkSync(destinationPath);

} else if (stats.isDirectory()) {

// Remove directories with removeSync

fse.removeSync(destinationPath);

}

}

fse.ensureSymlinkSync(

path.resolve(mainDependencyLocationPath),

destinationPath,

'junction',

);

} catch (e) {

displayErrorMessage(e);

process.exit(1);

}

displayConfirmationMessage(`${exampleDir ? '\t' : ''}Symlink created for ${packageName} in ${

linkLocation.replace(path.resolve(__dirname, '..'), '').replace('/node_modules', '')}.`);

}

};

const argv = yargs(hideBin(process.argv))

.describe('examples-version', 'Version of the examples package to do the linking in.')

.alias('f', 'framework')

.array('f')

.describe('f', 'Target framework to the linking to take place in. Defaults to none.')

.argv;

if (!argv.f) {

displayWarningMessage('No frameworks passed as a `-f` argument, exiting.');

process.exit(0);

}

for (const hotPackageGlob of hotWorkspaces) {

const mainPackages = glob.sync(`../${hotPackageGlob}`);

for (const mainPackageUrl of mainPackages) {

const { default: packagePackageJson } = await import(`../${mainPackageUrl}/package.json`, { with: { type: 'json' } });

const packageName = packagePackageJson.name;

packagesToLink.push(packageName);

}

}

exampleFrameworkSubdirs.forEach((packagesLocation) => {

const subdirs = glob.sync(`./${packagesLocation}`);

subdirs.forEach((packageLocation) => {

const frameworkLocationName = packageLocation.split('/').pop();

if (

packageLocation.startsWith(`./${argv.examplesVersion}`) &&

((argv.framework && argv.framework.includes(frameworkLocationName)) ||

!argv.framework)

) {

// Currently linking the live dependencies only for the 'next' directory.

if (argv.examplesVersion.startsWith('next')) {

packagesToLink.forEach((packageName) => {

linkPackage(

path.resolve('./node_modules'),

path.resolve(packageLocation, './node_modules'),

packageName

);

});

}

// Additional linking to all the examples for Angular (required to load css files from `angular.json`)

if (/^angular(-(\d+|next|wrapper))?$/.test(frameworkLocationName)) {

const angularPackageJson = fse.readJSONSync(`${packageLocation}/package.json`);

const workspacesList = angularPackageJson?.workspaces.packages || angularPackageJson?.workspaces;

workspacesList.forEach((angularPackagesLocation) => {

const angularPackageDirs = glob.sync(`${packageLocation}/${angularPackagesLocation}`);

angularPackageDirs.forEach((angularPackageLocation) => {

packagesToLink.forEach((packageName) => {

linkPackage(

path.resolve(angularPackageLocation, '../node_modules'),

path.resolve(angularPackageLocation, './node_modules'),

packageName,

true

);

});

});

});

}

}

});

});