Change Db to typescript and add types

packages/mermaid/src/diagrams/requirement/requirementDb.ts

@@ -8,12 +8,15 @@ import {
   setAccDescription,
   clear as commonClear,
 } from '../common/commonDb.js';
-
-let relations = [];
-let latestRequirement = {};
-let requirements = new Map();
-let latestElement = {};
-let elements = new Map();
+import type {
+  Element,
+  Relation,
+  RelationshipType,
+  Requirement,
+  RequirementType,
+  RiskLevel,
+  VerifyType,
+} from './types.js';
 
 const RequirementType = {
   REQUIREMENT: 'Requirement',
@@ -47,78 +50,108 @@ const Relationships = {
   TRACES: 'traces',
 };
 
-const addRequirement = (name, type) => {
+const getInitialRequirement = (): Requirement => ({
+  id: '',
+  text: '',
+  risk: RiskLevel.LOW_RISK as RiskLevel,
+  verifyMethod: VerifyType.VERIFY_ANALYSIS as VerifyType,
+  name: '',
+  type: RequirementType.REQUIREMENT as RequirementType,
+});
+
+const getInitialElement = (): Element => ({
+  name: '',
+  type: '',
+  docRef: '',
+});
+
+// Update initial declarations
+let relations: Relation[] = [];
+let latestRequirement: Requirement = getInitialRequirement();
+let requirements = new Map<string, Requirement>();
+let latestElement: Element = getInitialElement();
+let elements = new Map<string, Element>();
+
+// Add reset functions
+const resetLatestRequirement = () => {
+  latestRequirement = getInitialRequirement();
+};
+
+const resetLatestElement = () => {
+  latestElement = getInitialElement();
+};
+
+const addRequirement = (name: string, type: RequirementType) => {
   if (!requirements.has(name)) {
     requirements.set(name, {
       name,
       type,
-
       id: latestRequirement.id,
       text: latestRequirement.text,
       risk: latestRequirement.risk,
       verifyMethod: latestRequirement.verifyMethod,
     });
   }
-  latestRequirement = {};
+  resetLatestRequirement();
 
   return requirements.get(name);
 };
 
 const getRequirements = () => requirements;
 
-const setNewReqId = (id) => {
+const setNewReqId = (id: string) => {
   if (latestRequirement !== undefined) {
     latestRequirement.id = id;
   }
 };
 
-const setNewReqText = (text) => {
+const setNewReqText = (text: string) => {
   if (latestRequirement !== undefined) {
     latestRequirement.text = text;
   }
 };
 
-const setNewReqRisk = (risk) => {
+const setNewReqRisk = (risk: RiskLevel) => {
   if (latestRequirement !== undefined) {
     latestRequirement.risk = risk;
   }
 };
 
-const setNewReqVerifyMethod = (verifyMethod) => {
+const setNewReqVerifyMethod = (verifyMethod: VerifyType) => {
   if (latestRequirement !== undefined) {
     latestRequirement.verifyMethod = verifyMethod;
   }
 };
 
-const addElement = (name) => {
+const addElement = (name: string) => {
   if (!elements.has(name)) {
     elements.set(name, {
       name,
       type: latestElement.type,
       docRef: latestElement.docRef,
     });
-    log.info('Added new requirement: ', name);
+    log.info('Added new element: ', name);
   }
-  latestElement = {};
+  resetLatestElement();
 
   return elements.get(name);
 };
 
 const getElements = () => elements;
 
-const setNewElementType = (type) => {
+const setNewElementType = (type: string) => {
   if (latestElement !== undefined) {
     latestElement.type = type;
   }
 };
 
-const setNewElementDocRef = (docRef) => {
+const setNewElementDocRef = (docRef: string) => {
   if (latestElement !== undefined) {
     latestElement.docRef = docRef;
   }
 };
 
-const addRelationship = (type, src, dst) => {
+const addRelationship = (type: RelationshipType, src: string, dst: string) => {
   relations.push({
     type,
     src,
@@ -130,21 +163,19 @@ const getRelationships = () => relations;
 
 const clear = () => {
   relations = [];
-  latestRequirement = {};
+  resetLatestRequirement();
   requirements = new Map();
-  latestElement = {};
+  resetLatestElement();
   elements = new Map();
   commonClear();
 };
 
 export default {
+  Relationships,
   RequirementType,
   RiskLevel,
   VerifyType,
-  Relationships,
-
-  getConfig: () => getConfig().req,
-
+  getConfig: () => getConfig().requirement,
   addRequirement,
   getRequirements,
   setNewReqId,
@@ -155,14 +186,11 @@ export default {
   getAccTitle,
   setAccDescription,
   getAccDescription,
-
   addElement,
   getElements,
   setNewElementType,
   setNewElementDocRef,
-
   addRelationship,
   getRelationships,
-
   clear,
 };

packages/mermaid/src/diagrams/requirement/types.ts

@@ -0,0 +1,41 @@
+export type RequirementType =
+  | 'Requirement'
+  | 'Functional Requirement'
+  | 'Interface Requirement'
+  | 'Performance Requirement'
+  | 'Physical Requirement'
+  | 'Design Constraint';
+
+export type RiskLevel = 'Low' | 'Medium' | 'High';
+
+export type VerifyType = 'Analysis' | 'Demonstration' | 'Inspection' | 'Test';
+
+export interface Requirement {
+  name: string;
+  type: RequirementType;
+  id: string;
+  text: string;
+  risk: RiskLevel;
+  verifyMethod: VerifyType;
+}
+
+export type RelationshipType =
+  | 'contains'
+  | 'copies'
+  | 'derives'
+  | 'satisfies'
+  | 'verifies'
+  | 'refines'
+  | 'traces';
+
+export interface Relation {
+  type: RelationshipType;
+  src: string;
+  dst: string;
+}
+
+export interface Element {
+  name: string;
+  type: string;
+  docRef: string;
+}