refactor: use LibraryAnalysis to persist to disk (#799)

packages/analyzer-cli/package.json

@@ -27,7 +27,6 @@
   },
   "dependencies": {
     "@meetalva/analyzer": "1.0.0",
-    "@meetalva/model": "1.0.0",
     "@meetalva/types": "1.0.0",
     "@types/node": "^10.12.18",
     "yargs-parser": "10.1.0"

packages/analyzer-cli/src/bin/analyze.ts

@@ -41,27 +41,30 @@ async function main() {
 		return;
 	}
 
-	const project = Model.Project.create({ name: 'Project', draft: true, path: 'project' });
-	const library = Model.PatternLibrary.fromAnalysis(analysis.result, {
-		project,
-		analyzeBuiltins,
-		installType: Types.PatternLibraryInstallType.Local
-	});
+	const output = formatData(analysis.result, format);
 
 	if (toFile) {
-		await writeFile(outPath, formatLibrary(library, format));
+		await writeFile(outPath, output);
 	} else {
-		write(formatLibrary(library, format));
+		write(output);
 	}
 }
 
-function formatLibrary(library: Model.PatternLibrary, format: string): string {
+function formatData(input: Types.LibraryAnalysis, format: string): string {
 	switch (format) {
 		case 'json':
-			return JSON.stringify(library.toJSON(), null, '  ');
+			return JSON.stringify(input, null, '  ');
 		case 'js':
+			return `export const analysis = ${JSON.stringify(input, null, '  ')}`;
 		case 'ts':
-			return `export const analysis = ${JSON.stringify(library.toJSON(), null, '  ')}`;
+			return [
+				'import {LibraryAnalysis} from "@meetalva/types";',
+				`export const analysis: LibraryAnalysis = ${JSON.stringify(
+					input,
+					null,
+					'  '
+				)} as unknown as LibraryAnalysis`
+			].join('\n');
 		default:
 			throw new Error(`Unknown format: ${format}`);
 	}

packages/model/src/pattern-library/builtin-pattern-library.ts

@@ -1,7 +1,21 @@
-import { analysis } from '@meetalva/essentials';
-import { PatternLibrary } from './pattern-library';
+import * as Essentials from '@meetalva/essentials';
 import * as Types from '@meetalva/types';
+import { PatternLibrary } from './pattern-library';
+
+const data = Essentials.analysis as any;
+
+export const builtinPatternLibrary = (() => {
+	// Legacy analysis persistence - Types.SerializedPatternLibrary
+	if (data.model === Types.ModelName.PatternLibrary) {
+		const serializedLibrary = data as Types.SerializedPatternLibrary;
+		return PatternLibrary.from(serializedLibrary);
+	}
+
+	// Current analysis persistence - Types.LibraryAnalysis
+	const analysis = data as Types.LibraryAnalysis;
 
-export const builtinPatternLibrary = PatternLibrary.from(
-	(analysis as unknown) as Types.SerializedPatternLibrary
-);
+	return PatternLibrary.fromAnalysis(analysis, {
+		analyzeBuiltins: true,
+		installType: Types.PatternLibraryInstallType.Local
+	});
+})();

packages/model/src/pattern-library/pattern-library.ts

@@ -139,7 +139,7 @@ export class PatternLibrary {
 		analysis: Types.LibraryAnalysis,
 		opts: {
 			analyzeBuiltins: boolean;
-			project: Project;
+			project?: Project;
 			installType: Types.PatternLibraryInstallType;
 		}
 	): PatternLibrary {
@@ -196,7 +196,7 @@ export class PatternLibrary {
 	}
 
 	@Mobx.action
-	public import(analysis: Types.LibraryAnalysis, { project }: { project: Project }): void {
+	public import(analysis: Types.LibraryAnalysis, { project }: { project?: Project }): void {
 		this.packageFile = analysis.packageFile;
 
 		const patternsBefore = this.getPatterns();
@@ -256,29 +256,31 @@ export class PatternLibrary {
 
 		propChanges.changed.map(change => change.before.update(change.after));
 
-		const touchedPatterns = [...patternChanges.added, ...patternChanges.changed].map(
-			change => change.after
-		);
-
-		// TODO: This might be solved via a bigger refactoring that
-		// computes available element contents from pattern slots directly
-		touchedPatterns.forEach(pattern => {
-			project.getElementsByPattern(pattern).forEach(element => {
-				const contents = element.getContents();
-
-				pattern
-					.getSlots()
-					// Check if there is a corresponding element content for each pattern slot
-					.filter(slot => !contents.some(content => content.getSlotId() === slot.getId()))
-					.forEach(slot => {
-						// No element content, create a new one and add it to element
-						const content = ElementContent.fromSlot(slot, { project });
-						content.setParentElement(element);
-						element.addContent(content);
-						project.addElementContent(content);
-					});
+		if (project) {
+			const touchedPatterns = [...patternChanges.added, ...patternChanges.changed].map(
+				change => change.after
+			);
+
+			// TODO: This might be solved via a bigger refactoring that
+			// computes available element contents from pattern slots directly
+			touchedPatterns.forEach(pattern => {
+				project.getElementsByPattern(pattern).forEach(element => {
+					const contents = element.getContents();
+
+					pattern
+						.getSlots()
+						// Check if there is a corresponding element content for each pattern slot
+						.filter(slot => !contents.some(content => content.getSlotId() === slot.getId()))
+						.forEach(slot => {
+							// No element content, create a new one and add it to element
+							const content = ElementContent.fromSlot(slot, { project });
+							content.setParentElement(element);
+							element.addContent(content);
+							project.addElementContent(content);
+						});
+				});
 			});
-		});
+		}
 
 		this.setState(Types.PatternLibraryState.Connected);