@fontoxml/fontoxml-development-tools 3.10.0 → 3.12.0-beta.1

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

@@ -1,7 +1,10 @@
 import babel from '@babel/core';
 import os from 'os';
 
-import { isPre7170Editor } from '../../../../../editorVersions.js';
+import {
+	isPre810Editor,
+	isPre7170Editor,
+} from '../../../../../editorVersions.js';
 import SchemaSummary from '../../../../schema/src/api/SchemaSummary.js';
 import addCommentToAstNode, {
 	trickRecastIntoKeepingStatementsTogether,
@@ -49,7 +52,7 @@ const buildParagraphNodeNameForPastingConfiguration = template(
 // Configuration constants.
 const PARAGRAPH_COUTERPART_ELEMENT_NAME = 'p';
 
-export function buildConfigurationSetUniqueIdConfigurationStatement(version) {
+function buildConfigurationSetUniqueIdConfigurationStatement(version) {
 	return buildConfigurationSetUniqueIdConfigurations({
 		CONFIGURATION_VALUE: t.arrayExpression([
 			isPre7170Editor(version)
@@ -65,13 +68,15 @@ export function buildConfigurationSetUniqueIdConfigurationStatement(version) {
  * @param {Object}    compiledSchemaResultsByXsdPath The compiled schema for a package by xsd path.
  * @param {ASTNode[]} statements                     The statements node array to add the configuration and/or comments to.
  * @param {string}    version                        The sdk version used to configure.
+ * @param {ASTNode}   lastStatement                  The statement to add the comment to in case no new statement is created.
  *
- * @return {Promise}
+ * @return {Promise<void>}
  */
 async function addUniqueIdGenerationConfigurations(
 	compiledSchemaResultsByXsdPath,
 	statements,
-	version
+	version,
+	lastStatement
 ) {
 	// Check if an id attribute exists in one of the schemas.
 	const idAttributeExists = Object.values(
@@ -110,7 +115,7 @@ async function addUniqueIdGenerationConfigurations(
 			configurationSetUniqueIdConfigurationStatement
 		);
 		addCommentToAstNode(
-			statements[statements.length - 1],
+			lastStatement,
 			[
 				...comments,
 				'Example:',
@@ -123,18 +128,16 @@ async function addUniqueIdGenerationConfigurations(
 }
 
 /**
- * Creates the config/configuration.ts/js file for the Editor.
+ * Generates the config/configuration.ts/js file for the Editor.
  *
- * @param {string} configConfigurationJsFilePath  The path to the configuration file.
  * @param {Object} prefixByNamespaceUri           The namespace URIs with their prefix.
  * @param {Array}  addons                         The selected addons for this editor instance.
  * @param {Object} compiledSchemaResultsByXsdPath The compiled schema for a package by xsd path.
  * @param {string} version                        The sdk version used to configure.
  *
- * @return {Promise}
+ * @return {Promise<Program>}
  */
-export default async function createConfigConfiguration(
-	configConfigurationJsFilePath,
+export async function generateConfigConfiguration(
 	prefixByNamespaceUri,
 	addons,
 	compiledSchemaResultsByXsdPath,
@@ -160,16 +163,47 @@ export default async function createConfigConfiguration(
 	);
 	importStatements.push(configurationManagerImportStatement);
 
-	// Enable the 'correct selection after enter' experiment.
-	const correctSelectionAfterEnterConfigurationStatement =
-		buildCorrectSelectionAfterEnterConfiguration();
-	addCommentToAstNode(correctSelectionAfterEnterConfigurationStatement, [
-		'Enable an experiment where, when pressing enter at the edges of elements, the cursor is prevented',
-		'from ending up in positions that are not reachable using the cursor keys.',
-		'For more information:',
-		'https://documentation.fontoxml.com/latest/enable-experiment-correct-selection-after-enter-8d2ce78e26b8',
-	]);
-	statements.push(correctSelectionAfterEnterConfigurationStatement);
+	// Get all prefix and namespace entries, sorted naturally by prefix.
+	const prefixByNamespaceUriEntries = Object.entries(
+		prefixByNamespaceUri
+	).sort(([_nsA, prefixA], [_nsB, prefixB]) =>
+		prefixA === prefixB
+			? 0
+			: prefixA === null
+			? 1
+			: prefixB === null
+			? -1
+			: prefixA.localeCompare(prefixB, undefined, {
+					numeric: true,
+					sensitivity: 'base',
+			  })
+	);
+	if (prefixByNamespaceUriEntries.length) {
+		const namespaceManagerImport = buildNamespaceManagerImport();
+		trickRecastIntoKeepingStatementsTogether(namespaceManagerImport);
+		importStatements.push(namespaceManagerImport);
+	}
+
+	// Import xq for editor versions 7.17 or higher.
+	if (!isPre7170Editor(version)) {
+		const xqImportStatement = buildXqImport();
+		trickRecastIntoKeepingStatementsTogether(xqImportStatement);
+		importStatements.push(xqImportStatement);
+	}
+
+	// Set an experimental flag for editor versions 8.0.x or lower.
+	if (isPre810Editor(version)) {
+		const correctSelectionAfterEnterConfigurationStatement =
+			buildCorrectSelectionAfterEnterConfiguration();
+		// Enable the 'correct selection after enter' experiment.
+		addCommentToAstNode(correctSelectionAfterEnterConfigurationStatement, [
+			'Enable an experiment where, when pressing enter at the edges of elements, the cursor is prevented',
+			'from ending up in positions that are not reachable using the cursor keys.',
+			'For more information:',
+			'https://documentation.fontoxml.com/latest/enable-experiment-correct-selection-after-enter-8d2ce78e26b8',
+		]);
+		statements.push(correctSelectionAfterEnterConfigurationStatement);
+	}
 
 	// Configures the clipboard configuration option 'paragraph-node-name-for-pasting'.
 	// Skips this configuration when the 'fontoxml-dita' add-on is enabled, since that add-on already configures this option.
@@ -219,7 +253,8 @@ export default async function createConfigConfiguration(
 			comments.push('Example:');
 			comments.push(...exampleCode.split(os.EOL).filter(Boolean));
 			addCommentToAstNode(
-				correctSelectionAfterEnterConfigurationStatement,
+				statements[statements.length - 1] ||
+					importStatements[importStatements.length - 1],
 				comments,
 				true,
 				true
@@ -231,28 +266,13 @@ export default async function createConfigConfiguration(
 	await addUniqueIdGenerationConfigurations(
 		compiledSchemaResultsByXsdPath,
 		statements,
-		version
-	);
-
-	// Get all prefix and namespace entries, sorted naturally by prefix.
-	const prefixByNamespaceUriEntries = Object.entries(
-		prefixByNamespaceUri
-	).sort(([_nsA, prefixA], [_nsB, prefixB]) =>
-		prefixA === prefixB
-			? 0
-			: prefixA === null
-			? 1
-			: prefixB === null
-			? -1
-			: prefixA.localeCompare(prefixB, undefined, {
-					numeric: true,
-					sensitivity: 'base',
-			  })
+		version,
+		statements[statements.length - 1] ||
+			importStatements[importStatements.length - 1]
 	);
 
 	// Register all namespaces.
 	if (prefixByNamespaceUriEntries.length) {
-		importStatements.push(buildNamespaceManagerImport());
 		let isFirstAddedNamespaceStatement = true;
 		for (const [namespaceUri, prefix] of prefixByNamespaceUriEntries) {
 			const namespaceConfigurationStatement =
@@ -281,16 +301,34 @@ export default async function createConfigConfiguration(
 		}
 	}
 
-	// Import xq for editor versions 7.17 or higher.
-	if (!isPre7170Editor(version)) {
-		importStatements.push(buildXqImport());
-	}
-
 	// Generate the AST for the config/configuration.ts/js file.
-	const configConfigurationJsAst = t.program([
-		...importStatements,
-		...statements,
-	]);
+	return t.program([...importStatements, ...statements]);
+}
+
+/**
+ * Creates the config/configuration.ts/js file for the Editor.
+ *
+ * @param {string} configConfigurationJsFilePath  The path to the configuration file.
+ * @param {Object} prefixByNamespaceUri           The namespace URIs with their prefix.
+ * @param {Array}  addons                         The selected addons for this editor instance.
+ * @param {Object} compiledSchemaResultsByXsdPath The compiled schema for a package by xsd path.
+ * @param {string} version                        The sdk version used to configure.
+ *
+ * @return {Promise}
+ */
+export default async function createConfigConfiguration(
+	configConfigurationJsFilePath,
+	prefixByNamespaceUri,
+	addons,
+	compiledSchemaResultsByXsdPath,
+	version
+) {
+	const configConfigurationJsAst = await generateConfigConfiguration(
+		prefixByNamespaceUri,
+		addons,
+		compiledSchemaResultsByXsdPath,
+		version
+	);
 	await writeAstProgramToFile(
 		configConfigurationJsFilePath,
 		configConfigurationJsAst

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

@@ -1,5 +1,4 @@
-import requestPromise from 'request-promise-native';
-import url from 'url';
+import fetch, { File, FormData } from 'node-fetch';
 
 /**
  * Compile a schema zip archive using the schema compile service.
@@ -12,34 +11,29 @@ import url from 'url';
 export default async (baseUrl, compressedSchema) => {
 	let response;
 	try {
-		response = await requestPromise.post(
-			url.resolve(baseUrl, '/api/compile'),
-			{
-				formData: {
-					data: {
-						options: {
-							contentType: 'application/zip',
-							filename: 'schema.zip',
-						},
-						value: compressedSchema,
-					},
-				},
-				resolveWithFullResponse: true,
-				simple: false,
-			}
+		const form = new FormData();
+		form.set(
+			'schema',
+			new File([compressedSchema], 'schema.zip', {
+				type: 'application/zip',
+			}),
+			'schema.zip'
 		);
+
+		const compileUrl = new URL('/api/compile', baseUrl);
+		response = await fetch(compileUrl.href, { method: 'POST', body: form });
 	} catch (_error) {
 		throw new Error('Could not connect to the schema compile service.');
 	}
 
-	switch (response.statusCode) {
+	switch (response.status) {
 		case 200:
 		case 400:
 			try {
-				return JSON.parse(response.body);
-			} catch (_error) {
+				return await response.json();
+			} catch (_err) {
 				throw new Error(
-					'Invalid response data from the schema compile service.'
+					`Invalid response data from the schema compile service.`
 				);
 			}
 		case 401:
@@ -49,7 +43,7 @@ export default async (baseUrl, compressedSchema) => {
 			);
 		default:
 			throw new Error(
-				`Invalid response from the schema compile service (${response.statusCode}).`
+				`Invalid response from the schema compile service (${response.status}).`
 			);
 	}
 };

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

@@ -90,6 +90,14 @@ async function createPackageSchemaLocationsJsFile(
 	]);
 
 	await writeAstProgramToFile(schemaLocationsFilePath, schemaLocationsJsAst);
+
+	await fs.remove(
+		path.join(
+			packageDirectoryPath,
+			'src',
+			useTypeScript ? 'SCHEMA_LOCATIONS.js' : 'SCHEMA_LOCATIONS.ts'
+		)
+	);
 }
 
 /**

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

@@ -2,6 +2,80 @@ import fs from 'fs-extra';
 import os from 'os';
 import path from 'path';
 
+/**
+ * Validate the schema fonto.json file contents.
+ *
+ * @param {string} fontoJson The schema fonto.json contents.
+ *
+ * @throws If the schema fonto Json is invalid.
+ */
+export function validateSchemaFontoJson(fontoJson) {
+	if (!fontoJson.rootSchemas) {
+		throw new Error('Missing "rootSchemas" property in fonto.json.');
+	}
+
+	if (
+		typeof fontoJson.rootSchemas !== 'object' ||
+		Array.isArray(fontoJson.rootSchemas)
+	) {
+		throw new Error(
+			'The "rootSchemas" property is not an object in fonto.json.'
+		);
+	}
+
+	const xsdPaths = Object.keys(fontoJson.rootSchemas);
+	const requireLocations = xsdPaths.length > 1;
+	xsdPaths.forEach((xsdPath) => {
+		const schemaPackage = fontoJson.rootSchemas[xsdPath];
+
+		if (typeof schemaPackage !== 'object' || Array.isArray(schemaPackage)) {
+			throw new Error(
+				`Root schema "${xsdPath}" is not an object in fonto.json.`
+			);
+		}
+
+		if (!schemaPackage.packageName) {
+			throw new Error(
+				`Root schema "${xsdPath}" does not have a valid "packageName" property in fonto.json.`
+			);
+		}
+
+		// If there are multiple root schemas, the location property is required.
+		if (
+			requireLocations &&
+			(!schemaPackage.locations || !schemaPackage.locations.length)
+		) {
+			const error = new Error(
+				!schemaPackage.locations
+					? `Root schema "${xsdPath}" is missing the "locations" property, which is required when having multipe root schemas in fonto.json.`
+					: `Root schema "${xsdPath}" has an empty "locations" property, which is not allowed when having multipe root schemas in fonto.json.`
+			);
+
+			const solution = [
+				'Make sure to set locations for each schema in fonto.json when having multipe root schemas.',
+				'See: https://documentation.fontoxml.com/latest/schema-experiences-7d818ffb9db5',
+			];
+
+			error.solution = solution.join(os.EOL);
+			throw error;
+		}
+
+		// Validate the locations property, if there is any.
+		if (
+			schemaPackage.locations &&
+			(!Array.isArray(schemaPackage.locations) ||
+				schemaPackage.locations.some(
+					(schemaLocation) =>
+						typeof schemaLocation !== 'string' || !schemaLocation
+				))
+		) {
+			throw new Error(
+				`Root schema "${xsdPath}" has an invalid "locations" property in fonto.json.`
+			);
+		}
+	});
+}
+
 /**
  * Get the schema fonto.json file contents.
  *
@@ -10,7 +84,7 @@ import path from 'path';
  * @return {Promise<Object>} Returns the contents of fonto.json.
  *
  * @async
- * @throws If the required directory or files do not exist.
+ * @throws If the required directory or files do not exist or the schema fonto json is invalid.
  */
 export default async function getSchemaFontoJson(inputPath) {
 	if (!inputPath) {
@@ -38,53 +112,7 @@ export default async function getSchemaFontoJson(inputPath) {
 		throw new Error('The required fonto.json could not be parsed.');
 	}
 
-	if (!fontoJson.rootSchemas) {
-		throw new Error('Missing rootSchemas property in fonto.json.');
-	}
-
-	const xsdPaths = Object.keys(fontoJson.rootSchemas);
-	xsdPaths.forEach((xsdPath) => {
-		const schemaPackage = fontoJson.rootSchemas[xsdPath];
-		if (!schemaPackage.packageName) {
-			throw new Error(
-				`Root schema "${xsdPath}" has no package name in fonto.json.`
-			);
-		}
-
-		if (
-			schemaPackage.locations &&
-			(!Array.isArray(schemaPackage.locations) ||
-				schemaPackage.locations.some(
-					(schemaLocation) => typeof schemaLocation !== 'string'
-				))
-		) {
-			throw new Error(
-				`Root schema "${xsdPath}" has invalid locations in fonto.json.`
-			);
-		}
-
-		// In case of referencing multiple schemas, verify that each has valid locations.
-		if (
-			xsdPaths.length > 1 &&
-			(!schemaPackage.locations ||
-				!schemaPackage.locations.length ||
-				schemaPackage.locations.some(
-					(schemaLocation) => !schemaLocation
-				))
-		) {
-			const error = new Error(
-				'One or more schemas in fonto.json do not have valid locations associated.'
-			);
-
-			const solution = [
-				'Make sure to set locations for each schema in fonto.json.',
-				'See: https://documentation.fontoxml.com/latest/schema-experiences-7d818ffb9db5',
-			];
-
-			error.solution = solution.join(os.EOL);
-			throw error;
-		}
-	});
+	validateSchemaFontoJson(fontoJson);
 
 	return fontoJson;
 }

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

@@ -31,7 +31,12 @@ function zipSchemaSource(inputPath) {
 			resolve(Buffer.concat(buffers));
 		});
 
-		zipArchive.glob('**/*', {
+		// Use .glob here, instead of .file, to properly handle symlinked fonto.json files
+		zipArchive.glob('fonto.json', {
+			cwd: inputPath,
+			follow: true,
+		});
+		zipArchive.glob('**/*.@(xml|xsd)', {
 			cwd: inputPath,
 			follow: true,
 		});

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

@@ -1,3 +1,4 @@
+import fs from 'fs-extra';
 import inquirer from 'inquirer';
 import path from 'path';
 
@@ -11,6 +12,29 @@ import schemaZipHelpers from './api/schema/zipHelpers.js';
 const SCHEMA_COMPILE_DOCUMENTATION_URL =
 	'https://documentation.fontoxml.com/latest/create-a-schema-bundle-d186eeb79200';
 
+/**
+ * Helper function to test whether to use TypeScript conditionally.
+ *
+ * @param {boolean} isEditorRepositoryPath    Whether the command is run from an editor repo
+ * @param {boolean} editorSupportsTypeScript  Whether the editor platform directory contains tsconfig.json
+ * @param {boolean} hasSchemaLocationsJs      Whether there are existing SCHEMA_LOCATIONS.js files
+ * @param {boolean} hasSchemaLocationsTs      Whether there are existing SCHEMA_LOCATIONS.ts files
+ *
+ * @return {boolean}
+ */
+export function shouldUseTypeScriptForSchemaPackages(
+	isEditorRepositoryPath,
+	editorSupportsTypeScript,
+	hasSchemaLocationsJs,
+	hasSchemaLocationsTs
+) {
+	// If editor supports TS or if not running in editor, default to TS unless there are existing JS files and no existing TS files
+	// If editor does not support TS, default to JS
+	return editorSupportsTypeScript || !isEditorRepositoryPath
+		? !(hasSchemaLocationsJs && !hasSchemaLocationsTs)
+		: false;
+}
+
 export default async function schemaCompileCommand(req, res) {
 	res.caption(req.command.getLongName());
 
@@ -96,7 +120,7 @@ export default async function schemaCompileCommand(req, res) {
 			res.list(schemaCompileResult.error.details, '-');
 		}
 		res.outdent();
-		throw new Error('The schema(s) failed to compiled.');
+		throw new Error('The schema(s) failed to compile.');
 	}
 
 	// Output schema warnings.
@@ -122,7 +146,20 @@ export default async function schemaCompileCommand(req, res) {
 			fontoJson.rootSchemas,
 			false
 		);
+
+	let hasSchemaLocationsJs = false;
+	let hasSchemaLocationsTs = false;
+
 	if (schemaPackagesWithExistingFiles.length) {
+		for (const file of schemaPackagesWithExistingFiles) {
+			if (path.basename(file) === 'SCHEMA_LOCATIONS.js') {
+				hasSchemaLocationsJs = true;
+			}
+			if (path.basename(file) === 'SCHEMA_LOCATIONS.ts') {
+				hasSchemaLocationsTs = true;
+			}
+		}
+
 		res.caption('Existing files to be overwritten');
 		res.log(
 			`In${isEditorRepositoryPath ? ' editor' : ''} path "${outputPath}".`
@@ -161,6 +198,17 @@ export default async function schemaCompileCommand(req, res) {
 		}
 	}
 
+	const hasTsConfig = await fs.pathExists(
+		path.join(outputPath, 'platform', 'tsconfig.json')
+	);
+	const platformHasTsConfig = isEditorRepositoryPath && hasTsConfig;
+	const useTypeScript = shouldUseTypeScriptForSchemaPackages(
+		isEditorRepositoryPath,
+		platformHasTsConfig,
+		hasSchemaLocationsJs,
+		hasSchemaLocationsTs
+	);
+
 	// Create schema packages.
 	destroySpinner = res.spinner(
 		'Creating package(s) for the compiled schema(s)...'
@@ -169,7 +217,8 @@ export default async function schemaCompileCommand(req, res) {
 		await createSchemaPackages(
 			outputPath,
 			fontoJson.rootSchemas,
-			schemaCompileResult
+			schemaCompileResult,
+			useTypeScript
 		);
 	} catch (error) {
 		throw new res.ErrorWithInnerError(

package/src/modules/editor-pre-7-7-0/test/api/init/createConfigConfiguration.test.js

@@ -1,47 +1,85 @@
-import babel from '@babel/core';
 import assert from 'assert';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
 
 import createPrettifiedCode from '../../../src/api/createPrettifiedCode.js';
-import { buildConfigurationSetUniqueIdConfigurationStatement } from '../../../src/api/init/createConfigConfiguration.js';
+import { generateConfigConfiguration } from '../../../src/api/init/createConfigConfiguration.js';
+import getPrefixByNamespaceUri from '../../../src/api/schema/getPrefixByNamespaceUri.js';
 
-const t = babel.types;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 describe('createConfigConfiguration', () => {
-	it('works for pre 7.17 versions', async () => {
-		const configStatement =
-			buildConfigurationSetUniqueIdConfigurationStatement('7.16');
-		const program = t.program([configStatement]);
+	it('works for versions pre 7.17.x', async () => {
+		// < 7.17.x (+experiment, -xq, -dita, -p, -namespaces, -id)
+		const abstractSchema = await fs.readJSON(
+			path.resolve(
+				__dirname,
+				'../schema/fixtures/abstract-test/compiledSchema.json'
+			)
+		);
+		const program = await generateConfigConfiguration(
+			getPrefixByNamespaceUri(abstractSchema),
+			[],
+			abstractSchema,
+			'7.16.0'
+		);
+		const stringOutcome = await createPrettifiedCode(program);
+
+		const fixture = await fs.readFile(
+			path.join(__dirname, 'fixtures/configjs-7160.js'),
+			'utf8'
+		);
+
+		assert.strictEqual(stringOutcome, fixture);
+	});
+
+	it('works for versions 8.0.0 to 8.1.0', async () => {
+		// 8.0.0 - 8.1.0 (+experiment, +xq, -dita, +p, ?namespaces, ?id)
+		const abstractSchema = await fs.readJSON(
+			path.resolve(
+				__dirname,
+				'../schema/fixtures/training-schema-bundle/compiledSchema.json'
+			)
+		);
+		const program = await generateConfigConfiguration(
+			getPrefixByNamespaceUri(abstractSchema),
+			[],
+			abstractSchema,
+			'8.0.0'
+		);
 		const stringOutcome = await createPrettifiedCode(program);
-		assert.strictEqual(
-			stringOutcome,
-			`configurationManager.set('unique-id-configurations', [
-	{
-		selector: 'self::*',
-		namespaceURI: null,
-		localName: 'id',
-		strategy: 'unique-for-document',
-	},
-]);
-`
+
+		const fixture = await fs.readFile(
+			path.join(__dirname, 'fixtures/configjs-800.js'),
+			'utf8'
 		);
+
+		assert.strictEqual(stringOutcome, fixture);
 	});
 
-	it('works for 7.17 and up', async () => {
-		const configStatement =
-			buildConfigurationSetUniqueIdConfigurationStatement('7.17');
-		const program = t.program([configStatement]);
+	it('works for versions 8.1.x and up', async () => {
+		// > 8.1.x (-experiment, +xq, +dita, -p, +namespaces, +id)
+		const abstractSchema = await fs.readJSON(
+			path.resolve(
+				__dirname,
+				'../schema/fixtures/dita-example-schema-bundle/compiledSchema.json'
+			)
+		);
+		const program = await generateConfigConfiguration(
+			getPrefixByNamespaceUri(abstractSchema),
+			['fontoxml-dita'],
+			abstractSchema,
+			'8.1.0'
+		);
 		const stringOutcome = await createPrettifiedCode(program);
-		assert.strictEqual(
-			stringOutcome,
-			`configurationManager.set('unique-id-configurations', [
-	{
-		selector: xq\`self::*\`,
-		namespaceURI: null,
-		localName: 'id',
-		strategy: 'unique-for-document',
-	},
-]);
-`
+
+		const fixture = await fs.readFile(
+			path.join(__dirname, 'fixtures/configjs-810.js'),
+			'utf8'
 		);
+
+		assert.strictEqual(stringOutcome, fixture);
 	});
 });