@accordproject/concerto-vocabulary 4.2.0 → 5.0.0-beta.1

package/dist/esm/chunk-3VH3UOGB.mjs

@@ -0,0 +1,398 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  vocabulary_default
+} from "./chunk-7RW3VXN4.mjs";
+import {
+  parseVocabularyYaml
+} from "./chunk-TA74NV57.mjs";
+
+// src/vocabularymanager.ts
+import YAML from "yaml";
+import { MetaModelNamespace } from "@accordproject/concerto-metamodel";
+import { ModelUtil } from "@accordproject/concerto-core";
+var DC_NAMESPACE = "org.accordproject.decoratorcommands@0.4.0";
+function camelCaseToSentence(text) {
+  const result = text.replace(/([A-Z]+)/g, " $1").trim();
+  return result.charAt(0).toUpperCase() + result.slice(1);
+}
+var VocabularyManager = class _VocabularyManager {
+  /**
+   * Create the VocabularyManager
+   * @param {*} [options] options to configure vocabulary lookup
+   * @param {*} [options.missingTermGenerator] A function to call for missing terms. The function
+   * should accept namespace, locale, declarationName, propertyName as arguments
+   * @constructor
+   */
+  constructor(options) {
+    this.vocabularies = {};
+    this.missingTermGenerator = options ? options.missingTermGenerator : null;
+  }
+  /**
+   * Computes a term in English based on declaration and property name.
+   * @param {string} namespace the namespace
+   * @param {string} locale the BCP-47 locale identifier
+   * @param {string} declarationName the name of a concept or enum
+   * @param {string} [propertyName] the name of a property (optional)
+   * @returns {string} the term or null if it does not exist
+   */
+  static englishMissingTermGenerator(namespace, locale, declarationName, propertyName) {
+    if (!declarationName) {
+      return camelCaseToSentence(ModelUtil.parseNamespace(namespace).name);
+    }
+    const firstPart = propertyName ? propertyName.replace("$", "") + " of the" : "";
+    return camelCaseToSentence(firstPart + declarationName);
+  }
+  /**
+   * Removes all vocabularies
+   */
+  clear() {
+    this.vocabularies = {};
+  }
+  /**
+   * Removes a vocabulary from the vocabulary manager
+   * @param {string} namespace the namespace for the vocabulary
+   * @param {string} locale the BCP-47 locale identifier
+   */
+  removeVocabulary(namespace, locale) {
+    delete this.vocabularies[`${namespace}/${locale}`];
+  }
+  /**
+   * Adds a vocabulary to the vocabulary manager
+   * @param {string} contents the YAML string for the vocabulary
+   * @param {*} [options] options to configure vocabulary parsing
+   * @param {boolean} [options.enableSafeVocabParsing] When true, ensures vocabulary values are resolved correctly as strings
+   * @returns {Vocabulary} the vocabulary the was added
+   */
+  addVocabulary(contents, options) {
+    if (!contents) {
+      throw new Error("Vocabulary contents must be specified");
+    }
+    const voc = new vocabulary_default(this, options?.enableSafeVocabParsing ? parseVocabularyYaml(contents) : YAML.parse(contents));
+    if (this.vocabularies[voc.getIdentifier()]) {
+      throw new Error("Vocabulary has already been added.");
+    }
+    this.vocabularies[voc.getIdentifier()] = voc;
+    return voc;
+  }
+  /**
+   * Finds the vocabulary for a requested locale, removing language
+   * identifiers from the locale until the locale matches, or if no
+   * vocabulary is found, null is returned
+   * @param {string} requestedLocale the BCP-47 locale identifier
+   * @param {Vocabulary[]} vocabularies the vocabularies to match against
+   * @param {*} [options] options to configure vocabulary lookup
+   * @param {*} [options.localeMatcher] Pass 'lookup' to find a general vocabulary, if available
+   * @returns {Vocabulary} the most specific vocabulary, or null
+   */
+  static findVocabulary(requestedLocale, vocabularies, options) {
+    let locale = requestedLocale;
+    let done = false;
+    do {
+      const voc = vocabularies.find((v) => v.getLocale() === locale);
+      if (voc) {
+        return voc;
+      }
+      if (options?.localeMatcher !== "lookup") {
+        done = true;
+        break;
+      }
+      const pos = locale.lastIndexOf("-");
+      if (pos === -1) {
+        done = true;
+        break;
+      }
+      locale = locale.substring(0, pos);
+    } while (!done);
+    return null;
+  }
+  /**
+   * Gets a vocabulary for a given namespace plus locale
+   * @param {string} namespace the namespace for the vocabulary
+   * @param {string} locale the BCP-47 locale identifier
+   * @param {*} [options] options to configure vocabulary lookup
+   * @param {*} [options.localeMatcher] Pass 'lookup' to find a general vocabulary, if available
+   * @returns {Vocabulary} the vocabulary or null if no vocabulary exists for the locale
+   */
+  getVocabulary(namespace, locale, options) {
+    const loc = locale.toLowerCase();
+    const voc = this.vocabularies[`${namespace}/${loc}`];
+    if (voc) {
+      return voc;
+    }
+    if (options?.localeMatcher === "lookup") {
+      const vocs = this.getVocabulariesForNamespace(namespace);
+      return _VocabularyManager.findVocabulary(loc, vocs, options);
+    }
+    return null;
+  }
+  /**
+   * Gets all the vocabulary files for a given namespace
+   * @param {string} namespace the namespace
+   * @returns {Vocabulary[]} the array of vocabularies
+   */
+  getVocabulariesForNamespace(namespace) {
+    return Object.values(this.vocabularies).filter((v) => v.getNamespace() === namespace);
+  }
+  /**
+   * Gets all the vocabulary files for a given locale
+   * @param {string} locale the BCP-47 locale identifier
+   * @returns {Vocabulary[]} the array of vocabularies
+   */
+  getVocabulariesForLocale(locale) {
+    return Object.values(this.vocabularies).filter((v) => v.getLocale() === locale.toLowerCase());
+  }
+  /**
+   * Resolve the term for a property, looking up terms from a more general vocabulary
+   * if required, and resolving properties using an object manager, allowing terms defined
+   * on super types to be automatically resolved.
+   * @param {ModelManager} modelManager the model manager
+   * @param {string} namespace the namespace
+   * @param {string} locale the BCP-47 locale identifier
+   * @param {string} declarationName the name of a concept or enum
+   * @param {string} [propertyName] the name of a property (optional)
+   * @param {string} [identifier] the identifier of the term (optional)
+   * @returns {string|number|boolean|null} the term or null if it does not exist
+   */
+  resolveTerm(modelManager, namespace, locale, declarationName, propertyName, identifier) {
+    const modelFile = modelManager.getModelFile(namespace);
+    const classDecl = modelFile ? modelFile.getType(declarationName) : null;
+    const property = propertyName ? classDecl ? classDecl.getProperty(propertyName) : null : null;
+    return this.getTerm(property ? property.getNamespace() : namespace, locale, property ? property.getParent().getName() : declarationName, propertyName, identifier);
+  }
+  /**
+   * Resolve the terms for a property, looking up terms from a more general vocabulary
+   * if required, and resolving properties using an object manager, allowing terms defined
+   * on super types to be automatically resolved.
+   * @param {ModelManager} modelManager the model manager
+   * @param {string} namespace the namespace
+   * @param {string} locale the BCP-47 locale identifier
+   * @param {string} declarationName the name of a concept or enum
+   * @param {string} [propertyName] the name of a property (optional)
+   * @param {*} [options] options to configure term resolution
+   * @param {boolean} [options.generateMissing=true] whether to synthesize missing terms
+   * @returns {*} the terms or null if it does not exist
+   */
+  resolveTerms(modelManager, namespace, locale, declarationName, propertyName, options) {
+    const modelFile = modelManager.getModelFile(namespace);
+    const classDecl = modelFile ? modelFile.getType(declarationName) : null;
+    let property;
+    if (classDecl && !classDecl.isScalarDeclaration()) {
+      if (classDecl.isMapDeclaration()) {
+        if (propertyName === "KEY") {
+          property = classDecl.getKey();
+        } else if (propertyName === "VALUE") {
+          property = classDecl.getValue();
+        }
+      } else {
+        property = propertyName ? classDecl ? classDecl.getProperty(propertyName) : null : null;
+      }
+    }
+    return this.getTerms(property ? property.getNamespace() : namespace, locale, property ? property.getParent().getName() : declarationName, propertyName, options);
+  }
+  /**
+   * Gets the term for a concept, enum or property, looking up terms
+   * from a more general vocabulary if required
+   * @param {string} namespace the namespace
+   * @param {string} locale the BCP-47 locale identifier
+   * @param {string} declarationName the name of a concept or enum
+   * @param {string} [propertyName] the name of a property (optional)
+   * @param {string} [identifier] the identifier of the term (optional)
+   * @returns {string|number|boolean|null} the term or null if it does not exist
+   */
+  getTerm(namespace, locale, declarationName, propertyName, identifier) {
+    const voc = this.getVocabulary(namespace, locale);
+    let term = null;
+    if (voc) {
+      term = voc.getTerm(declarationName, propertyName, identifier);
+    }
+    if (term != null) {
+      return term;
+    } else {
+      const dashIndex = locale.lastIndexOf("-");
+      if (dashIndex >= 0) {
+        return this.getTerm(namespace, locale.substring(0, dashIndex), declarationName, propertyName, identifier);
+      } else {
+        return this.missingTermGenerator ? this.missingTermGenerator(namespace, locale, declarationName, propertyName) : null;
+      }
+    }
+  }
+  /**
+   * Gets the term for a concept, enum or property, looking up terms
+   * from a more general vocabulary if required
+   * @param {string} namespace the namespace
+   * @param {string} locale the BCP-47 locale identifier
+   * @param {string} declarationName the name of a concept or enum
+   * @param {string} [propertyName] the name of a property (optional)
+   * @param {*} [options] options to configure term resolution
+   * @param {boolean} [options.generateMissing=true] whether to synthesize missing terms
+   * @returns {*} the terms or null if it does not exist
+   */
+  getTerms(namespace, locale, declarationName, propertyName, options) {
+    const voc = this.getVocabulary(namespace, locale);
+    let term = null;
+    if (voc) {
+      term = voc.getElementTerms(declarationName, propertyName);
+    }
+    if (term != null) {
+      return term;
+    } else {
+      const dashIndex = locale.lastIndexOf("-");
+      if (dashIndex >= 0) {
+        return this.getTerms(namespace, locale.substring(0, dashIndex), declarationName, propertyName, options);
+      } else {
+        if (options?.generateMissing === false) {
+          return;
+        }
+        let missingKey = propertyName ? propertyName : declarationName;
+        missingKey = missingKey ? missingKey : "term";
+        return this.missingTermGenerator ? { [missingKey]: this.missingTermGenerator(namespace, locale, declarationName, propertyName) } : null;
+      }
+    }
+  }
+  /**
+   * Creates a DecoractorCommandSet with @Term decorators
+   * to decorate all model elements based on the vocabulary for a locale.
+   * Pass the return value to the DecoratorManager.decorateModel to apply
+   * the decorators to a ModelManager.
+   * @param {ModelManager} modelManager - the Model Manager
+   * @param {string} locale the BCP-47 locale identifier
+   * @returns {*} the decorator command set used to decorate the model.
+   */
+  generateDecoratorCommands(modelManager, locale) {
+    const commands = [];
+    const CLASS_COMMAND = `${DC_NAMESPACE}.Command`;
+    const CLASS_TARGET = `${DC_NAMESPACE}.CommandTarget`;
+    const CLASS_DECORATOR = `${MetaModelNamespace}.Decorator`;
+    const CLASS_DECORATOR_STRING = `${MetaModelNamespace}.DecoratorString`;
+    const makeCommand = (target, decoratorName, value) => ({
+      "$class": CLASS_COMMAND,
+      "type": "UPSERT",
+      "target": target,
+      "decorator": {
+        "$class": CLASS_DECORATOR,
+        "name": decoratorName,
+        "arguments": [{ "$class": CLASS_DECORATOR_STRING, "value": value }]
+      }
+    });
+    modelManager.getModelFiles().forEach((model) => {
+      const namespace = model.getNamespace();
+      const nsTerms = this.getTerms(namespace, locale, "", void 0, { generateMissing: false });
+      if (nsTerms) {
+        const keys = Object.keys(nsTerms);
+        for (let i = 0; i < keys.length; i++) {
+          const term = keys[i];
+          if (term === "term") {
+            commands.push(makeCommand(
+              { "$class": CLASS_TARGET, "namespace": namespace },
+              "Term",
+              nsTerms[term]
+            ));
+          } else if (term !== "declarations" && term !== "namespace" && term !== "locale") {
+            commands.push(makeCommand(
+              { "$class": CLASS_TARGET, "namespace": namespace },
+              `Term_${term}`,
+              nsTerms[term]
+            ));
+          }
+        }
+      }
+      model.getAllDeclarations().forEach((decl) => {
+        const declName = decl.getName();
+        const declTerms = this.getTerms(namespace, locale, declName);
+        if (declTerms) {
+          const keys = Object.keys(declTerms);
+          for (let i = 0; i < keys.length; i++) {
+            const term = keys[i];
+            if (term === declName) {
+              commands.push(makeCommand(
+                { "$class": CLASS_TARGET, "namespace": namespace, "declaration": declName },
+                "Term",
+                declTerms[term]
+              ));
+            } else if (term !== "properties") {
+              commands.push(makeCommand(
+                { "$class": CLASS_TARGET, "namespace": namespace, "declaration": declName },
+                `Term_${term}`,
+                declTerms[term]
+              ));
+            }
+          }
+        }
+        let propertyNames = [];
+        if (decl.getProperties) {
+          propertyNames = decl.getProperties().map((p) => p.getName());
+        } else if (decl.isMapDeclaration?.()) {
+          propertyNames = ["KEY", "VALUE"];
+        } else {
+          return;
+        }
+        for (let p = 0; p < propertyNames.length; p++) {
+          const propertyName = propertyNames[p];
+          const propertyTerms = this.resolveTerms(modelManager, namespace, locale, declName, propertyName);
+          if (propertyTerms) {
+            const propertyType = propertyName === "KEY" || propertyName === "VALUE" ? "mapElement" : "property";
+            const keys = Object.keys(propertyTerms);
+            for (let i = 0; i < keys.length; i++) {
+              const term = keys[i];
+              commands.push(makeCommand(
+                { "$class": CLASS_TARGET, "namespace": namespace, "declaration": declName, [propertyType]: propertyName },
+                term === propertyName ? "Term" : `Term_${term}`,
+                propertyTerms[term]
+              ));
+            }
+          }
+        }
+      });
+    });
+    return {
+      "$class": `${DC_NAMESPACE}.DecoratorCommandSet`,
+      "name": `terms-${locale}`,
+      "version": "1.0.0",
+      "commands": commands
+    };
+  }
+  /**
+   * Validates the terms in the vocabulary against the namespaces and declarations
+   * within a ModelManager
+   * @param {ModelManager} modelManager - the Model Manager
+   * @param {string} locale the BCP-47 locale identifier
+   * @returns {*} the result of validation
+   */
+  validate(modelManager) {
+    const missingVocabularies = modelManager.getModelFiles().map((m) => this.getVocabulariesForNamespace(m.getNamespace()).length === 0 ? m.getNamespace() : null).filter((m) => m !== null);
+    const additionalVocabularies = Object.values(this.vocabularies).filter((v) => !modelManager.getModelFile(v.getNamespace()));
+    const result = {
+      missingVocabularies,
+      additionalVocabularies,
+      vocabularies: {}
+    };
+    Object.values(this.vocabularies).forEach((voc) => {
+      const vocResult = {
+        locale: voc.getLocale(),
+        namespace: voc.getNamespace(),
+        missingTerms: [],
+        additionalTerms: []
+      };
+      const model = modelManager.getModelFile(voc.getNamespace());
+      if (model) {
+        const errors = voc.validate(model);
+        if (errors.missingTerms) {
+          vocResult.missingTerms = vocResult.missingTerms.concat(errors.missingTerms);
+        }
+        if (errors.additionalTerms) {
+          vocResult.additionalTerms = vocResult.additionalTerms.concat(errors.additionalTerms);
+        }
+        result.vocabularies[`${vocResult.namespace}/${vocResult.locale}`] = vocResult;
+      }
+    });
+    return result;
+  }
+};
+var vocabularymanager_default = VocabularyManager;
+
+export {
+  VocabularyManager,
+  vocabularymanager_default
+};
+//# sourceMappingURL=chunk-3VH3UOGB.mjs.map

package/dist/esm/chunk-3VH3UOGB.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/vocabularymanager.ts"],
+  "sourcesContent": ["/*\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport YAML from 'yaml';\nimport { MetaModelNamespace } from '@accordproject/concerto-metamodel';\nimport Vocabulary from './vocabulary';\nimport { ModelUtil, ModelManager } from '@accordproject/concerto-core';\nimport { parseVocabularyYaml } from './yamlparser';\n\nconst DC_NAMESPACE = 'org.accordproject.decoratorcommands@0.4.0';\n\n/**\n * Converts a camel case string to a sentence\n * @param {string} text input\n * @returns {string} modified string\n */\nfunction camelCaseToSentence(text: string): string {\n    const result = text.replace(/([A-Z]+)/g, ' $1').trim();\n    return result.charAt(0).toUpperCase() + result.slice(1);\n}\n\n/**\n* A vocabulary manager for concerto models. The vocabulary manager\n* stores and provides API access to a set of vocabulary files, where each file\n* is associated with a BCP-47 language tag and a Concerto namespace.\n* @see https://datatracker.ietf.org/doc/html/rfc5646#section-2\n* @class\n* @memberof module:concerto-vocabulary\n*/\nclass VocabularyManager {\n    public vocabularies: Record<string, Vocabulary>;\n    public missingTermGenerator: any;\n\n    /**\n     * Create the VocabularyManager\n     * @param {*} [options] options to configure vocabulary lookup\n     * @param {*} [options.missingTermGenerator] A function to call for missing terms. The function\n     * should accept namespace, locale, declarationName, propertyName as arguments\n     * @constructor\n     */\n    constructor(options?: any) {\n        this.vocabularies = {}; // key is namespace/locale, value is a Vocabulary object\n        this.missingTermGenerator = options ? options.missingTermGenerator : null;\n    }\n\n    /**\n     * Computes a term in English based on declaration and property name.\n     * @param {string} namespace the namespace\n     * @param {string} locale the BCP-47 locale identifier\n     * @param {string} declarationName the name of a concept or enum\n     * @param {string} [propertyName] the name of a property (optional)\n     * @returns {string} the term or null if it does not exist\n     */\n    static englishMissingTermGenerator(namespace: string, locale: string, declarationName: string, propertyName?: string): string {\n        if(!declarationName){\n            return camelCaseToSentence(ModelUtil.parseNamespace(namespace).name);\n        }\n        const firstPart = propertyName ? propertyName.replace('$', '') + ' of the' : '';\n        return camelCaseToSentence(firstPart + declarationName);\n    }\n\n    /**\n     * Removes all vocabularies\n     */\n    clear() {\n        this.vocabularies = {};\n    }\n\n    /**\n     * Removes a vocabulary from the vocabulary manager\n     * @param {string} namespace the namespace for the vocabulary\n     * @param {string} locale the BCP-47 locale identifier\n     */\n    removeVocabulary(namespace: string, locale: string) {\n        delete this.vocabularies[`${namespace}/${locale}`];\n    }\n\n    /**\n     * Adds a vocabulary to the vocabulary manager\n     * @param {string} contents the YAML string for the vocabulary\n     * @param {*} [options] options to configure vocabulary parsing\n     * @param {boolean} [options.enableSafeVocabParsing] When true, ensures vocabulary values are resolved correctly as strings\n     * @returns {Vocabulary} the vocabulary the was added\n     */\n    addVocabulary(contents: any, options?: any): Vocabulary {\n        if (!contents) {\n            throw new Error('Vocabulary contents must be specified');\n        }\n        const voc = new Vocabulary(this, options?.enableSafeVocabParsing ? parseVocabularyYaml(contents) : YAML.parse(contents));\n\n        if (this.vocabularies[voc.getIdentifier()]) {\n            throw new Error('Vocabulary has already been added.');\n        }\n        this.vocabularies[voc.getIdentifier()] = voc;\n        return voc;\n    }\n\n    /**\n     * Finds the vocabulary for a requested locale, removing language\n     * identifiers from the locale until the locale matches, or if no\n     * vocabulary is found, null is returned\n     * @param {string} requestedLocale the BCP-47 locale identifier\n     * @param {Vocabulary[]} vocabularies the vocabularies to match against\n     * @param {*} [options] options to configure vocabulary lookup\n     * @param {*} [options.localeMatcher] Pass 'lookup' to find a general vocabulary, if available\n     * @returns {Vocabulary} the most specific vocabulary, or null\n     */\n    static findVocabulary(requestedLocale: string, vocabularies: Vocabulary[], options?: any): Vocabulary | null {\n        let locale = requestedLocale;\n        let done = false;\n        do {\n            const voc = vocabularies.find(v => v.getLocale() === locale);\n            if (voc) {\n                return voc;\n            }\n\n            if (options?.localeMatcher !== 'lookup') {\n                done = true;\n                break;\n            }\n\n            const pos = locale.lastIndexOf('-');\n            if (pos === -1) {\n                done = true;\n                break;\n            }\n            locale = locale.substring(0, pos);\n        } while (!done);\n        return null;\n    }\n\n    /**\n     * Gets a vocabulary for a given namespace plus locale\n     * @param {string} namespace the namespace for the vocabulary\n     * @param {string} locale the BCP-47 locale identifier\n     * @param {*} [options] options to configure vocabulary lookup\n     * @param {*} [options.localeMatcher] Pass 'lookup' to find a general vocabulary, if available\n     * @returns {Vocabulary} the vocabulary or null if no vocabulary exists for the locale\n     */\n    getVocabulary(namespace: string, locale: string, options?: any): Vocabulary | null {\n        const loc = locale.toLowerCase();\n        const voc = this.vocabularies[`${namespace}/${loc}`];\n        if (voc) {\n            return voc;\n        }\n        if (options?.localeMatcher === 'lookup') {\n            const vocs = this.getVocabulariesForNamespace(namespace);\n            return VocabularyManager.findVocabulary(loc, vocs, options);\n        }\n        return null;\n    }\n\n    /**\n     * Gets all the vocabulary files for a given namespace\n     * @param {string} namespace the namespace\n     * @returns {Vocabulary[]} the array of vocabularies\n     */\n    getVocabulariesForNamespace(namespace: string): Vocabulary[] {\n        return Object.values(this.vocabularies).filter(v => v.getNamespace() === namespace);\n    }\n\n    /**\n     * Gets all the vocabulary files for a given locale\n     * @param {string} locale the BCP-47 locale identifier\n     * @returns {Vocabulary[]} the array of vocabularies\n     */\n    getVocabulariesForLocale(locale: string): Vocabulary[] {\n        return Object.values(this.vocabularies).filter(v => v.getLocale() === locale.toLowerCase());\n    }\n\n    /**\n     * Resolve the term for a property, looking up terms from a more general vocabulary\n     * if required, and resolving properties using an object manager, allowing terms defined\n     * on super types to be automatically resolved.\n     * @param {ModelManager} modelManager the model manager\n     * @param {string} namespace the namespace\n     * @param {string} locale the BCP-47 locale identifier\n     * @param {string} declarationName the name of a concept or enum\n     * @param {string} [propertyName] the name of a property (optional)\n     * @param {string} [identifier] the identifier of the term (optional)\n     * @returns {string|number|boolean|null} the term or null if it does not exist\n     */\n    resolveTerm(modelManager: ModelManager, namespace: string, locale: string, declarationName: string, propertyName?: string, identifier?: string): string | number | boolean | null {\n        const modelFile = modelManager.getModelFile(namespace);\n        // @ts-ignore\n        const classDecl = modelFile ? (modelFile as any).getType(declarationName) : null;\n        const property = propertyName ? classDecl ? classDecl.getProperty(propertyName) : null : null;\n        return this.getTerm(property ? property.getNamespace() : namespace, locale, property ? (property.getParent() as any).getName() : declarationName, propertyName, identifier);\n    }\n\n    /**\n     * Resolve the terms for a property, looking up terms from a more general vocabulary\n     * if required, and resolving properties using an object manager, allowing terms defined\n     * on super types to be automatically resolved.\n     * @param {ModelManager} modelManager the model manager\n     * @param {string} namespace the namespace\n     * @param {string} locale the BCP-47 locale identifier\n     * @param {string} declarationName the name of a concept or enum\n     * @param {string} [propertyName] the name of a property (optional)\n     * @param {*} [options] options to configure term resolution\n     * @param {boolean} [options.generateMissing=true] whether to synthesize missing terms\n     * @returns {*} the terms or null if it does not exist\n     */\n    resolveTerms(modelManager: ModelManager, namespace: string, locale: string, declarationName: string, propertyName?: string, options?: any) {\n        const modelFile = modelManager.getModelFile(namespace);\n        // @ts-ignore\n        const classDecl = modelFile ? (modelFile as any).getType(declarationName) : null;\n        let property;\n        if(classDecl && !classDecl.isScalarDeclaration()) {\n            if(classDecl.isMapDeclaration()) {\n                if(propertyName === 'KEY') {\n                    property = classDecl.getKey();\n                } else if(propertyName === 'VALUE') {\n                    property = classDecl.getValue();\n                }\n            } else {\n                property = propertyName ? classDecl ? classDecl.getProperty(propertyName) : null : null;\n            }\n        }\n        return this.getTerms(property ? property.getNamespace() : namespace, locale, property ? (property.getParent() as any).getName() : declarationName, propertyName, options);\n    }\n\n    /**\n     * Gets the term for a concept, enum or property, looking up terms\n     * from a more general vocabulary if required\n     * @param {string} namespace the namespace\n     * @param {string} locale the BCP-47 locale identifier\n     * @param {string} declarationName the name of a concept or enum\n     * @param {string} [propertyName] the name of a property (optional)\n     * @param {string} [identifier] the identifier of the term (optional)\n     * @returns {string|number|boolean|null} the term or null if it does not exist\n     */\n    getTerm(namespace: string, locale: string, declarationName: string, propertyName?: string, identifier?: string): string | number | boolean | null {\n        const voc = this.getVocabulary(namespace, locale);\n        let term = null;\n        if (voc) {\n            term = voc.getTerm(declarationName, propertyName, identifier);\n        }\n        if (term != null) {\n            return term;\n        }\n        else {\n            const dashIndex = locale.lastIndexOf('-');\n            if (dashIndex >= 0) {\n                return this.getTerm(namespace, locale.substring(0, dashIndex), declarationName, propertyName, identifier);\n            }\n            else {\n                return this.missingTermGenerator ? this.missingTermGenerator(namespace, locale, declarationName, propertyName) : null;\n            }\n        }\n    }\n\n    /**\n     * Gets the term for a concept, enum or property, looking up terms\n     * from a more general vocabulary if required\n     * @param {string} namespace the namespace\n     * @param {string} locale the BCP-47 locale identifier\n     * @param {string} declarationName the name of a concept or enum\n     * @param {string} [propertyName] the name of a property (optional)\n     * @param {*} [options] options to configure term resolution\n     * @param {boolean} [options.generateMissing=true] whether to synthesize missing terms\n     * @returns {*} the terms or null if it does not exist\n     */\n    getTerms(namespace: string, locale: string, declarationName: string, propertyName?: string, options?: any): any {\n        const voc = this.getVocabulary(namespace, locale);\n        let term = null;\n        if (voc) {\n            term = voc.getElementTerms(declarationName, propertyName);\n        }\n        if (term != null) {\n            return term;\n        }\n        else {\n            const dashIndex = locale.lastIndexOf('-');\n            if (dashIndex >= 0) {\n                return this.getTerms(namespace, locale.substring(0, dashIndex), declarationName, propertyName, options);\n            }\n            else {\n                if (options?.generateMissing === false) {\n                    return;\n                }\n                let missingKey = propertyName ? propertyName : declarationName;\n                missingKey = missingKey? missingKey : 'term';\n                return this.missingTermGenerator ? { [missingKey]: this.missingTermGenerator(namespace, locale, declarationName, propertyName) } : null;\n            }\n        }\n    }\n\n    /**\n     * Creates a DecoractorCommandSet with @Term decorators\n     * to decorate all model elements based on the vocabulary for a locale.\n     * Pass the return value to the DecoratorManager.decorateModel to apply\n     * the decorators to a ModelManager.\n     * @param {ModelManager} modelManager - the Model Manager\n     * @param {string} locale the BCP-47 locale identifier\n     * @returns {*} the decorator command set used to decorate the model.\n     */\n    generateDecoratorCommands(modelManager: ModelManager, locale: string): any {\n        const commands: any[] = [];\n\n        const CLASS_COMMAND = `${DC_NAMESPACE}.Command`;\n        const CLASS_TARGET = `${DC_NAMESPACE}.CommandTarget`;\n        const CLASS_DECORATOR = `${MetaModelNamespace}.Decorator`;\n        const CLASS_DECORATOR_STRING = `${MetaModelNamespace}.DecoratorString`;\n\n        const makeCommand = (target: any, decoratorName: string, value: string) => ({\n            '$class': CLASS_COMMAND,\n            'type': 'UPSERT',\n            'target': target,\n            'decorator': {\n                '$class': CLASS_DECORATOR,\n                'name': decoratorName,\n                'arguments': [{ '$class': CLASS_DECORATOR_STRING, 'value': value }]\n            }\n        });\n\n        // @ts-ignore\n        (modelManager as any).getModelFiles().forEach((model: any) => {\n            const namespace = model.getNamespace();\n\n            const nsTerms = this.getTerms(namespace, locale, '', undefined, { generateMissing: false });\n            if (nsTerms) {\n                const keys = Object.keys(nsTerms);\n                for (let i = 0; i < keys.length; i++) {\n                    const term = keys[i];\n                    if (term === 'term') {\n                        commands.push(makeCommand(\n                            { '$class': CLASS_TARGET, 'namespace': namespace },\n                            'Term', nsTerms[term]\n                        ));\n                    } else if (term !== 'declarations' && term !== 'namespace' && term !== 'locale') {\n                        commands.push(makeCommand(\n                            { '$class': CLASS_TARGET, 'namespace': namespace },\n                            `Term_${term}`, nsTerms[term]\n                        ));\n                    }\n                }\n            }\n\n            model.getAllDeclarations().forEach((decl: any) => {\n                const declName = decl.getName();\n\n                const declTerms = this.getTerms(namespace, locale, declName);\n                if (declTerms) {\n                    const keys = Object.keys(declTerms);\n                    for (let i = 0; i < keys.length; i++) {\n                        const term = keys[i];\n                        if (term === declName) {\n                            commands.push(makeCommand(\n                                { '$class': CLASS_TARGET, 'namespace': namespace, 'declaration': declName },\n                                'Term', declTerms[term]\n                            ));\n                        } else if (term !== 'properties') {\n                            commands.push(makeCommand(\n                                { '$class': CLASS_TARGET, 'namespace': namespace, 'declaration': declName },\n                                `Term_${term}`, declTerms[term]\n                            ));\n                        }\n                    }\n                }\n\n                let propertyNames: string[] = [];\n                if (decl.getProperties) {\n                    propertyNames = decl.getProperties().map((p: any) => p.getName());\n                } else if (decl.isMapDeclaration?.()) {\n                    propertyNames = ['KEY', 'VALUE'];\n                } else {\n                    return;\n                }\n\n                for (let p = 0; p < propertyNames.length; p++) {\n                    const propertyName = propertyNames[p];\n                    const propertyTerms = this.resolveTerms(modelManager, namespace, locale, declName, propertyName);\n                    if (propertyTerms) {\n                        const propertyType = propertyName === 'KEY' || propertyName === 'VALUE' ? 'mapElement' : 'property';\n                        const keys = Object.keys(propertyTerms);\n                        for (let i = 0; i < keys.length; i++) {\n                            const term = keys[i];\n                            commands.push(makeCommand(\n                                { '$class': CLASS_TARGET, 'namespace': namespace, 'declaration': declName, [propertyType]: propertyName },\n                                term === propertyName ? 'Term' : `Term_${term}`, propertyTerms[term]\n                            ));\n                        }\n                    }\n                }\n            });\n        });\n\n        return {\n            '$class': `${DC_NAMESPACE}.DecoratorCommandSet`,\n            'name': `terms-${locale}`,\n            'version': '1.0.0',\n            'commands': commands\n        };\n    }\n\n    /**\n     * Validates the terms in the vocabulary against the namespaces and declarations\n     * within a ModelManager\n     * @param {ModelManager} modelManager - the Model Manager\n     * @param {string} locale the BCP-47 locale identifier\n     * @returns {*} the result of validation\n     */\n    validate(modelManager: ModelManager): any {\n        // missing vocabularies\n        // @ts-ignore\n        const missingVocabularies = (modelManager as any).getModelFiles()\n            .map((m: any) => this.getVocabulariesForNamespace(m.getNamespace()).length === 0 ? m.getNamespace() : null)\n            .filter((m: any) => m !== null);\n\n        // additional vocabularies\n        const additionalVocabularies = Object.values(this.vocabularies)\n            .filter(v => !modelManager.getModelFile(v.getNamespace()));\n\n        const result: any = {\n            missingVocabularies,\n            additionalVocabularies,\n            vocabularies: {}\n        };\n\n        // validate the models against the vocs\n        Object.values(this.vocabularies)\n            .forEach(voc => {\n                const vocResult: any = {\n                    locale: voc.getLocale(),\n                    namespace: voc.getNamespace(),\n                    missingTerms: [],\n                    additionalTerms: []\n                };\n\n                const model = modelManager.getModelFile(voc.getNamespace());\n                if (model) {\n                    const errors = voc.validate(model);\n                    if (errors.missingTerms) {\n                        vocResult.missingTerms = vocResult.missingTerms.concat(errors.missingTerms);\n                    }\n                    if (errors.additionalTerms) {\n                        vocResult.additionalTerms = vocResult.additionalTerms.concat(errors.additionalTerms);\n                    }\n\n                    result.vocabularies[`${vocResult.namespace}/${vocResult.locale}`] = vocResult;\n                }\n            });\n        return result;\n    }\n}\n\nexport { VocabularyManager };\nexport default VocabularyManager;\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/chunk-7RW3VXN4.mjs

@@ -0,0 +1,185 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+
+// src/vocabulary.ts
+var Vocabulary = class _Vocabulary {
+  /**
+   * Create the Vocabulary
+   * @constructor
+   * @param {VocabularyManager} vocabularyManager - the manager for this vocabulary
+   * @param {object} voc - the JSON representation of the vocabulary
+   */
+  constructor(vocabularyManager, voc) {
+    if (!vocabularyManager) {
+      throw new Error("VocabularyManager must be specified");
+    }
+    if (!voc) {
+      throw new Error("Vocabulary object must be specified");
+    }
+    if (!voc.declarations) {
+      throw new Error("Vocabulary object must have declarations");
+    }
+    if (!voc.namespace) {
+      throw new Error("A vocabulary must specify a namespace");
+    }
+    if (!voc.locale) {
+      throw new Error("A vocabulary must specify a locale");
+    }
+    _Vocabulary.validateLocale(voc.locale);
+    this.vocabularyManager = vocabularyManager;
+    this.content = voc;
+  }
+  /**
+   * Returns the namespace for the vocabulary
+   * @returns {string} the namespace for this vocabulary
+   */
+  getNamespace() {
+    return this.content.namespace;
+  }
+  /**
+   * Validates a locale
+   * @param {string} locale the locale to validate
+   * @throws {Error} if the locale is invalid
+   */
+  static validateLocale(locale) {
+    new Intl.Locale(locale);
+    if (locale !== locale.toLowerCase()) {
+      throw new Error("Locale should be lowercase with dashes");
+    }
+  }
+  /**
+   * Returns the locale for the vocabulary
+   * @returns {string} the locale for this vocabulary
+   */
+  getLocale() {
+    return this.content.locale;
+  }
+  /**
+   * Returns the identifier for the vocabulary, composed of the namespace plus the locale
+   * @returns {string} the identifier for this vocabulary
+   */
+  getIdentifier() {
+    return `${this.getNamespace()}/${this.content.locale}`;
+  }
+  /**
+   * Returns all the declarations for this vocabulary
+   * @returns {Array} an array of objects
+   */
+  getTerms() {
+    return this.content.declarations;
+  }
+  /**
+   * Gets the terms of Namespace
+   * @returns {string} the term or null if it does not exist
+   * @private
+   */
+  getNamespaceTerms() {
+    const namespaceTerms = Object.entries(this.content).filter(([key]) => key !== "namespace" && key !== "locale" && key !== "declarations");
+    return namespaceTerms.length > 0 ? Object.fromEntries(namespaceTerms) : null;
+  }
+  /**
+   * Gets the term for a concept, enum or property
+   * @param {string} declarationName the name of a concept or enum
+   * @param {string} [propertyName] the name of a property (optional)
+   * @param {string} [identifier] the identifier of the term (optional)
+   * @returns {string|number|boolean|null} the term or null if it does not exist
+   */
+  getTerm(declarationName, propertyName, identifier) {
+    if (!declarationName) {
+      const namespaceTerms = this.getNamespaceTerms();
+      return identifier ? namespaceTerms?.[identifier] : namespaceTerms?.term;
+    }
+    const decl = this.content.declarations.find((d) => Object.keys(d)[0] === declarationName);
+    if (!decl) {
+      return null;
+    }
+    if (!propertyName) {
+      return identifier ? decl[identifier] : decl[declarationName];
+    } else {
+      const property = decl.properties ? decl.properties.find((d) => propertyName in d) : null;
+      return property ? identifier ? property[identifier] : property[propertyName] : null;
+    }
+  }
+  /**
+   * Gets the terms for a concept, enum or property
+   * @param {string} declarationName the name of a concept or enum
+   * @param {string} [propertyName] the name of a property (optional)
+   * @returns {string} the term or null if it does not exist
+   */
+  getElementTerms(declarationName, propertyName) {
+    if (!declarationName) {
+      return this.getNamespaceTerms();
+    }
+    const decl = this.content.declarations.find((d) => Object.keys(d)[0] === declarationName);
+    if (!decl) {
+      return null;
+    }
+    if (!propertyName) {
+      return decl;
+    } else {
+      const property = decl.properties ? decl.properties.find((d) => propertyName in d) : null;
+      return property;
+    }
+  }
+  /**
+   * Validates a vocabulary against a ModelFile, returning errors for
+   * missing and additional terms.
+   * @param {ModelFile} modelFile the model file for this vocabulary
+   * @returns {*} an object with missingTerms and additionalTerms properties
+   */
+  validate(modelFile) {
+    const getOwnProperties = (declaration) => {
+      if (declaration.isMapDeclaration()) {
+        return [declaration.getKey(), declaration.getValue()];
+      } else {
+        return declaration.getOwnProperties?.() ? declaration.getOwnProperties?.() : [];
+      }
+    };
+    const getPropertyName = (property) => {
+      if (property.isKey?.()) {
+        return "KEY";
+      } else if (property.isValue?.()) {
+        return "VALUE";
+      } else {
+        return property.getName();
+      }
+    };
+    const checkPropertyExists = (k, p) => {
+      const declaration = modelFile.getLocalType(Object.keys(k)[0]);
+      const property = Object.keys(p)[0];
+      if (declaration.isMapDeclaration()) {
+        if (property === "KEY") {
+          return true;
+        } else if (property === "VALUE") {
+          return true;
+        } else {
+          return false;
+        }
+      } else {
+        return declaration.getOwnProperty(Object.keys(p)[0]);
+      }
+    };
+    const result = {
+      missingTerms: modelFile.getAllDeclarations().flatMap((d) => this.getTerm(d.getName()) ? getOwnProperties(d).flatMap((p) => this.getTerm(d.getName(), getPropertyName(p)) ? null : `${d.getName()}.${getPropertyName(p)}`) : d.getName()).filter((i) => i !== null),
+      additionalTerms: this.content.declarations.flatMap((k) => modelFile.getLocalType(Object.keys(k)[0]) ? Array.isArray(k.properties) ? k.properties.flatMap((p) => checkPropertyExists(k, p) ? null : `${Object.keys(k)[0]}.${Object.keys(p)[0]}`) : null : k).filter((i) => i !== null)
+    };
+    if (!this.content.term) {
+      result.missingTerms.push("namespace");
+    }
+    return result;
+  }
+  /**
+   * Converts the object to JSON
+   * @returns {*} the contens of this vocabulary
+   */
+  toJSON() {
+    return this.content;
+  }
+};
+var vocabulary_default = Vocabulary;
+
+export {
+  Vocabulary,
+  vocabulary_default
+};
+//# sourceMappingURL=chunk-7RW3VXN4.mjs.map