@schemd/core 0.1.1 → 0.1.2

package/dist/parser.js

@@ -1,5 +1,6 @@
-import { ANALOG_KINDS, CLASSICAL_GATE_KINDS, COMPONENT_KINDS, DIODE_TYPES, GROUND_STYLES, PASSIVE_KINDS, SEMANTIC_COLORS, SCHEMATIC_SIGNAL_MARKERS, TRANSISTOR_TYPES, SchematicSyntaxError } from './types.js';
+import { ANALOG_KINDS, CLASSICAL_GATE_KINDS, COMPONENT_KINDS, DIODE_TYPES, GROUND_STYLES, PASSIVE_KINDS, SEMANTIC_COLORS, SCHEMATIC_SIGNAL_MARKERS, TRANSISTOR_TYPES, UML_COMPONENT_KINDS, UML_RELATION_KINDS, SchematicSyntaxError } from './types.js';
 import { validateDocumentGeometry } from './layout.js';
+import { mathLabelTextWidth } from './math-label.js';
 import { MAX_SCHEMATIC_COMPONENTS, MAX_SCHEMATIC_CONNECTIONS, MAX_SCHEMATIC_SOURCE_CHARACTERS } from './limits.js';
 const COMPONENT_PATTERN = /^([A-Za-z][A-Za-z0-9_-]*):([A-Za-z][A-Za-z0-9_-]*)\s+"([^"]+)"\s+at\s+\((-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)\)\s+(.+)$/;
 const CONNECTION_PATTERN = /^([A-Za-z][A-Za-z0-9_-]*)\.([A-Za-z][A-Za-z0-9_-]*)\s*->\s*([A-Za-z][A-Za-z0-9_-]*)\.([A-Za-z][A-Za-z0-9_-]*)\s+(.+)$/;
@@ -15,6 +16,9 @@ const IC_MINIMUM_HEIGHT = 64;
 const IC_HORIZONTAL_PIN_SPACING = 22;
 const IC_VERTICAL_PIN_SPACING = 18;
 const IC_BODY_PADDING = 24;
+const MAX_UML_ROWS = 64;
+const MAX_UML_ROW_LENGTH = 256;
+const UML_ROW_HEIGHT = 16;
 const MAX_FENCE_TITLE_LENGTH = 512;
 const parsedDocuments = new WeakSet();
 function freezeParsedDocument(document) {
@@ -27,6 +31,12 @@ function freezeParsedDocument(document) {
             Object.freeze(component.pins.bottom);
             Object.freeze(component.pins);
         }
+        if (component.kind === 'class') {
+            Object.freeze(component.attributes);
+            Object.freeze(component.operations);
+        }
+        if (component.kind === 'state')
+            Object.freeze(component.details);
         Object.freeze(component);
     }
     for (const connection of document.connections) {
@@ -141,29 +151,51 @@ function parseAttributes(raw, line) {
     let cursor = 0;
     while (cursor < source.length) {
         if (cursor > 0) {
-            const separator = source.slice(cursor).match(/^\s+/);
-            if (!separator)
+            if (!/\s/.test(source[cursor])) {
+                throw new SchematicSyntaxError('Malformed component options.', line);
+            }
+            while (cursor < source.length && /\s/.test(source[cursor]))
+                cursor += 1;
+            if (cursor === source.length) {
                 throw new SchematicSyntaxError('Malformed component options.', line);
-            cursor += separator[0].length;
+            }
         }
-        const keyMatch = source.slice(cursor).match(/^([a-z][a-z0-9-]*)=/);
-        if (!keyMatch) {
+        const keyStart = cursor;
+        const firstCode = source.charCodeAt(cursor);
+        if (firstCode < 97 || firstCode > 122) {
             throw new SchematicSyntaxError('Malformed component options.', line);
         }
-        const key = keyMatch[1];
-        cursor += keyMatch[0].length;
+        cursor += 1;
+        while (cursor < source.length) {
+            const code = source.charCodeAt(cursor);
+            if (!((code >= 97 && code <= 122) || (code >= 48 && code <= 57) || code === 45))
+                break;
+            cursor += 1;
+        }
+        if (source[cursor] !== '=') {
+            throw new SchematicSyntaxError('Malformed component options.', line);
+        }
+        const key = source.slice(keyStart, cursor);
+        cursor += 1;
         let value;
         if (source[cursor] === '"') {
-            const closingQuote = source.indexOf('"', cursor + 1);
-            value = source.slice(cursor + 1, closingQuote);
-            cursor = closingQuote + 1;
+            const valueStart = ++cursor;
+            while (cursor < source.length && source[cursor] !== '"')
+                cursor += 1;
+            if (cursor === source.length) {
+                throw new SchematicSyntaxError('Malformed component options.', line);
+            }
+            value = source.slice(valueStart, cursor);
+            cursor += 1;
         }
         else {
-            const valueMatch = source.slice(cursor).match(/^[^\s]+/);
-            if (!valueMatch)
+            const valueStart = cursor;
+            while (cursor < source.length && !/\s/.test(source[cursor]))
+                cursor += 1;
+            if (cursor === valueStart) {
                 throw new SchematicSyntaxError('Malformed component options.', line);
-            value = valueMatch[0];
-            cursor += value.length;
+            }
+            value = source.slice(valueStart, cursor);
         }
         if (attributes.has(key))
             throw new SchematicSyntaxError(`Duplicate option ${key}.`, line);
@@ -287,6 +319,38 @@ function integratedCircuitDimensions(pins) {
         bodyHeight: Math.max(IC_MINIMUM_HEIGHT, Math.max(pins.left.length, pins.right.length) * IC_VERTICAL_PIN_SPACING + IC_BODY_PADDING)
     };
 }
+function parseUmlRows(value, name, line) {
+    if (value === undefined || value.trim() === '')
+        return [];
+    const rows = value.split(';').map((row) => row.trim());
+    if (rows.length > MAX_UML_ROWS) {
+        throw new SchematicSyntaxError(`${name} supports at most ${MAX_UML_ROWS} rows.`, line);
+    }
+    for (const row of rows) {
+        if (row === '' || row.length > MAX_UML_ROW_LENGTH) {
+            throw new SchematicSyntaxError(`${name} rows must contain 1 through ${MAX_UML_ROW_LENGTH} characters.`, line);
+        }
+    }
+    return rows;
+}
+function parseUmlDimension(value, fallback, name, line) {
+    if (value === undefined)
+        return fallback;
+    if (!/^\d+(?:\.\d+)?$/.test(value)) {
+        throw new SchematicSyntaxError(`${name} must be a finite number from 24 through 2048.`, line);
+    }
+    const dimension = Number(value);
+    if (dimension < 24 || dimension > 2048) {
+        throw new SchematicSyntaxError(`${name} must be a finite number from 24 through 2048.`, line);
+    }
+    return dimension;
+}
+function widestUmlRow(rows) {
+    let width = 0;
+    for (const row of rows)
+        width = Math.max(width, mathLabelTextWidth(row, 8));
+    return width;
+}
 function commonComponent(match, color, line) {
     return {
         id: match[2],
@@ -362,6 +426,67 @@ function parseComponent(match, line) {
             ...integratedCircuitDimensions(pins)
         };
     }
+    if (includesValue(UML_COMPONENT_KINDS, kind)) {
+        switch (kind) {
+            case 'class': {
+                assertOnlyAttributes(attributes, ['attributes', 'operations', 'stereotype', 'width'], line);
+                const classAttributes = parseUmlRows(attributes.get('attributes'), 'attributes', line);
+                const operations = parseUmlRows(attributes.get('operations'), 'operations', line);
+                const stereotype = attributes.get('stereotype');
+                if (stereotype !== undefined && (stereotype === '' || stereotype.length > 128)) {
+                    throw new SchematicSyntaxError('stereotype must contain 1 through 128 characters.', line);
+                }
+                const calculatedWidth = Math.max(120, widestUmlRow([common.label, stereotype ?? '', ...classAttributes, ...operations]) + 24);
+                const bodyWidth = Math.max(calculatedWidth, parseUmlDimension(attributes.get('width'), calculatedWidth, 'width', line));
+                const bodyHeight = 36 +
+                    Math.max(24, classAttributes.length * UML_ROW_HEIGHT + 8) +
+                    Math.max(24, operations.length * UML_ROW_HEIGHT + 8) +
+                    (stereotype === undefined ? 0 : 14);
+                const component = {
+                    kind,
+                    ...common,
+                    attributes: classAttributes,
+                    operations,
+                    bodyWidth,
+                    bodyHeight
+                };
+                if (stereotype !== undefined)
+                    component.stereotype = stereotype;
+                return component;
+            }
+            case 'state': {
+                assertOnlyAttributes(attributes, ['details', 'width'], line);
+                const details = parseUmlRows(attributes.get('details'), 'details', line);
+                const calculatedWidth = Math.max(112, widestUmlRow([common.label, ...details]) + 28);
+                return {
+                    kind,
+                    ...common,
+                    details,
+                    bodyWidth: Math.max(calculatedWidth, parseUmlDimension(attributes.get('width'), calculatedWidth, 'width', line)),
+                    bodyHeight: 40 + details.length * UML_ROW_HEIGHT
+                };
+            }
+            case 'usecase':
+            case 'lifeline':
+            case 'note':
+            case 'package': {
+                assertOnlyAttributes(attributes, ['width', 'height'], line);
+                const defaultWidth = Math.max(kind === 'usecase' ? 112 : 96, mathLabelTextWidth(common.label, 8) + 28);
+                const defaultHeight = kind === 'lifeline' ? 180 : kind === 'usecase' ? 56 : 64;
+                return {
+                    kind,
+                    ...common,
+                    bodyWidth: Math.max(defaultWidth, parseUmlDimension(attributes.get('width'), defaultWidth, 'width', line)),
+                    bodyHeight: Math.max(defaultHeight, parseUmlDimension(attributes.get('height'), defaultHeight, 'height', line))
+                };
+            }
+            case 'actor':
+            case 'initial':
+            case 'final':
+                assertOnlyAttributes(attributes, [], line);
+                return { kind, ...common };
+        }
+    }
     const quantumKind = kind;
     assertOnlyAttributes(attributes, quantumKind === 'qgate' ? ['parameter', 'matrix', 'phase'] : [], line);
     const component = { kind: quantumKind, ...common };
@@ -379,6 +504,26 @@ function parseComponent(match, line) {
 function parseEndpoint(componentId, port) {
     return { componentId, port };
 }
+function connectionOptionTokens(raw, line) {
+    const tokens = [];
+    let tokenStart = -1;
+    let quoteOpen = false;
+    for (let index = 0; index <= raw.length; index += 1) {
+        const character = raw[index];
+        if (character === '"')
+            quoteOpen = !quoteOpen;
+        if ((character === undefined || (/\s/.test(character) && !quoteOpen)) && tokenStart >= 0) {
+            tokens.push(raw.slice(tokenStart, index));
+            tokenStart = -1;
+        }
+        else if (character !== undefined && !/\s/.test(character) && tokenStart < 0) {
+            tokenStart = index;
+        }
+    }
+    if (quoteOpen)
+        throw new SchematicSyntaxError('Malformed quoted connection option.', line);
+    return tokens;
+}
 function parseSignalMarker(value, option, line) {
     if (!includesValue(SCHEMATIC_SIGNAL_MARKERS, value)) {
         throw new SchematicSyntaxError(`${option} must be one of: ${SCHEMATIC_SIGNAL_MARKERS.join(', ')}.`, line);
@@ -389,10 +534,14 @@ function parseConnectionOptions(raw, line) {
     let curve = 'line';
     let markerStart = 'none';
     let markerEnd = 'none';
-    if (raw === undefined || raw.trim() === '')
-        return { curve, markerStart, markerEnd };
+    let relation = 'signal';
+    let label;
+    let dashed = false;
+    if (raw === undefined || raw.trim() === '') {
+        return { curve, markerStart, markerEnd, relation, label, dashed };
+    }
     const seen = new Set();
-    for (const token of raw.trim().split(/\s+/)) {
+    for (const token of connectionOptionTokens(raw.trim(), line)) {
         if (token === 'line' || token === 'bezier' || token === 'ortho') {
             if (seen.has('curve')) {
                 throw new SchematicSyntaxError('Connection routing can only be declared once.', line);
@@ -401,6 +550,22 @@ function parseConnectionOptions(raw, line) {
             seen.add('curve');
             continue;
         }
+        if (token === 'dashed' || token === 'solid') {
+            if (seen.has('stroke-style')) {
+                throw new SchematicSyntaxError('Connection stroke style can only be declared once.', line);
+            }
+            dashed = token === 'dashed';
+            seen.add('stroke-style');
+            continue;
+        }
+        if (includesValue(UML_RELATION_KINDS, token)) {
+            if (seen.has('relation')) {
+                throw new SchematicSyntaxError('Connection relation can only be declared once.', line);
+            }
+            relation = token;
+            seen.add('relation');
+            continue;
+        }
         if (token === 'arrow' || token === 'dot') {
             if (seen.has('marker-end')) {
                 throw new SchematicSyntaxError('Connection marker-end can only be declared once.', line);
@@ -409,35 +574,84 @@ function parseConnectionOptions(raw, line) {
             seen.add('marker-end');
             continue;
         }
-        const match = token.match(/^(marker-start|marker-end)=(\S+)$/);
+        const match = token.match(/^(marker-start|marker-end|relation|label)=(.*)$/);
         if (!match) {
-            throw new SchematicSyntaxError('Connection routing options support line, bezier, ortho, arrow, dot, marker-start, and marker-end.', line);
+            throw new SchematicSyntaxError('Unsupported connection routing, marker, relation, label, or stroke option.', line);
         }
         const option = match[1];
         if (seen.has(option)) {
             throw new SchematicSyntaxError(`Connection ${option} can only be declared once.`, line);
         }
-        const marker = parseSignalMarker(match[2], option, line);
-        if (option === 'marker-start')
-            markerStart = marker;
-        else
-            markerEnd = marker;
+        let optionValue = match[2];
+        if (optionValue.startsWith('"') || optionValue.endsWith('"')) {
+            if (!(optionValue.length >= 2 && optionValue.startsWith('"') && optionValue.endsWith('"'))) {
+                throw new SchematicSyntaxError(`Malformed connection ${option}.`, line);
+            }
+            optionValue = optionValue.slice(1, -1);
+        }
+        if (option === 'relation') {
+            if (!includesValue(UML_RELATION_KINDS, optionValue)) {
+                throw new SchematicSyntaxError(`relation must be one of: ${UML_RELATION_KINDS.join(', ')}.`, line);
+            }
+            relation = optionValue;
+        }
+        else if (option === 'label') {
+            if (optionValue === '' || optionValue.length > 256) {
+                throw new SchematicSyntaxError('Connection labels require 1 through 256 characters.', line);
+            }
+            label = optionValue;
+        }
+        else {
+            const marker = parseSignalMarker(optionValue, option, line);
+            if (option === 'marker-start')
+                markerStart = marker;
+            else
+                markerEnd = marker;
+        }
         seen.add(option);
     }
-    return { curve, markerStart, markerEnd };
+    if (!seen.has('marker-start')) {
+        if (relation === 'aggregation')
+            markerStart = 'diamond';
+        else if (relation === 'composition')
+            markerStart = 'diamond-filled';
+    }
+    if (!seen.has('marker-end')) {
+        if (relation === 'generalization' || relation === 'realization')
+            markerEnd = 'triangle';
+        else if (relation === 'dependency' ||
+            relation === 'message' ||
+            relation === 'transition' ||
+            relation === 'include' ||
+            relation === 'extend') {
+            markerEnd = 'open-arrow';
+        }
+    }
+    if (!seen.has('stroke-style')) {
+        dashed = ['dependency', 'realization', 'include', 'extend'].includes(relation);
+    }
+    if (label === undefined && (relation === 'include' || relation === 'extend')) {
+        label = `«${relation}»`;
+    }
+    return { curve, markerStart, markerEnd, relation, label, dashed };
 }
 function parseConnection(match, line) {
     const tail = splitDeclarationTail(match[5], line);
     const options = parseConnectionOptions(tail.options, line);
-    return {
+    const connection = {
         from: parseEndpoint(match[1], match[2]),
         to: parseEndpoint(match[3], match[4]),
         color: parseSchematicColor(tail.color, line),
         curve: options.curve,
         markerStart: options.markerStart,
         markerEnd: options.markerEnd,
+        relation: options.relation,
+        dashed: options.dashed,
         line
     };
+    if (options.label !== undefined)
+        connection.label = options.label;
+    return connection;
 }
 function validateComponent(component, fence) {
     if (component.x < 0 ||
@@ -483,6 +697,13 @@ function validateEndpoint(endpoint, components, line) {
     if (isClassicalGate(component)) {
         valid = validGatePort(component, endpoint.port);
     }
+    else if (includesValue(UML_COMPONENT_KINDS, component.kind)) {
+        valid = ['in', 'out', 'left', 'right', 'top', 'bottom'].includes(endpoint.port);
+        if (!valid && component.kind === 'lifeline') {
+            const match = endpoint.port.match(/^(left|right)(\d+)$/);
+            valid = match !== null && Number(match[2]) <= component.bodyHeight;
+        }
+    }
     else {
         switch (component.kind) {
             case 'resistor':