@microtronics/studio-cli 0.3.5 → 0.4.1

package/out/dde/dde.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DDE = exports.DDE_PATH = void 0;
+const vscode_uri_1 = require("vscode-uri");
+const FS_1 = require("../FS");
+const dependencies_1 = require("../dependencies");
+const manifest_1 = require("../manifest");
+const ajv_1 = __importDefault(require("ajv"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const dynamic_dde_schema_json_1 = __importDefault(require("./dynamic-dde.schema.json"));
+const yaml_1 = require("yaml");
+const yamlDdePreCompiler_1 = require("./yamlDdePreCompiler");
+const xml_1 = require("./fileGenerators/xml");
+const defaultFiles_1 = require("../defaultFiles");
+exports.DDE_PATH = defaultFiles_1.DefaultFiles.filePaths.dde.path;
+// create file cache.
+// yaml & json
+// ...
+var DDE;
+(function (DDE) {
+    /**
+     * The json schema to validate the dde structure
+     */
+    DDE.DDE_SCHEMA = dynamic_dde_schema_json_1.default;
+    async function readYamlFile(filePath, fs) {
+        const yamlBin = await fs.readFile(filePath);
+        return (0, FS_1.convertBlobToString)(yamlBin);
+    }
+    DDE.readYamlFile = readYamlFile;
+    /**
+     * Validate all dde files if they are valid based on the json schema
+     * @param cwd
+     * @param fs
+     * @param fileName
+     */
+    async function validate(cwd, fs, fileName = defaultFiles_1.DefaultFiles.fileNames.mainDDE) {
+        const manifest = await manifest_1.Manifest.read(cwd, fs);
+        const allLibraryFiles = await getDependencies(cwd, fs, manifest);
+        for (const libraryFile of allLibraryFiles) {
+            await validateJsonSchema(libraryFile.path, libraryFile.yaml);
+        }
+        // read project dde
+        const mainDdePath = vscode_uri_1.Utils.joinPath(cwd, exports.DDE_PATH, fileName);
+        const mainDdeYaml = await readYamlFile(mainDdePath, fs);
+        await validateJsonSchema(mainDdePath, mainDdeYaml);
+        return {
+            manifest,
+            libraryFiles: allLibraryFiles,
+            main: {
+                path: mainDdePath,
+                yaml: mainDdeYaml
+            }
+        };
+    }
+    DDE.validate = validate;
+    /**
+     * Run dde compiler in the given studio directory
+     * @param cwd
+     * @param fs
+     * @param fileName
+     */
+    async function compileDDE(cwd, fs, fileName = defaultFiles_1.DefaultFiles.fileNames.mainDDE) {
+        const validated = await validate(cwd, fs, fileName);
+        const historyJson = await getHistoryJson(cwd, fs);
+        const preCompiler = new yamlDdePreCompiler_1.YamlPreCompiler.PreCompiler(validated.manifest, validated.libraryFiles, historyJson);
+        const libraryDiagnostics = preCompiler.parseLibraries();
+        const librariesHaveError = libraryDiagnostics.find(diagnostics => diagnostics.level === 'error');
+        if (librariesHaveError) {
+            return { ddeJSON: null, diagnostics: libraryDiagnostics };
+        }
+        const { ddeJSON, diagnostics } = preCompiler.parseMainDDE(validated.main.path, validated.main.yaml);
+        return { ddeJSON, diagnostics };
+    }
+    DDE.compileDDE = compileDDE;
+    const ajv = new ajv_1.default({
+        strict: false,
+        allErrors: true,
+        verbose: true
+    });
+    // @ts-ignore
+    (0, ajv_formats_1.default)(ajv);
+    const validateDynamicDde = ajv.compile(DDE.DDE_SCHEMA);
+    /**
+     * Validate a given dde file against the dynamic dde schema
+     * @param ddeFilePath
+     * @param yaml
+     */
+    async function validateJsonSchema(ddeFilePath, yaml) {
+        const json = (0, yaml_1.parseDocument)(yaml).toJSON();
+        const result = validateDynamicDde(json);
+        if (!result) {
+            const errors = validateDynamicDde.errors || [];
+            const error = new Error(`${vscode_uri_1.Utils.basename(ddeFilePath)} has "${errors.length}" errors"`);
+            errors.forEach(error => console.error(error));
+            throw error;
+        }
+    }
+    DDE.validateJsonSchema = validateJsonSchema;
+    /**
+     * Creates and returns a new precompiler instance
+     * @param manifest
+     * @param libraries
+     * @param ddeHistory
+     * @constructor
+     */
+    DDE.PreCompiler = (manifest, libraries, ddeHistory) => {
+        return new yamlDdePreCompiler_1.YamlPreCompiler.PreCompiler(manifest, libraries, ddeHistory);
+    };
+    /**
+     * File Generators
+     */
+    /**
+     * Generate the needed xml for the myDatanet application
+     * @param ddeJSON
+     */
+    function generateMyDatanetXML(ddeJSON) {
+        return (0, xml_1.generateXMLFromMap)(ddeJSON);
+    }
+    DDE.generateMyDatanetXML = generateMyDatanetXML;
+    /**
+     * Generate the xml dde notation and write it to the correct dist directory
+     * @param cwd
+     * @param fs
+     * @param ddeJSON
+     */
+    async function exportMyDatanetXML(cwd, fs, ddeJSON) {
+        const xml = (0, xml_1.generateXMLFromMap)(ddeJSON);
+        const distFile = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dist.ddeXmlPath);
+        await fs.writeFile(distFile, xml);
+        console.log('Generated', defaultFiles_1.DefaultFiles.filePaths.dist.ddeXmlPath);
+    }
+    DDE.exportMyDatanetXML = exportMyDatanetXML;
+})(DDE || (exports.DDE = DDE = {}));
+async function getDependencies(cwd, fs, manifest) {
+    const ddeFiles = [];
+    const allDependencies = await dependencies_1.Dependencies.getAll(manifest);
+    for (const dependencyId in allDependencies) {
+        const depPath = dependencies_1.Dependencies.dependencyToPath(cwd, dependencyId);
+        const name = dependencies_1.Dependencies.dependencyIdToName(dependencyId);
+        const ddePath = vscode_uri_1.Utils.joinPath(depPath, `${exports.DDE_PATH}/${name}.dde`);
+        const hasDDE = await fs.stat(ddePath);
+        if (hasDDE) {
+            ddeFiles.push({
+                libraryName: name,
+                path: ddePath,
+                yaml: await DDE.readYamlFile(ddePath, fs)
+            });
+        }
+    }
+    // push library projects dde file also into the list
+    if (manifest_1.Manifest.isLibraryProject(manifest)) {
+        const projectLibPath = vscode_uri_1.Utils.joinPath(cwd, `/${exports.DDE_PATH}/${manifest.name}.dde`);
+        if (await fs.stat(projectLibPath)) {
+            ddeFiles.push({
+                libraryName: manifest.name,
+                path: projectLibPath,
+                yaml: await DDE.readYamlFile(projectLibPath, fs)
+            });
+        }
+    }
+    return ddeFiles;
+}
+async function getHistoryJson(cwd, fs) {
+    const historyPath = vscode_uri_1.Utils.joinPath(cwd, exports.DDE_PATH, 'history.json');
+    try {
+        const binary = await fs.readFile(historyPath);
+        const historyString = (0, FS_1.convertBlobToString)(binary);
+        return JSON.parse(historyString);
+    }
+    catch (e) {
+        console.warn('history.json does not exist');
+        return {};
+    }
+}
+//# sourceMappingURL=dde.js.map