@fontoxml/fontoxml-development-tools 3.8.1 → 3.9.0-beta.3

package/src/modules/editor-pre-7-7-0/src/api/schema/createSchemaExperiencePackages.js

@@ -1,42 +1,62 @@
-// @TODO: @TS: Remove file extensions from imports in generated files when
-// supporting TS configuration.
-
 import babel from '@babel/core';
 import fs from 'fs-extra';
 import os from 'os';
 import path from 'path';
 
+import { isPre7170Editor } from '../../../../../editorVersions.js';
 import addCommentToAstNode from '../addCommentToAstNode.js';
 import createPackageDirectoryPath from '../createPackageDirectoryPath.js';
 import createPrettifiedCode from '../createPrettifiedCode.js';
 import writeAstProgramToFile from '../writeAstProgramToFile.js';
+import buildElementConfigurations from './buildElementConfigurations.js';
 import buildSchemaExperienceConfigurationModel from './buildSchemaExperienceConfigurationModel.js';
-import createCommentsForElement from './createCommentsForElement.js';
 
 const t = babel.types;
 const template = babel.template;
 
-// Babel templates.
-const buildConfigureAsRemoved = template(
-	'configureAsRemoved(sxModule, SELECTOR);'
-);
 const buildConfigureAsRemovedImport = template(
-	`import configureAsRemoved from 'fontoxml-families/src/configureAsRemoved.js';`
+	`import configureAsRemoved from 'fontoxml-families/src/configureAsRemoved';`
 );
+
 const buildDefaultExportConfigureSxModule = template(
-	'export default function configureSxModule (sxModule) {SX_CONFIGURATION}'
+	`export default function configureSxModule(sxModule) {SX_CONFIGURATION}`
 );
+const buildDefaultExportConfigureSxModuleTS = template(
+	`export default function configureSxModule(sxModule: SxModule): void {SX_CONFIGURATION}`,
+	{
+		plugins: ['typescript'],
+	}
+);
+
 const buildDefaultExportInstall = template(
 	'export default function install() {}'
 );
+const buildDefaultExportInstallTS = template(
+	'export default function install(): void {}',
+	{
+		plugins: ['typescript'],
+	}
+);
+
 const buildMarkAsAddon = template(`sxModule.markAsAddon();`);
+
 const buildPivotModelTransformerManagerImport = template(
-	`import pivotModelTransformerManager from 'fontoxml-pivot-model/src/pivotModelTransformerManager.js';`
+	`import pivotModelTransformerManager from 'fontoxml-pivot-model/src/pivotModelTransformerManager';`
 );
+
 const buildRegisterTransformers = template(
 	'pivotModelTransformerManager.registerTransformers(sxModule, []);'
 );
 
+const buildXqImport = template(`import xq from 'fontoxml-selectors/src/xq';`);
+
+const buildSxModuleTypeImport = template(
+	`import type { SxModule } from 'fontoxml-modular-schema-experience/src/sxManager';`,
+	{
+		plugins: ['typescript'],
+	}
+);
+
 // Configuration constants.
 const PIVOT_MODEL_TRANSLATION_PACKAGE_NAME = 'editor-clipboard-configuration';
 
@@ -50,61 +70,24 @@ const PIVOT_MODEL_TRANSLATION_PACKAGE_NAME = 'editor-clipboard-configuration';
  */
 async function addPackageToManifestFile(manifestFilePath, packageName) {
 	const content = await fs.readJson(manifestFilePath);
+
 	content.dependencies[packageName] = path.posix.join(
 		'packages',
 		packageName
 	);
-	await fs.outputJson(manifestFilePath, content, { spaces: '\t' });
-}
 
-/**
- * Builds an array of Babel templates containing the schema experience configuration for the given elements.
- *
- * @param {Object} elements             The sx configuration elements for which to create Babel templates.
- * @param {Object} prefixByNamespaceUri The namespace URIs with their prefix.
- *
- * @return {Object}
- */
-function buildElementConfigurations(elements, prefixByNamespaceUri) {
-	return (
-		elements
-			// Sort the elements ascending by the localName property.
-			.sort((a, b) =>
-				a.localName < b.localName
-					? -1
-					: a.localName > b.localName
-					? 1
-					: 0
-			)
-			.map((element) => {
-				const elementSelector = element.namespacePrefix
-					? `self::${element.namespacePrefix}:${element.localName}`
-					: `self::${element.localName}`;
-
-				const elementConfiguration = buildConfigureAsRemoved({
-					SELECTOR: t.stringLiteral(elementSelector),
-				});
-
-				const comments = createCommentsForElement(
-					element,
-					prefixByNamespaceUri
-				);
-
-				// Add preceding comments to the element configuration.
-				addCommentToAstNode(elementConfiguration, comments);
-
-				return elementConfiguration;
-			})
-	);
+	await fs.outputJson(manifestFilePath, content, { spaces: '\t' });
 }
 
 /**
- * Creates a configureSxModule.js file for a schema experience package.
+ * Creates a configureSxModule.ts/js file for a schema experience package.
  *
  * @param {string}   sxPackagePath        The schema experience package path.
  * @param {Object}   elements             The elements to configure.
  * @param {Object}   prefixByNamespaceUri The namespace URIs with their prefix.
  * @param {string[]} addons               The addons to include in the manifest file.
+ * @param {string}   version              The SDK version used to configure.
+ * @param {boolean}  useTypeScript        Output TypeScript instead of JavaScript.
  *
  * @return {Promise}
  */
@@ -112,16 +95,23 @@ async function createConfigureSxModuleJS(
 	sxPackagePath,
 	elements,
 	prefixByNamespaceUri,
-	addons
+	addons,
+	version,
+	useTypeScript
 ) {
 	const elementConfigurations = buildElementConfigurations(
 		elements,
-		prefixByNamespaceUri
+		prefixByNamespaceUri,
+		version
 	);
-	const defaultExportConfigureSxModuleStatement =
-		buildDefaultExportConfigureSxModule({
-			SX_CONFIGURATION: elementConfigurations,
-		});
+
+	const defaultExportConfigureSxModuleStatement = useTypeScript
+		? buildDefaultExportConfigureSxModuleTS({
+				SX_CONFIGURATION: elementConfigurations,
+		  })
+		: buildDefaultExportConfigureSxModule({
+				SX_CONFIGURATION: elementConfigurations,
+		  });
 
 	addCommentToAstNode(defaultExportConfigureSxModuleStatement, [
 		'configureSxModule is meant for registering configuration for one or more schemas, such as element',
@@ -133,7 +123,18 @@ async function createConfigureSxModuleJS(
 		'https://documentation.fontoxml.com/latest/family-71e1eb7b5cab',
 	]);
 
-	const configureAsRemovedImport = buildConfigureAsRemovedImport();
+	const importStatements = [];
+
+	if (useTypeScript) {
+		const configureSxModuleImport = buildSxModuleTypeImport();
+		importStatements.push(configureSxModuleImport);
+	}
+
+	importStatements.push(buildConfigureAsRemovedImport());
+
+	if (!isPre7170Editor(version)) {
+		importStatements.push(buildXqImport());
+	}
 
 	const isMathMLPackage = elements.every(
 		(el) => el.namespaceUri === 'http://www.w3.org/1998/Math/MathML'
@@ -142,7 +143,7 @@ async function createConfigureSxModuleJS(
 	if (isMathMLPackage) {
 		if (!addons.includes('fontoxml-mathml')) {
 			addCommentToAstNode(
-				configureAsRemovedImport,
+				importStatements[importStatements.length - 1],
 				[
 					'TODO 👉: Configure the MathML addon.',
 					'For more information:',
@@ -165,16 +166,18 @@ async function createConfigureSxModuleJS(
 		);
 	}
 
-	// Generate the AST for the schema experience configureSxModule.js file.
+	// Generate the AST for the schema experience configureSxModule.ts/js file.
 	const configureSxModuleJsFilePath = path.join(
 		sxPackagePath,
 		'src',
-		'configureSxModule.js'
+		`configureSxModule${useTypeScript ? '.ts' : '.js'}`
 	);
+
 	const configureSxModuleJsAst = t.program([
-		configureAsRemovedImport,
+		...importStatements,
 		defaultExportConfigureSxModuleStatement,
 	]);
+
 	await writeAstProgramToFile(
 		configureSxModuleJsFilePath,
 		configureSxModuleJsAst
@@ -182,14 +185,18 @@ async function createConfigureSxModuleJS(
 }
 
 /**
- * Creates a install.js file for a schema experience package.
+ * Creates an install.ts/js file for a schema experience package.
  *
- * @param {string} sxPackagePath The schema experience package path.
+ * @param {string}  sxPackagePath The schema experience package path.
+ * @param {boolean} useTypeScript Output TypeScript instead of JavaScript.
  *
  * @return {Promise}
  */
-async function createInstallJS(sxPackagePath) {
-	const defaultExportInstallStatement = buildDefaultExportInstall();
+async function createInstallJS(sxPackagePath, useTypeScript) {
+	const defaultExportInstallStatement = useTypeScript
+		? buildDefaultExportInstallTS()
+		: buildDefaultExportInstall();
+
 	addCommentToAstNode(defaultExportInstallStatement, [
 		'install is meant for registering custom functionality, such as custom operation steps and UI',
 		'components. Any set-up for the package involving managers, such as setting up notifier callbacks,',
@@ -209,9 +216,15 @@ async function createInstallJS(sxPackagePath) {
 		'Your custom configuration code goes here.'
 	);
 
-	// Generate the AST for the schema experience install.js file.
-	const installJsFilePath = path.join(sxPackagePath, 'src', 'install.js');
+	// Generate the AST for the schema experience install.ts/js file.
+	const installJsFilePath = path.join(
+		sxPackagePath,
+		'src',
+		`install${useTypeScript ? '.ts' : '.js'}`
+	);
+
 	const installJsAst = t.program([defaultExportInstallStatement]);
+
 	await writeAstProgramToFile(installJsFilePath, installJsAst);
 }
 
@@ -222,6 +235,8 @@ async function createInstallJS(sxPackagePath) {
  * @param {Object}   schemaExperiencePackage The schema experience model for the package to create.
  * @param {Object}   prefixByNamespaceUri    The namespace URIs with their prefix.
  * @param {string[]} addons                  The addons to include in the manifest file.
+ * @param {string}   version                 The sdk version used to configure.
+ * @param {boolean}  useTypeScript           Output TypeScript instead of JavaScript.
  *
  * @return {Promise}
  */
@@ -229,7 +244,9 @@ async function createSchemaExperiencePackage(
 	outputPath,
 	schemaExperiencePackage,
 	prefixByNamespaceUri,
-	addons
+	addons,
+	version,
+	useTypeScript
 ) {
 	// Create the sx package directory.
 	const sxPackageName = schemaExperiencePackage.sxPackageName;
@@ -261,22 +278,26 @@ async function createSchemaExperiencePackage(
 		sxPackagePath,
 		schemaExperiencePackage.elements,
 		prefixByNamespaceUri,
-		addons
+		addons,
+		version,
+		useTypeScript
 	);
-	await createInstallJS(sxPackagePath);
+	await createInstallJS(sxPackagePath, useTypeScript);
 }
 
 /**
  * Creates the schema experience pivot model translation package.
  *
- * @param {string} outputPath  The path of the Fonto Editor, or the schema source directory.
- * @param {string} packageName The name of the pivot model translation package.
+ * @param {string}  outputPath    The path of the Fonto Editor, or the schema source directory.
+ * @param {string}  packageName   The name of the pivot model translation package.
+ * @param {boolean} useTypeScript Output TypeScript instead of JavaScript.
  *
  * @return {Promise}
  */
 async function createSchemaExperiencePivotModelTranslationPackage(
 	outputPath,
-	packageName
+	packageName,
+	useTypeScript
 ) {
 	// Create the package directory.
 	const pivotModelPackagePath = await createPackageDirectoryPath(
@@ -313,18 +334,26 @@ async function createSchemaExperiencePivotModelTranslationPackage(
 		true
 	);
 
-	const configureSxModuleJsAst = t.program([
-		buildPivotModelTransformerManagerImport(),
-		buildDefaultExportConfigureSxModule({
-			SX_CONFIGURATION: markAsAddonStatement,
-		}),
-	]);
+	const configureSxModuleJsAst = t.program(
+		[
+			useTypeScript ? buildSxModuleTypeImport() : null,
+			buildPivotModelTransformerManagerImport(),
+			useTypeScript
+				? buildDefaultExportConfigureSxModuleTS({
+						SX_CONFIGURATION: markAsAddonStatement,
+				  })
+				: buildDefaultExportConfigureSxModule({
+						SX_CONFIGURATION: markAsAddonStatement,
+				  }),
+		].filter(Boolean)
+	);
 
 	const configureSxModuleJsFilePath = path.join(
 		pivotModelPackagePath,
 		'src',
-		'configureSxModule.js'
+		`configureSxModule${useTypeScript ? '.ts' : '.js'}`
 	);
+
 	await writeAstProgramToFile(
 		configureSxModuleJsFilePath,
 		configureSxModuleJsAst
@@ -339,6 +368,8 @@ async function createSchemaExperiencePivotModelTranslationPackage(
  * @param {Object}   compiledSchemaResultsByXsdPath The compiled schema for a package by xsd path.
  * @param {Object}   prefixByNamespaceUri           The namespace URIs with their prefix.
  * @param {string[]} addons                         The addons to include in the manifest file.
+ * @param {string}   version                        The SDK version used to configure.
+ * @param {boolean}  useTypeScript                  Output TypeScript instead of JavaScript.
  *
  * @return {Promise}
  */
@@ -347,11 +378,14 @@ export default async function createSchemaExperiencePackages(
 	schemaPackagesByXsdPath,
 	compiledSchemaResultsByXsdPath,
 	prefixByNamespaceUri,
-	addons
+	addons,
+	version,
+	useTypeScript
 ) {
 	await createSchemaExperiencePivotModelTranslationPackage(
 		outputPath,
-		PIVOT_MODEL_TRANSLATION_PACKAGE_NAME
+		PIVOT_MODEL_TRANSLATION_PACKAGE_NAME,
+		useTypeScript
 	);
 
 	const schemaExperiencePackages = buildSchemaExperienceConfigurationModel(
@@ -365,7 +399,9 @@ export default async function createSchemaExperiencePackages(
 			outputPath,
 			schemaExperiencePackage,
 			prefixByNamespaceUri,
-			addons
+			addons,
+			version,
+			useTypeScript
 		);
 	}
 

package/src/modules/editor-pre-7-7-0/src/api/schema/createSchemaPackages.js

@@ -36,8 +36,8 @@ async function createPackageManifestJsonFile(packageDirectoryPath) {
  * Create the schema file for a specific package.
  *
  * @param {string} packageDirectoryPath The path to a single package directory.
- * @param {string} packageName The package name.
- * @param {Object} schemaData The schema data for this package.
+ * @param {string} packageName          The package name.
+ * @param {Object} schemaData           The schema data for this package.
  *
  * @return {Promise}
  */
@@ -58,25 +58,27 @@ async function createPackageSchemaJsonFile(
 }
 
 /**
- * Create the SCHEMA_LOCATIONS.js file for a specific package.
+ * Create the SCHEMA_LOCATIONS.ts/js file for a specific package.
  *
- * @param {string} packageDirectoryPath The path to a single package directory.
- * @param {Array<string>} schemaLocations An array of schema locations for this package.
+ * @param {string}        packageDirectoryPath The path to a single package directory.
+ * @param {Array<string>} schemaLocations      An array of schema locations for this package.
+ * @param {boolean}       useTypeScript        Output TypeScript instead of JavaScript.
  *
  * @return {Promise}
  */
 async function createPackageSchemaLocationsJsFile(
 	packageDirectoryPath,
-	schemaLocations = []
+	schemaLocations = [],
+	useTypeScript
 ) {
-	const t = babel.types;
-	// @TODO: @TS: Remove file extensions from imports in generated imports when
-	// supporting TS configuration.
-	const schemaLocationsJsFilePath = path.join(
+	const { types: t } = babel;
+
+	const schemaLocationsFilePath = path.join(
 		packageDirectoryPath,
 		'src',
-		'SCHEMA_LOCATIONS.js'
+		`SCHEMA_LOCATIONS${useTypeScript ? '.ts' : '.js'}`
 	);
+
 	const schemaLocationsJsAst = t.program([
 		t.exportDefaultDeclaration(
 			t.arrayExpression(
@@ -86,19 +88,18 @@ async function createPackageSchemaLocationsJsFile(
 			)
 		),
 	]);
-	await writeAstProgramToFile(
-		schemaLocationsJsFilePath,
-		schemaLocationsJsAst
-	);
+
+	await writeAstProgramToFile(schemaLocationsFilePath, schemaLocationsJsAst);
 }
 
 /**
  * Create a schema package from a compiled schema.
  *
- * @param {string} outputPath The path of the Fonto Editor, or the schema source directory.
- * @param {Object} schemaPackagesByXsdPath The package information by xsd path.
- * @param {Object} compiledSchemaResultsByXsdPath The compiled schema for a package by xsd path.
- * @param {string} xsdPath The path of the xsd file for this package.
+ * @param {string}  outputPath                     The path of the Fonto Editor, or the schema source directory.
+ * @param {Object}  schemaPackagesByXsdPath        The package information by xsd path.
+ * @param {Object}  compiledSchemaResultsByXsdPath The compiled schema for a package by xsd path.
+ * @param {string}  xsdPath                        The path of the xsd file for this package.
+ * @param {boolean} useTypeScript                  Output TypeScript instead of JavaScript.
  *
  * @return {Promise}
  */
@@ -106,7 +107,8 @@ async function createSchemaPackageFromCompiledSchemaResults(
 	outputPath,
 	schemaPackagesByXsdPath,
 	compiledSchemaResultsByXsdPath,
-	xsdPath
+	xsdPath,
+	useTypeScript
 ) {
 	// Resolve the schema package directory path.
 	const schemaPackage = schemaPackagesByXsdPath[xsdPath];
@@ -124,7 +126,8 @@ async function createSchemaPackageFromCompiledSchemaResults(
 		),
 		await createPackageSchemaLocationsJsFile(
 			schemaPackageDirectoryPath,
-			schemaPackage.locations
+			schemaPackage.locations,
+			useTypeScript
 		),
 	]);
 }
@@ -133,16 +136,18 @@ async function createSchemaPackageFromCompiledSchemaResults(
  * Create all schema packages, will also create the fonto-manifest.json file when the package
  * directory does not yet exists.
  *
- * @param {string} outputPath The path of the Fonto Editor, or the schema source directory.
- * @param {Object} schemaPackagesByXsdPath The package information by xsd path.
- * @param {Object} compiledSchemaResultsByXsdPath The compiled schema for a package by xsd path.
+ * @param {string}  outputPath                     The path of the Fonto Editor, or the schema source directory.
+ * @param {Object}  schemaPackagesByXsdPath        The package information by xsd path.
+ * @param {Object}  compiledSchemaResultsByXsdPath The compiled schema for a package by xsd path.
+ * @param {boolean} useTypeScript                  Output TypeScript instead of JavaScript.
  *
  * @return {Promise}
  */
 export default async function createSchemaPackages(
 	outputPath,
 	schemaPackagesByXsdPath,
-	compiledSchemaResultsByXsdPath
+	compiledSchemaResultsByXsdPath,
+	useTypeScript
 ) {
 	await Promise.all(
 		Object.keys(schemaPackagesByXsdPath).map((xsdPath) => {
@@ -150,7 +155,8 @@ export default async function createSchemaPackages(
 				path.resolve(outputPath),
 				schemaPackagesByXsdPath,
 				compiledSchemaResultsByXsdPath,
-				xsdPath
+				xsdPath,
+				useTypeScript
 			);
 		})
 	);

package/src/modules/editor-pre-7-7-0/src/command.init.controller.js

@@ -49,6 +49,8 @@ export default async function editorInitCommand(req, res) {
 		);
 	}
 
+	const useTypeScript = !req.options['output-javascript'];
+
 	// Check if the required fonto.json path has been specified when running non-interactive.
 	if (req.options['non-interactive'] && !req.options['schema']) {
 		throw new res.InputError('Missing schema value.');
@@ -274,15 +276,12 @@ export default async function editorInitCommand(req, res) {
 		return;
 	}
 
-	// @TODO: @TS: Remove file extensions from imports in template files when
-	// supporting TS configuration.
-
 	// Copy the Fonto Editor instance template.
 	destroySpinner = res.spinner('Setting up a new Fonto Editor instance...');
 	const templateDirectoryPath = path.join(
 		__dirname,
 		'..',
-		'instanceTemplate'
+		useTypeScript ? 'instanceTemplateTypeScript' : 'instanceTemplate'
 	);
 	try {
 		await fs.copy(templateDirectoryPath, editorPath, {
@@ -308,7 +307,8 @@ export default async function editorInitCommand(req, res) {
 		await createSchemaPackages(
 			editorPath,
 			fontoJson.rootSchemas,
-			schemaCompileResults
+			schemaCompileResults,
+			useTypeScript
 		);
 	} catch (error) {
 		throw new res.ErrorWithInnerError(
@@ -346,7 +346,9 @@ export default async function editorInitCommand(req, res) {
 			fontoJson.rootSchemas,
 			schemaCompileResults,
 			prefixByNamespaceUri,
-			addons
+			addons,
+			sdkVersion,
+			useTypeScript
 		);
 	} catch (error) {
 		throw new res.ErrorWithInnerError(
@@ -379,37 +381,40 @@ export default async function editorInitCommand(req, res) {
 		destroySpinner();
 	}
 
-	// Creating config/configuration.js.
+	// Creating config/configuration.ts/js.
 	destroySpinner = res.spinner('Creating the config configuration file...');
 	const configConfigurationPath = path.join(
 		editorPath,
 		'config',
-		'configuration.js'
+		`configuration${useTypeScript ? '.ts' : '.js'}`
 	);
 	try {
 		await createConfigConfiguration(
 			configConfigurationPath,
 			prefixByNamespaceUri,
 			addons,
-			schemaCompileResults
+			schemaCompileResults,
+			sdkVersion
 		);
 	} catch (error) {
 		throw new res.ErrorWithInnerError(
-			'Could not create the config/configuration.js file.',
+			`Could not create the config/configuration${
+				useTypeScript ? '.ts' : '.js'
+			} file.`,
 			error
 		);
 	} finally {
 		destroySpinner();
 	}
 
-	// Creating config/schemaExperienceResolver.js.
+	// Creating config/schemaExperienceResolver.ts/js.
 	destroySpinner = res.spinner(
 		'Creating the config schema experience resolver file...'
 	);
 	const schemaExperienceResolverPath = path.join(
 		editorPath,
 		'config',
-		'schemaExperienceResolver.js'
+		`schemaExperienceResolver${useTypeScript ? '.ts' : '.js'}`
 	);
 	try {
 		await createSchemaExperienceResolver(
@@ -418,7 +423,9 @@ export default async function editorInitCommand(req, res) {
 		);
 	} catch (error) {
 		throw new res.ErrorWithInnerError(
-			'Could not create the config/schemaExperienceResolver.js file.',
+			`Could not create the config/schemaExperienceResolver${
+				useTypeScript ? '.ts' : '.js'
+			} file.`,
 			error
 		);
 	} finally {

package/src/modules/editor-pre-7-7-0/src/command.init.js

@@ -56,6 +56,12 @@ export default (moduleRegistration, editorCommand) => {
 			'Specify the schema compiler backend base url.'
 		)
 
+		.addHiddenOption(
+			'output-javascript',
+			undefined,
+			'Generate JavaScript instead of TypeScript.'
+		)
+
 		.addOption(
 			'version',
 			undefined,

package/src/modules/editor-pre-7-7-0/src/command.upgrade.controller.js

@@ -1,6 +1,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import unzipper from 'unzipper';
+import { fileURLToPath } from 'url';
 
 import { isPre770Editor } from '../../../editorVersions.js';
 import convertEditorWithOutput from '../../editor/src/commands/api/convertEditorWithOutput.js';
@@ -18,6 +19,9 @@ import updateConfigFontoManifest from './api/upgrade/updateConfigFontoManifest.j
 import validateAddons from './api/validateAddons.js';
 import validateManifest from './api/validateManifest.js';
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 export default async function editorUpgradeCommand(req, res) {
 	if (req.options['remove-backup']) {
 		// DEV-9386
@@ -308,6 +312,27 @@ export default async function editorUpgradeCommand(req, res) {
 		);
 	}
 
+	// Set up code intelligence if there's a base tsconfig.json and it hasn't
+	// been set up yet.
+	const platformHasTsConfig = await fs.pathExists(
+		path.join(editorPath, 'platform', 'tsconfig.json')
+	);
+	if (platformHasTsConfig) {
+		await fs.copy(
+			path.resolve(
+				__dirname,
+				'..',
+				'instanceTemplateTypeScript',
+				'tsconfig.json'
+			),
+			path.resolve(editorPath, 'tsconfig.json'),
+			{
+				// Silently fail when target already exists.
+				overwrite: false,
+			}
+		);
+	}
+
 	await req.fdt.license.sendTelemetry({
 		product: req.command.parent.name,
 		type: 'selfContained',