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

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/schema/buildSchemaExperienceConfigurationModel.test.js

@@ -505,93 +505,84 @@ describe('api/schema/buildSchemaExperienceConfigurationModel', () => {
 			throw new Error('No fixtures found.');
 		}
 
-		const fixturesBlacklist = [];
+		const fixturesBlacklist = ['invalid-fonto-json'];
 		fixtures.forEach((fixture) => {
-			const testFunction = fixturesBlacklist.includes(fixture)
-				? it.skip
-				: it;
-
-			testFunction(
-				`can build model for fixture "${fixture}"`,
-				async function () {
-					this.slow(500);
-
-					const fixturePath = path.join(fixturesPath, fixture);
-					const compiledSchemaFilePath = path.join(
-						fixturePath,
-						'compiledSchema.json'
-					);
-					const fontoJsonFilePath = path.join(
-						fixturePath,
-						'fonto.json'
-					);
+			if (fixturesBlacklist.includes(fixture)) {
+				return;
+			}
 
-					// Recompile the schema using the schema compiler when updating snapshots and the compiled schema does NOT exist.
-					if (
-						UPDATE_SNAPSHOTS &&
-						!(await fs
-							.access(compiledSchemaFilePath)
-							.then(() => true)
-							.catch(() => false))
-					) {
-						this.timeout(120000);
-						this.slow(60000);
-						console.warn(
-							mochaColoring(
-								'error stack',
-								`      - Compiling schema for fixture "${fixture}"...`
-							)
-						);
-						const schemaCompileResults = await compileSchema(
-							fixturePath
-						);
-						await fs.writeJson(
-							compiledSchemaFilePath,
-							schemaCompileResults
-						);
-					}
+			it(`can build model for fixture "${fixture}"`, async function () {
+				this.slow(500);
 
-					// Build the schema model.
-					const fontoJson = await fs.readJson(fontoJsonFilePath);
-					const schemaPackagesByXsdPath = fontoJson.rootSchemas;
-					const compiledSchemaResultsByXsdPath = await fs.readJson(
-						compiledSchemaFilePath
-					);
-					const prefixByNamespaceUri = getprefixByNamespaceUri(
-						compiledSchemaResultsByXsdPath
-					);
-					const result = buildSchemaExperienceConfigurationModel(
-						schemaPackagesByXsdPath,
-						compiledSchemaResultsByXsdPath,
-						prefixByNamespaceUri
-					);
+				const fixturePath = path.join(fixturesPath, fixture);
+				const compiledSchemaFilePath = path.join(
+					fixturePath,
+					'compiledSchema.json'
+				);
+				const fontoJsonFilePath = path.join(fixturePath, 'fonto.json');
 
-					// Sanity check.
-					sanityCheckResult(
-						result,
-						schemaPackagesByXsdPath,
-						compiledSchemaResultsByXsdPath
+				// Recompile the schema using the schema compiler when updating snapshots and the compiled schema does NOT exist.
+				if (
+					UPDATE_SNAPSHOTS &&
+					!(await fs
+						.access(compiledSchemaFilePath)
+						.then(() => true)
+						.catch(() => false))
+				) {
+					this.timeout(120000);
+					this.slow(60000);
+					console.warn(
+						mochaColoring(
+							'error stack',
+							`      - Compiling schema for fixture "${fixture}"...`
+						)
 					);
-
-					// Assert against snapshot, and optionally update the snapshot.
-					const serializedResult = JSON.stringify(
-						result,
-						(_key, value) => {
-							return value instanceof Map
-								? Array.from(value.entries())
-								: value instanceof Set
-								? Array.from(value)
-								: value;
-						},
-						'\t'
+					const schemaCompileResults = await compileSchema(
+						fixturePath
 					);
-					const snapshotPath = path.join(
-						fixturePath,
-						'model.out.json'
+					await fs.writeJson(
+						compiledSchemaFilePath,
+						schemaCompileResults
 					);
-					await assertFixtureSnapshot(serializedResult, snapshotPath);
 				}
-			);
+
+				// Build the schema model.
+				const fontoJson = await fs.readJson(fontoJsonFilePath);
+				const schemaPackagesByXsdPath = fontoJson.rootSchemas;
+				const compiledSchemaResultsByXsdPath = await fs.readJson(
+					compiledSchemaFilePath
+				);
+				const prefixByNamespaceUri = getprefixByNamespaceUri(
+					compiledSchemaResultsByXsdPath
+				);
+				const result = buildSchemaExperienceConfigurationModel(
+					schemaPackagesByXsdPath,
+					compiledSchemaResultsByXsdPath,
+					prefixByNamespaceUri
+				);
+
+				// Sanity check.
+				sanityCheckResult(
+					result,
+					schemaPackagesByXsdPath,
+					compiledSchemaResultsByXsdPath
+				);
+
+				// Assert against snapshot, and optionally update the snapshot.
+				const serializedResult = JSON.stringify(
+					result,
+					(_key, value) => {
+						return value instanceof Map
+							? Array.from(value.entries())
+							: value instanceof Set
+							? Array.from(value)
+							: value;
+					},
+					'\t'
+				);
+				const snapshotPath = path.join(fixturePath, 'model.out.json');
+				await assertFixtureSnapshot(serializedResult, snapshotPath);
+			});
 		});
 	});
 });

package/src/modules/editor-pre-7-7-0/test/api/schema/fixtures/invalid-fonto-json/fonto.json

@@ -0,0 +1 @@
+This is not a JSON file.

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

@@ -0,0 +1,174 @@
+import assert from 'assert';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import getSchemaFontoJson, {
+	validateSchemaFontoJson,
+} from '../../../src/api/schema/getSchemaFontoJson.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('api/schema/getSchemaFontoJson', () => {
+	it('can get a schema fonto.json', async () => {
+		const fixturePath = path.join(__dirname, 'fixtures', 'abstract-test');
+		const fontoJson = await getSchemaFontoJson(fixturePath);
+		assert.deepEqual(fontoJson, {
+			rootSchemas: {
+				'abstractTest.xsd': {
+					packageName: 'abstract-test-sx-shell',
+					locations: ['urn:fonto:abstract:test'],
+				},
+			},
+		});
+	});
+
+	it('throws when the directory does not exist', async () => {
+		const fixturePath = path.join(__dirname, 'fixtures', 'non-existing');
+		await getSchemaFontoJson(fixturePath)
+			.then(() => {
+				throw new Error('Should have thrown.');
+			})
+			.catch((error) => {
+				assert.ok(error);
+				assert.ok(
+					error.message.match(/Schema source path does not exist/)
+				);
+			});
+	});
+
+	it('throws when the fonto.json file does not exist', async () => {
+		const fixturePath = path.join(__dirname, 'fixtures');
+		await getSchemaFontoJson(fixturePath)
+			.then(() => {
+				throw new Error('Should have thrown.');
+			})
+			.catch((error) => {
+				assert.ok(error);
+				assert.ok(
+					error.message.match(/schema source path does not exist/)
+				);
+			});
+	});
+
+	it('throws when the fonto.json could not be parsed', async () => {
+		const fixturePath = path.join(
+			__dirname,
+			'fixtures',
+			'invalid-fonto-json'
+		);
+		await getSchemaFontoJson(fixturePath)
+			.then(() => {
+				throw new Error('Should have thrown.');
+			})
+			.catch((error) => {
+				assert.ok(error);
+				assert.ok(error.message.match(/could not be parsed/));
+			});
+	});
+
+	describe('validateSchemaFontoJson', () => {
+		it('throws when there is no rootSchemas property', () => {
+			assert.throws(() => {
+				validateSchemaFontoJson({});
+			}, /Missing "rootSchemas" property/);
+		});
+
+		it('throws when a rootSchemas property is not an object', () => {
+			assert.throws(() => {
+				validateSchemaFontoJson({ rootSchemas: [] });
+			}, /The "rootSchemas" property is not an object/);
+		});
+
+		it('throws when a root schema is not an object', () => {
+			assert.throws(() => {
+				validateSchemaFontoJson({ rootSchemas: { 'test.xsd': [] } });
+			}, /Root schema "test.xsd" is not an object/);
+		});
+
+		it('throws when a root schema is missing the packageName property', () => {
+			assert.throws(() => {
+				validateSchemaFontoJson({ rootSchemas: { 'test.xsd': {} } });
+			}, /Root schema "test.xsd" does not have a valid "packageName" property/);
+		});
+
+		it('throws when a root schema has an invalid location property', () => {
+			// Non array.
+			assert.throws(() => {
+				validateSchemaFontoJson({
+					rootSchemas: {
+						'test.xsd': {
+							packageName: 'test-package',
+							locations: {},
+						},
+					},
+				});
+			}, /Root schema "test.xsd" has an invalid "locations" property/);
+
+			// Non string value.
+			assert.throws(() => {
+				validateSchemaFontoJson({
+					rootSchemas: {
+						'test.xsd': {
+							packageName: 'test-package',
+							locations: [false],
+						},
+					},
+				});
+			}, /Root schema "test.xsd" has an invalid "locations" property/);
+
+			// Empty string value.
+			assert.throws(() => {
+				validateSchemaFontoJson({
+					rootSchemas: {
+						'test.xsd': {
+							packageName: 'test-package',
+							locations: [''],
+						},
+					},
+				});
+			}, /Root schema "test.xsd" has an invalid "locations" property/);
+		});
+
+		it('throws when there are multiple root schemas but one is missing the location property', () => {
+			// Missing locations property.
+			assert.throws(() => {
+				validateSchemaFontoJson({
+					rootSchemas: {
+						'test1.xsd': {
+							packageName: 'test-package',
+							locations: ['urn:test1'],
+						},
+						'test2.xsd': {
+							packageName: 'test-package',
+						},
+						'test3.xsd': {
+							packageName: 'test-package',
+							locations: ['urn:test1'],
+						},
+					},
+				});
+			}, /Root schema "test2.xsd" is missing the "locations" property/);
+
+			// Empty locations property.
+			assert.throws(() => {
+				validateSchemaFontoJson({
+					rootSchemas: {
+						'test1.xsd': {
+							packageName: 'test-package',
+							locations: ['urn:test1'],
+						},
+						'test2.xsd': {
+							packageName: 'test-package',
+							locations: [],
+						},
+						'test3.xsd': {
+							packageName: 'test-package',
+							locations: ['urn:test1'],
+						},
+					},
+				});
+			}, /Root schema "test2.xsd" has an empty "locations" property/);
+		});
+	});
+});

package/src/modules/editor-pre-7-7-0/test/schemaCompileController.test.js

@@ -0,0 +1,205 @@
+import assert from 'assert';
+
+import { shouldUseTypeScriptForSchemaPackages } from '../src/command.schema.compile.controller.js';
+
+describe('src/modules/editor-pre-7-7-0/src/command.schema.compile.controller.js', () => {
+	describe('shouldUseTypeScriptForSchemaPackages', () => {
+		describe('for editors that support TypeScript', () => {
+			it('uses TypeScript when there are no pre-existing SCHEMA_LOCATIONS file(s)', () => {
+				const isEditorRepositoryPath = true;
+				const editorSupportsTypeScript = true;
+				const hasSchemaLocationsJs = false;
+				const hasSchemaLocationsTs = false;
+
+				const result = shouldUseTypeScriptForSchemaPackages(
+					isEditorRepositoryPath,
+					editorSupportsTypeScript,
+					hasSchemaLocationsJs,
+					hasSchemaLocationsTs
+				);
+
+				assert.strictEqual(result, true);
+			});
+
+			it('uses TypeScript when there are both pre-existing SCHEMA_LOCATIONS.js and SCHEMA_LOCATIONS.ts file(s)', () => {
+				const isEditorRepositoryPath = true;
+				const editorSupportsTypeScript = true;
+				const hasSchemaLocationsJs = true;
+				const hasSchemaLocationsTs = true;
+
+				const result = shouldUseTypeScriptForSchemaPackages(
+					isEditorRepositoryPath,
+					editorSupportsTypeScript,
+					hasSchemaLocationsJs,
+					hasSchemaLocationsTs
+				);
+
+				assert.strictEqual(result, true);
+			});
+
+			it('does not use TypeScript when there are only pre-existing SCHEMA_LOCATIONS.js file(s)', () => {
+				const isEditorRepositoryPath = true;
+				const editorSupportsTypeScript = true;
+				const hasSchemaLocationsJs = true;
+				const hasSchemaLocationsTs = false;
+
+				const result = shouldUseTypeScriptForSchemaPackages(
+					isEditorRepositoryPath,
+					editorSupportsTypeScript,
+					hasSchemaLocationsJs,
+					hasSchemaLocationsTs
+				);
+
+				assert.strictEqual(result, false);
+			});
+
+			it('uses TypeScript when there are only pre-existing SCHEMA_LOCATIONS.ts file(s)', () => {
+				const isEditorRepositoryPath = true;
+				const editorSupportsTypeScript = true;
+				const hasSchemaLocationsJs = false;
+				const hasSchemaLocationsTs = true;
+
+				const result = shouldUseTypeScriptForSchemaPackages(
+					isEditorRepositoryPath,
+					editorSupportsTypeScript,
+					hasSchemaLocationsJs,
+					hasSchemaLocationsTs
+				);
+
+				assert.strictEqual(result, true);
+			});
+		});
+
+		describe('for editors that do not support TypeScript', () => {
+			it('does not use TypeScript when there are no pre-existing SCHEMA_LOCATIONS file(s)', () => {
+				const isEditorRepositoryPath = true;
+				const editorSupportsTypeScript = false;
+				const hasSchemaLocationsJs = false;
+				const hasSchemaLocationsTs = false;
+
+				const result = shouldUseTypeScriptForSchemaPackages(
+					isEditorRepositoryPath,
+					editorSupportsTypeScript,
+					hasSchemaLocationsJs,
+					hasSchemaLocationsTs
+				);
+
+				assert.strictEqual(result, false);
+			});
+
+			it('does not use TypeScript when there are both pre-existing SCHEMA_LOCATIONS.js and SCHEMA_LOCATIONS.ts file(s)', () => {
+				const isEditorRepositoryPath = true;
+				const editorSupportsTypeScript = false;
+				const hasSchemaLocationsJs = true;
+				const hasSchemaLocationsTs = true;
+
+				const result = shouldUseTypeScriptForSchemaPackages(
+					isEditorRepositoryPath,
+					editorSupportsTypeScript,
+					hasSchemaLocationsJs,
+					hasSchemaLocationsTs
+				);
+
+				assert.strictEqual(result, false);
+			});
+
+			it('does not use TypeScript when there are only pre-existing SCHEMA_LOCATIONS.js file(s)', () => {
+				const isEditorRepositoryPath = true;
+				const editorSupportsTypeScript = false;
+				const hasSchemaLocationsJs = true;
+				const hasSchemaLocationsTs = false;
+
+				const result = shouldUseTypeScriptForSchemaPackages(
+					isEditorRepositoryPath,
+					editorSupportsTypeScript,
+					hasSchemaLocationsJs,
+					hasSchemaLocationsTs
+				);
+
+				assert.strictEqual(result, false);
+			});
+
+			it('does not use TypeScript when there are only pre-existing SCHEMA_LOCATIONS.ts file(s)', () => {
+				const isEditorRepositoryPath = true;
+				const editorSupportsTypeScript = false;
+				const hasSchemaLocationsJs = false;
+				const hasSchemaLocationsTs = true;
+
+				const result = shouldUseTypeScriptForSchemaPackages(
+					isEditorRepositoryPath,
+					editorSupportsTypeScript,
+					hasSchemaLocationsJs,
+					hasSchemaLocationsTs
+				);
+
+				assert.strictEqual(result, false);
+			});
+		});
+
+		describe('when running outside of an editor or editor repo', () => {
+			it('uses TypeScript when there are no pre-existing SCHEMA_LOCATIONS file(s)', () => {
+				const isEditorRepositoryPath = false;
+				const editorSupportsTypeScript = false;
+				const hasSchemaLocationsJs = false;
+				const hasSchemaLocationsTs = false;
+
+				const result = shouldUseTypeScriptForSchemaPackages(
+					isEditorRepositoryPath,
+					editorSupportsTypeScript,
+					hasSchemaLocationsJs,
+					hasSchemaLocationsTs
+				);
+
+				assert.strictEqual(result, true);
+			});
+
+			it('uses TypeScript when there are both pre-existing SCHEMA_LOCATIONS.js and SCHEMA_LOCATIONS.ts file(s)', () => {
+				const isEditorRepositoryPath = false;
+				const editorSupportsTypeScript = false;
+				const hasSchemaLocationsJs = true;
+				const hasSchemaLocationsTs = true;
+
+				const result = shouldUseTypeScriptForSchemaPackages(
+					isEditorRepositoryPath,
+					editorSupportsTypeScript,
+					hasSchemaLocationsJs,
+					hasSchemaLocationsTs
+				);
+
+				assert.strictEqual(result, true);
+			});
+
+			it('does not use TypeScript when there are only pre-existing SCHEMA_LOCATIONS.js file(s)', () => {
+				const isEditorRepositoryPath = false;
+				const editorSupportsTypeScript = false;
+				const hasSchemaLocationsJs = true;
+				const hasSchemaLocationsTs = false;
+
+				const result = shouldUseTypeScriptForSchemaPackages(
+					isEditorRepositoryPath,
+					editorSupportsTypeScript,
+					hasSchemaLocationsJs,
+					hasSchemaLocationsTs
+				);
+
+				assert.strictEqual(result, false);
+			});
+
+			it('uses TypeScript when there are only pre-existing SCHEMA_LOCATIONS.ts file(s)', () => {
+				const isEditorRepositoryPath = false;
+				const editorSupportsTypeScript = false;
+				const hasSchemaLocationsJs = false;
+				const hasSchemaLocationsTs = true;
+
+				const result = shouldUseTypeScriptForSchemaPackages(
+					isEditorRepositoryPath,
+					editorSupportsTypeScript,
+					hasSchemaLocationsJs,
+					hasSchemaLocationsTs
+				);
+
+				assert.strictEqual(result, true);
+			});
+		});
+	});
+});

package/src/modules/localization/index.js

@@ -1,5 +1,5 @@
+import fastGlob from 'fast-glob';
 import fs from 'fs';
-import glob from 'globby';
 import path from 'path';
 
 import commandExtract from './src/command.extract.js';
@@ -14,7 +14,7 @@ export default (moduleRegistration) => {
 		let messageBundles;
 
 		if (req.fdt.editorRepository.path) {
-			messageBundles = glob.sync(
+			messageBundles = fastGlob.sync(
 				[
 					'packages/**/messages.*.json',
 					'packages-shared/**/messages.*.json',

package/src/modules/operations/src/api/getOperations.js

@@ -1,9 +1,9 @@
+import fastGlob from 'fast-glob';
 import fs from 'fs';
-import glob from 'globby';
 import path from 'path';
 
 export default function getOperations(workingDirectory, roots, ignoreSymlinks) {
-	return glob(
+	return fastGlob(
 		Array.isArray(roots)
 			? roots.map((root) => path.join(root, '**', 'operations?(-*).json'))
 			: [
@@ -14,7 +14,7 @@ export default function getOperations(workingDirectory, roots, ignoreSymlinks) {
 			  ],
 		{
 			cwd: workingDirectory,
-			follow: !ignoreSymlinks,
+			followSymbolicLinks: !ignoreSymlinks,
 		}
 	).then((operationsJsons) => {
 		return operationsJsons.reduce((allOps, operationsJson) => {