schema-markdown 1.2.13 → 1.3.1

package/README.md

@@ -63,7 +63,7 @@ Validation fails if the object does not match the schema:
 try {
     validateType(modelTypes, 'Aggregation', {'numbers': [1, 2, 'asdf', 4]});
 } catch ({message}) {
-    console.assert(message === "Invalid value \"asdf\" (type 'string') for member 'numbers.2', expected type 'int'", message);
+    console.assert(message === 'Invalid value "asdf" (type "string") for member "numbers.2", expected type "int"', message);
 }
 ~~~
 
@@ -73,10 +73,16 @@ Validation also fails if a member constraint is violated:
 try {
     validateType(modelTypes, 'Aggregation', {'numbers': []});
 } catch ({message}) {
-    console.assert(message === "Invalid value [] (type 'object') for member 'numbers', expected type 'array' [len > 0]", message);
+    console.assert(message === 'Invalid value [] (type "object") for member "numbers", expected type "array" [len > 0]', message);
 }
 ~~~
 
+`validateType` validates JSON-like values. In this JavaScript implementation, date values are
+`Date` objects (time-of-day cleared), datetime values are `Date` objects, and uuid strings remain
+strings. A `Date` input is left as a `Date` (date values have time-of-day cleared). See
+[The Schema Markdown Language - Built-in Types](https://craigahobbs.github.io/schema-markdown-js/language/#built-in-types)
+for accepted JSON input formats and host-runtime behavior.
+
 
 ## Schema Documentation
 

package/lib/encode.js

@@ -108,9 +108,14 @@ export function decodeQueryString(paramStr) {
                     parent[keyParent] = obj;
                 }
 
-                // Create the index for this key
-                if (!(key in obj)) {
-                    obj[key] = null;
+                // Create the index for this key - check own properties only, and define "__proto__"
+                // directly since assignment would invoke the prototype setter
+                if (!Object.hasOwn(obj, key)) {
+                    if (key === '__proto__') {
+                        Object.defineProperty(obj, key, {'value': null, 'enumerable': true, 'writable': true, 'configurable': true});
+                    } else {
+                        obj[key] = null;
+                    }
                 }
             }
 

package/lib/parser.js

@@ -24,7 +24,7 @@ const rFindAttrs = new RegExp(`${rPartAttr}(?:\\s*,\\s*|\\s*$)`, 'g');
 const rLineCont = /\\\s*$/;
 const rComment = /^\s*(?:#-.*|#(?<doc>.*))?$/;
 const rGroup = /^group(?:\s+"(?<group>.+?)")?\s*$/;
-const rAction = new RegExp(`^action\\s+(?<id>${rPartId})`);
+const rAction = new RegExp(`^action\\s+(?<id>${rPartId})\\s*$`);
 const rPartBaseIds = `(?:\\s*\\(\\s*(?<baseIds>${rPartId}(?:\\s*,\\s*${rPartId})*)\\s*\\)\\s*)`;
 const rBaseIdsSplit = /\s*,\s*/;
 const rDefinition = new RegExp(`^(?<type>struct|union|enum)\\s+(?<id>${rPartId})${rPartBaseIds}?\\s*$`);
@@ -49,6 +49,7 @@ const rValue = new RegExp(`^\\s+(?<id>${rPartId})\\s*$`);
 const rValueQuoted = /^\s+"(?<id>.*?)"\s*$/;
 const rURL = /^\s+(?<method>[A-Za-z]+|\*)(?:\s+(?<path>\/\S*))?/;
 const rLineSplit = /\r?\n/;
+const rIndent = /^\s/;
 
 
 /**
@@ -107,7 +108,7 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
         linenum += 1;
 
         // Line continuation?
-        const linePartNoContinuation = linePart.replace(rLineCont, '');
+        const linePartNoContinuation = linePart.includes('\\') ? linePart.replace(rLineCont, '') : linePart;
         if (lineContinuation.length || linePartNoContinuation !== linePart) {
             lineContinuation.push(linePartNoContinuation);
         }
@@ -122,47 +123,49 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             line = linePart;
         }
 
-        // Match syntax
+        // Match syntax - each regex is guarded by a cheap string test that only skips it when it cannot match
+        const lineIndented = rIndent.test(line);
+        const lineTrimmed = line.trim();
         let matchName = 'comment';
-        let match = line.match(rComment);
+        let match = (lineTrimmed === '' || lineTrimmed.startsWith('#')) ? line.match(rComment) : null;
         if (match === null) {
             matchName = 'group';
-            match = line.match(rGroup);
+            match = line.startsWith('group') ? line.match(rGroup) : null;
         }
         if (match === null) {
             matchName = 'action';
-            match = line.match(rAction);
+            match = line.startsWith('action') ? line.match(rAction) : null;
         }
         if (match === null) {
             matchName = 'definition';
-            match = line.match(rDefinition);
+            match = (line.startsWith('struct') || line.startsWith('union') || line.startsWith('enum')) ? line.match(rDefinition) : null;
         }
-        if (match === null && action !== null) {
+        if (match === null && action !== null && lineIndented) {
             matchName = 'section';
             match = line.match(rSection);
         }
-        if (match === null && action !== null) {
+        if (match === null && action !== null && lineIndented) {
             matchName = 'sectionPlain';
             match = line.match(rSectionPlain);
         }
-        if (match === null && userType !== null && 'enum' in userType) {
+        if (match === null && userType !== null && 'enum' in userType && lineIndented) {
             matchName = 'value';
             match = line.match(rValue);
             if (match === null) {
                 match = line.match(rValueQuoted);
             }
         }
-        if (match === null && userType !== null && 'struct' in userType) {
+        if (match === null && userType !== null && 'struct' in userType && lineIndented) {
             matchName = 'member';
             match = line.match(rMember);
         }
-        if (match === null && urls !== null) {
+        if (match === null && urls !== null && lineIndented) {
             matchName = 'urls';
             match = line.match(rURL);
         }
         if (match === null) {
             matchName = 'typedef';
-            match = line.match(rTypedef);
+            match = line.startsWith('typedef') ? line.match(rTypedef) : null;
         }
         if (match === null) {
             matchName = null;
@@ -189,7 +192,7 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             const actionId = match.groups.id;
 
             // Action already defined?
-            if (actionId in types) {
+            if (Object.hasOwn(types, actionId)) {
                 addError(`Redefinition of action '${actionId}'`, filename, linenum);
             }
 
@@ -215,7 +218,7 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             const definitionBaseIds = match.groups.baseIds;
 
             // Type already defined?
-            if (builtinTypes.has(definitionId) || definitionId in builtinDeprecated || definitionId in types) {
+            if (builtinTypes.has(definitionId) || Object.hasOwn(builtinDeprecated, definitionId) || Object.hasOwn(types, definitionId)) {
                 addError(`Redefinition of type '${definitionId}'`, filename, linenum);
             }
 
@@ -311,8 +314,12 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             // Clear parser state
             userType = null;
 
-            // Update the parser state
+            // Update the parser state - attach urls immediately so a second empty
+            // "urls" section is detected as a redefinition (even with no URL lines)
             urls = [];
+            if (!(sectionString in action)) {
+                action[sectionString] = urls;
+            }
 
         // Enum value?
         } else if (matchName === 'value') {
@@ -383,9 +390,6 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             }
 
             // Add the URL
-            if (!('urls' in action)) {
-                action.urls = urls;
-            }
             urls.push(actionUrl);
 
         // Typedef?
@@ -393,7 +397,7 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             const definitionId = match.groups.id;
 
             // Type already defined?
-            if (builtinTypes.has(definitionId) || definitionId in builtinDeprecated || definitionId in types) {
+            if (builtinTypes.has(definitionId) || Object.hasOwn(builtinDeprecated, definitionId) || Object.hasOwn(types, definitionId)) {
                 addError(`Redefinition of type '${definitionId}'`, filename, linenum);
             }
 
@@ -429,6 +433,16 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
         }
     }
 
+    // Drop empty action urls arrays (type model requires len > 0 when present)
+    for (const userTypeIter of Object.values(types)) {
+        if ('action' in userTypeIter) {
+            const actionType = userTypeIter.action;
+            if ('urls' in actionType && actionType.urls.length === 0) {
+                delete actionType.urls;
+            }
+        }
+    }
+
     // Validate the type model, if requested
     if (validate) {
         for (const [typeName, memberName, errorMsg] of validateTypeModelErrors(types)) {
@@ -438,7 +452,7 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
                 errorLinenum = filepos[`${typeName}.${memberName}`] ?? null;
             }
             if (errorLinenum === null) {
-                errorLinenum = filepos[typeName] ?? null;
+                errorLinenum = Object.hasOwn(filepos, typeName) ? filepos[typeName] : null;
             }
             if (errorLinenum === null) {
                 errorFilename = '';
@@ -516,7 +530,7 @@ function parseTypedef(matchTypedef) {
 
 // Helper function to create a type model
 function createType(typeName) {
-    if (typeName in builtinDeprecated) {
+    if (Object.hasOwn(builtinDeprecated, typeName)) {
         return {'builtin': builtinDeprecated[typeName]};
     }
     if (builtinTypes.has(typeName)) {

package/lib/schema.js

@@ -39,9 +39,9 @@ function getReferencedTypesHelper(types, type, referencedTypes) {
         const typeName = type.user;
 
         // Already encountered?
-        if (!(typeName in referencedTypes)) {
-            const userType = types[typeName];
-            referencedTypes[typeName] = userType;
+        if (!Object.hasOwn(referencedTypes, typeName)) {
+            const userType = getUserType(types, typeName);
+            setValue(referencedTypes, typeName, userType);
 
             // Struct?
             if ('struct' in userType) {
@@ -116,10 +116,37 @@ export class ValidationError extends Error {
 }
 
 
+// Helper to look up a user type by name - throws ValidationError for unknown type names
+function getUserType(types, typeName) {
+    const userType = Object.hasOwn(types, typeName) ? types[typeName] : null;
+    if (userType === null) {
+        throw new ValidationError(`Unknown type "${typeName}"`);
+    }
+    return userType;
+}
+
+
+// Helper to set an own property on a plain-object copy - the "__proto__" key is defined directly
+// since assignment would invoke the inherited prototype setter instead of creating an own property
+function setValue(obj, key, value) {
+    if (key === '__proto__') {
+        Object.defineProperty(obj, key, {'value': value, 'enumerable': true, 'writable': true, 'configurable': true});
+    } else {
+        obj[key] = value;
+    }
+}
+
+
 /**
  * Type-validate a value using a user type model. Container values are duplicated since some member types are
  * transformed during validation.
  *
+ * Validates JSON-like values. In this implementation, date values are `Date` objects (time-of-day
+ * cleared), datetime values are `Date` objects, and uuid strings remain strings. A `Date` input is
+ * left as a `Date` (date values have time-of-day cleared). See the language documentation on
+ * [built-in types]{@link https://craigahobbs.github.io/schema-markdown-js/language/#built-in-types}
+ * for accepted JSON input formats and host-runtime behavior.
+ *
  * @param {Object} types - The [type model]{@link https://craigahobbs.github.io/bare-script/model/#var.vURL=''&var.vName='Types'}
  * @param {string} typeName - The type name
  * @param {Object} value - The value object to validate
@@ -128,16 +155,18 @@ export class ValidationError extends Error {
  * @throws [ValidationError]{@link module:lib/schema.ValidationError}
  */
 export function validateType(types, typeName, value, memberFqn = null) {
-    if (!(typeName in types)) {
-        throw new ValidationError(`Unknown type '${typeName}'`);
-    }
     return validateTypeHelper(types, {'user': typeName}, value, memberFqn);
 }
 
 
 // Regular expressions used by validateTypeHelper
 const rDate = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/;
-const rDatetime = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:\d{2})$/;
+const rDatetime = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/;
+const rUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+
+// Default dict key type used by validateTypeHelper
+const defaultDictKeyType = {'builtin': 'string'};
 
 
 function validateTypeHelper(types, type, value, memberFqn) {
@@ -147,18 +176,13 @@ function validateTypeHelper(types, type, value, memberFqn) {
     if ('builtin' in type) {
         const {builtin} = type;
 
-        // string or uuid?
-        if (builtin === 'string' || builtin === 'uuid') {
+        // string?
+        if (builtin === 'string') {
             // Not a string?
             if (typeof value !== 'string') {
                 throwMemberError(type, value, memberFqn);
             }
 
-            // Not a valid UUID?
-            if (builtin === 'uuid' && !value.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i)) {
-                throwMemberError(type, value, memberFqn);
-            }
-
         // int or float?
         } else if (builtin === 'int' || builtin === 'float') {
             // Convert string?
@@ -195,31 +219,61 @@ function validateTypeHelper(types, type, value, memberFqn) {
                 throwMemberError(type, value, memberFqn);
             }
 
-        // date or datetime?
-        } else if (builtin === 'date' || builtin === 'datetime') {
+        // date?
+        } else if (builtin === 'date') {
             // Convert string?
             if (typeof value === 'string') {
-                // Valid date format?
+                // Date-only?
                 const mDate = value.match(rDate);
                 if (mDate !== null) {
                     const year = Number.parseInt(mDate.groups.year, 10);
                     const month = Number.parseInt(mDate.groups.month, 10);
                     const day = Number.parseInt(mDate.groups.day, 10);
                     valueNew = new Date(year, month - 1, day);
-                } else if (rDatetime.test(value)) {
+                    // new Date rolls an out-of-range month/day over (e.g. Feb 30 -> Mar 1); reject that
+                    if (valueNew.getMonth() !== month - 1) {
+                        throwMemberError(type, value, memberFqn);
+                    }
+                } else {
+                    throwMemberError(type, value, memberFqn);
+                }
+
+            // Not a date, or a date with a time-of-day?
+            } else if (!(value instanceof Date) ||
+                value.getHours() + value.getMinutes() + value.getSeconds() + value.getMilliseconds() !== 0) {
+                throwMemberError(type, value, memberFqn);
+            }
+
+        // datetime?
+        } else if (builtin === 'datetime') {
+            // Convert string?
+            if (typeof value === 'string') {
+                const mDatetime = value.match(rDatetime);
+                if (mDatetime !== null) {
                     valueNew = new Date(value);
+                    const year = Number.parseInt(mDatetime.groups.year, 10);
+                    const month = Number.parseInt(mDatetime.groups.month, 10);
+                    const day = Number.parseInt(mDatetime.groups.day, 10);
+                    // new Date rolls an out-of-range day over (e.g. Feb 30 -> Mar 1); reject that
+                    if (Number.isNaN(valueNew.getTime()) || new Date(year, month - 1, day).getMonth() !== month - 1) {
+                        throwMemberError(type, value, memberFqn);
+                    }
                 } else {
                     throwMemberError(type, value, memberFqn);
                 }
 
-            // Not a date?
+            // Not a datetime?
             } else if (!(value instanceof Date)) {
                 throwMemberError(type, value, memberFqn);
             }
 
-            // For date type, clear hours, minutes, seconds, and milliseconds
-            if (builtin === 'date') {
-                valueNew = new Date(valueNew.getFullYear(), valueNew.getMonth(), valueNew.getDate());
+        // uuid?
+        } else if (builtin === 'uuid') {
+            if (typeof value !== 'string') {
+                throwMemberError(type, value, memberFqn);
+            }
+            if (!rUuid.test(value)) {
+                throwMemberError(type, value, memberFqn);
             }
         }
 
@@ -239,13 +293,15 @@ function validateTypeHelper(types, type, value, memberFqn) {
         const valueCopy = [];
         const arrayValueNullable = arrayAttr !== null && 'nullable' in arrayAttr && arrayAttr.nullable;
         for (let ixArrayValue = 0; ixArrayValue < valueNew.length; ixArrayValue++) {
-            const memberFqnValue = memberFqn !== null ? `${memberFqn}.${ixArrayValue}` : `${ixArrayValue}`;
+            const memberFqnValue = [memberFqn, ixArrayValue];
             let arrayValue = valueNew[ixArrayValue];
             if (arrayValueNullable && (arrayValue === null || arrayValue === 'null')) {
                 arrayValue = null;
             } else {
                 arrayValue = validateTypeHelper(types, arrayType, arrayValue, memberFqnValue);
-                validateAttr(arrayType, arrayAttr, arrayValue, memberFqnValue);
+                if (arrayAttr !== null) {
+                    validateAttr(arrayType, arrayAttr, arrayValue, memberFqnValue);
+                }
             }
             valueCopy.push(arrayValue);
         }
@@ -259,27 +315,30 @@ function validateTypeHelper(types, type, value, memberFqn) {
         const {dict} = type;
         const dictType = dict.type;
         const dictAttr = 'attr' in dict ? dict.attr : null;
-        const dictKeyType = 'keyType' in dict ? dict.keyType : {'builtin': 'string'};
+        const dictKeyType = 'keyType' in dict ? dict.keyType : defaultDictKeyType;
         const dictKeyAttr = 'keyAttr' in dict ? dict.keyAttr : null;
         if (value === '') {
             valueNew = {};
-        } else if (value === null || typeof value !== 'object') {
+        } else if (value === null || typeof value !== 'object' || Array.isArray(value)) {
             throwMemberError(type, value, memberFqn);
         }
 
         // Validate the dict key/value pairs
-        const valueCopy = valueNew instanceof Map ? new Map() : {};
+        const isMap = valueNew instanceof Map;
+        const valueCopy = isMap ? new Map() : {};
         const dictKeyNullable = dictKeyAttr !== null && 'nullable' in dictKeyAttr && dictKeyAttr.nullable;
         const dictValueNullable = dictAttr !== null && 'nullable' in dictAttr && dictAttr.nullable;
-        for (let [dictKey, dictValue] of (valueNew instanceof Map ? valueNew.entries() : Object.entries(valueNew))) {
-            const memberFqnKey = memberFqn !== null ? `${memberFqn}.${dictKey}` : `${dictKey}`;
+        for (let [dictKey, dictValue] of (isMap ? valueNew.entries() : Object.entries(valueNew))) {
+            const memberFqnKey = [memberFqn, dictKey];
 
             // Validate the key
             if (dictKeyNullable && (dictKey === null || dictKey === 'null')) {
                 dictKey = null;
             } else {
                 dictKey = validateTypeHelper(types, dictKeyType, dictKey, memberFqn);
-                validateAttr(dictKeyType, dictKeyAttr, dictKey, memberFqn);
+                if (dictKeyAttr !== null) {
+                    validateAttr(dictKeyType, dictKeyAttr, dictKey, memberFqn);
+                }
             }
 
             // Validate the value
@@ -287,14 +346,16 @@ function validateTypeHelper(types, type, value, memberFqn) {
                 dictValue = null;
             } else {
                 dictValue = validateTypeHelper(types, dictType, dictValue, memberFqnKey);
-                validateAttr(dictType, dictAttr, dictValue, memberFqnKey);
+                if (dictAttr !== null) {
+                    validateAttr(dictType, dictAttr, dictValue, memberFqnKey);
+                }
             }
 
             // Copy the key/value
-            if (valueCopy instanceof Map) {
+            if (isMap) {
                 valueCopy.set(dictKey, dictValue);
             } else {
-                valueCopy[dictKey] = dictValue;
+                setValue(valueCopy, dictKey, dictValue);
             }
         }
 
@@ -303,7 +364,7 @@ function validateTypeHelper(types, type, value, memberFqn) {
 
     // User type?
     } else if ('user' in type) {
-        const userType = types[type.user];
+        const userType = getUserType(types, type.user);
 
         // action?
         if ('action' in userType) {
@@ -321,7 +382,9 @@ function validateTypeHelper(types, type, value, memberFqn) {
                 valueNew = null;
             } else {
                 valueNew = validateTypeHelper(types, typedef.type, value, memberFqn);
-                validateAttr(type, typedefAttr, valueNew, memberFqn);
+                if (typedefAttr !== null) {
+                    validateAttr(type, typedefAttr, valueNew, memberFqn);
+                }
             }
 
         // enum?
@@ -340,58 +403,64 @@ function validateTypeHelper(types, type, value, memberFqn) {
             // Valid value type?
             if (value === '') {
                 valueNew = {};
-            } else if (value === null || typeof value !== 'object') {
+            } else if (value === null || typeof value !== 'object' || Array.isArray(value)) {
                 throwMemberError({'user': struct.name}, value, memberFqn);
             }
 
             // Valid union?
+            const isMap = valueNew instanceof Map;
             const isUnion = 'union' in struct ? struct.union : false;
             if (isUnion) {
-                if (Object.keys(value).length !== 1) {
+                if ((isMap ? valueNew.size : Object.keys(valueNew).length) !== 1) {
                     throwMemberError({'user': struct.name}, value, memberFqn);
                 }
             }
 
             // Validate the struct members
-            const valueCopy = valueNew instanceof Map ? new Map() : {};
+            const valueCopy = isMap ? new Map() : {};
             for (const member of getStructMembers(types, struct)) {
                 const memberName = member.name;
-                const memberFqnMember = memberFqn !== null ? `${memberFqn}.${memberName}` : `${memberName}`;
+                const memberFqnMember = [memberFqn, memberName];
                 const memberOptional = 'optional' in member && member.optional;
-                const memberNullable = 'attr' in member && 'nullable' in member.attr && member.attr.nullable;
+                const memberAttr = 'attr' in member ? member.attr : null;
+                const memberNullable = memberAttr !== null && 'nullable' in memberAttr && memberAttr.nullable;
 
-                // Missing non-optional member?
-                if (!(valueNew instanceof Map ? valueNew.has(memberName) : memberName in valueNew)) {
+                // Missing non-optional member? Check own properties only - "in" matches inherited
+                // Object.prototype properties for member names like "constructor"
+                if (!(isMap ? valueNew.has(memberName) : Object.hasOwn(valueNew, memberName))) {
                     if (!memberOptional && !isUnion) {
-                        throw new ValidationError(`Required member '${memberFqnMember}' missing`);
+                        throw new ValidationError(`Required member "${memberFqnStr(memberFqnMember)}" missing`);
                     }
                 } else {
                     // Validate the member value
-                    let memberValue = valueNew instanceof Map ? valueNew.get(memberName) : valueNew[memberName];
+                    let memberValue = isMap ? valueNew.get(memberName) : valueNew[memberName];
                     if (memberNullable && (memberValue === null || memberValue === 'null')) {
                         memberValue = null;
                     } else {
                         memberValue = validateTypeHelper(types, member.type, memberValue, memberFqnMember);
-                        validateAttr(member.type, 'attr' in member ? member.attr : null, memberValue, memberFqnMember);
+                        if (memberAttr !== null) {
+                            validateAttr(member.type, memberAttr, memberValue, memberFqnMember);
+                        }
                     }
 
                     // Copy the validated member
-                    if (valueCopy instanceof Map) {
+                    if (isMap) {
                         valueCopy.set(memberName, memberValue);
                     } else {
-                        valueCopy[memberName] = memberValue;
+                        setValue(valueCopy, memberName, memberValue);
                     }
                 }
             }
 
             // Any unknown members?
-            const valueCopyKeys = valueCopy instanceof Map ? Array.from(valueCopy.keys()) : Object.keys(valueCopy);
-            const valueNewKeys = valueNew instanceof Map ? Array.from(valueNew.keys()) : Object.keys(valueNew);
-            if (valueCopyKeys.length !== valueNewKeys.length) {
+            const valueCopyCount = isMap ? valueCopy.size : Object.keys(valueCopy).length;
+            const valueNewCount = isMap ? valueNew.size : Object.keys(valueNew).length;
+            if (valueCopyCount !== valueNewCount) {
                 const memberSet = new Set(getStructMembers(types, struct).map((member) => member.name));
+                const valueNewKeys = isMap ? Array.from(valueNew.keys()) : Object.keys(valueNew);
                 const [unknownKey] = valueNewKeys.filter((key) => !memberSet.has(key));
-                const unknownFqn = memberFqn !== null ? `${memberFqn}.${unknownKey}` : `${unknownKey}`;
-                throw new ValidationError(`Unknown member '${unknownFqn.slice(0, 100)}'`);
+                const unknownFqn = memberFqnStr([memberFqn, unknownKey]);
+                throw new ValidationError(`Unknown member "${unknownFqn.slice(0, 100)}"`);
             }
 
             // Return the validated, transformed copy
@@ -403,36 +472,56 @@ function validateTypeHelper(types, type, value, memberFqn) {
 }
 
 
+// Helper to materialize a member's fully-qualified name string. For performance, member FQNs are
+// built lazily as [parent, key] pairs and only converted to strings on error.
+function memberFqnStr(memberFqn) {
+    if (memberFqn === null || typeof memberFqn === 'string') {
+        return memberFqn;
+    }
+    const parts = [];
+    let fqnPart = memberFqn;
+    while (Array.isArray(fqnPart)) {
+        parts.push(`${fqnPart[1]}`);
+        [fqnPart] = fqnPart;
+    }
+    if (fqnPart !== null) {
+        parts.push(`${fqnPart}`);
+    }
+    parts.reverse();
+    return parts.join('.');
+}
+
+
 function throwMemberError(type, value, memberFqn, attr = null) {
-    const memberPart = memberFqn !== null ? ` for member '${memberFqn}'` : '';
+    const memberFqnValue = memberFqnStr(memberFqn);
+    const memberPart = memberFqnValue ? ` for member "${memberFqnValue}"` : '';
     const typeName = 'builtin' in type ? type.builtin : ('array' in type ? 'array' : ('dict' in type ? 'dict' : type.user));
     const attrPart = attr !== null ? ` [${attr}]` : '';
     const valueStr = `${JSON.stringify(value)}`;
-    const msg = `Invalid value ${valueStr.slice(0, 100)} (type '${typeof value}')${memberPart}, expected type '${typeName}'${attrPart}`;
-    throw new ValidationError(msg, memberFqn);
+    const msg = `Invalid value ${valueStr.slice(0, 100)} (type "${typeof value}")${memberPart}, expected type "${typeName}"${attrPart}`;
+    throw new ValidationError(msg, memberFqnValue);
 }
 
 
 function validateAttr(type, attr, value, memberFqn) {
-    if (attr !== null) {
+    if ('eq' in attr && !(value === attr.eq)) {
+        throwMemberError(type, value, memberFqn, `== ${attr.eq}`);
+    }
+    if ('lt' in attr && !(value < attr.lt)) {
+        throwMemberError(type, value, memberFqn, `< ${attr.lt}`);
+    }
+    if ('lte' in attr && !(value <= attr.lte)) {
+        throwMemberError(type, value, memberFqn, `<= ${attr.lte}`);
+    }
+    if ('gt' in attr && !(value > attr.gt)) {
+        throwMemberError(type, value, memberFqn, `> ${attr.gt}`);
+    }
+    if ('gte' in attr && !(value >= attr.gte)) {
+        throwMemberError(type, value, memberFqn, `>= ${attr.gte}`);
+    }
+    if ('lenEq' in attr || 'lenLT' in attr || 'lenLTE' in attr || 'lenGT' in attr || 'lenGTE' in attr) {
         const length = Array.isArray(value) || typeof value === 'string' ? value.length
-            : (typeof value === 'object' ? Object.keys(value).length : null);
-
-        if ('eq' in attr && !(value === attr.eq)) {
-            throwMemberError(type, value, memberFqn, `== ${attr.eq}`);
-        }
-        if ('lt' in attr && !(value < attr.lt)) {
-            throwMemberError(type, value, memberFqn, `< ${attr.lt}`);
-        }
-        if ('lte' in attr && !(value <= attr.lte)) {
-            throwMemberError(type, value, memberFqn, `<= ${attr.lte}`);
-        }
-        if ('gt' in attr && !(value > attr.gt)) {
-            throwMemberError(type, value, memberFqn, `> ${attr.gt}`);
-        }
-        if ('gte' in attr && !(value >= attr.gte)) {
-            throwMemberError(type, value, memberFqn, `>= ${attr.gte}`);
-        }
+            : (value instanceof Map ? value.size : (typeof value === 'object' ? Object.keys(value).length : null));
         if ('lenEq' in attr && !(length === attr.lenEq)) {
             throwMemberError(type, value, memberFqn, `len == ${attr.lenEq}`);
         }
@@ -469,9 +558,9 @@ export function getStructMembers(types, struct) {
     // Get base struct members
     const members = [];
     for (const base of struct.bases) {
-        let baseUserType = types[base];
+        let baseUserType = getUserType(types, base);
         while ('typedef' in baseUserType) {
-            baseUserType = types[baseUserType.typedef.type.user];
+            baseUserType = getUserType(types, baseUserType.typedef.type.user);
         }
         members.push(...getStructMembers(types, baseUserType.struct));
     }
@@ -502,9 +591,9 @@ export function getEnumValues(types, enum_) {
     // Get base enum values
     const values = [];
     for (const base of enum_.bases) {
-        let baseUserType = types[base];
+        let baseUserType = getUserType(types, base);
         while ('typedef' in baseUserType) {
-            baseUserType = types[baseUserType.typedef.type.user];
+            baseUserType = getUserType(types, baseUserType.typedef.type.user);
         }
         values.push(...getEnumValues(types, baseUserType.enum));
     }
@@ -532,6 +621,23 @@ export function validateTypeModel(types) {
     // Do additional type model validation
     const errors = validateTypeModelErrors(validatedTypes);
     if (errors.length) {
+        // Sort by (typeName, memberName, message); null memberName as ''
+        errors.sort((errorA, errorB) => {
+            let result = 0;
+            for (let ixPart = 0; ixPart < 3; ixPart++) {
+                const partA = errorA[ixPart] ?? '';
+                const partB = errorB[ixPart] ?? '';
+                if (partA < partB) {
+                    result = -1;
+                    break;
+                }
+                if (partA > partB) {
+                    result = 1;
+                    break;
+                }
+            }
+            return result;
+        });
         throw new ValidationError(errors.map(([,, message]) => message).join('\n'));
     }
 

package/lib/schemaUtil.js

@@ -21,7 +21,7 @@ export function validateTypeModelErrors(types) {
 
             // Inconsistent type name?
             if (typeName !== struct.name) {
-                errors.push([typeName, null, `Inconsistent type name '${struct.name}' for '${typeName}'`]);
+                errors.push([typeName, null, `Inconsistent type name "${struct.name}" for "${typeName}"`]);
             }
 
             // Check base types
@@ -36,29 +36,29 @@ export function validateTypeModelErrors(types) {
                         }
                     }
                     if (invalidBase) {
-                        errors.push([typeName, null, `Invalid struct base type '${baseName}'`]);
+                        errors.push([typeName, null, `Invalid struct base type "${baseName}"`]);
                     }
                 }
             }
 
             // Iterate the members
             try {
-                const members = {};
+                const members = new Set();
                 for (const member of getStructMembers(types, struct)) {
                     const memberName = member.name;
 
                     // Duplicate member?
-                    if (!(memberName in members)) {
-                        members[memberName] = true;
+                    if (!members.has(memberName)) {
+                        members.add(memberName);
                     } else {
-                        errors.push([typeName, memberName, `Redefinition of '${typeName}' member '${memberName}'`]);
+                        errors.push([typeName, memberName, `Redefinition of "${typeName}" member "${memberName}"`]);
                     }
 
                     // Check member type and attributes
                     validateTypeModelType(errors, types, member.type, 'attr' in member ? member.attr : null, struct.name, member.name);
                 }
             } catch {
-                errors.push([typeName, null, `Circular base type detected for type '${typeName}'`]);
+                errors.push([typeName, null, `Circular base type detected for type "${typeName}"`]);
             }
 
         // Enum?
@@ -67,7 +67,7 @@ export function validateTypeModelErrors(types) {
 
             // Inconsistent type name?
             if (typeName !== enum_.name) {
-                errors.push([typeName, null, `Inconsistent type name '${enum_.name}' for '${typeName}'`]);
+                errors.push([typeName, null, `Inconsistent type name "${enum_.name}" for "${typeName}"`]);
             }
 
             // Check base types
@@ -75,26 +75,26 @@ export function validateTypeModelErrors(types) {
                 for (const baseName of enum_.bases) {
                     const baseUserType = getEffectiveUserType(types, baseName);
                     if (baseUserType === null || !('enum' in baseUserType)) {
-                        errors.push([typeName, null, `Invalid enum base type '${baseName}'`]);
+                        errors.push([typeName, null, `Invalid enum base type "${baseName}"`]);
                     }
                 }
             }
 
             // Get the enumeration values
             try {
-                const values = {};
+                const values = new Set();
                 for (const value of getEnumValues(types, enum_)) {
                     const valueName = value.name;
 
                     // Duplicate value?
-                    if (!(valueName in values)) {
-                        values[valueName] = true;
+                    if (!values.has(valueName)) {
+                        values.add(valueName);
                     } else {
-                        errors.push([typeName, valueName, `Redefinition of '${typeName}' value '${valueName}'`]);
+                        errors.push([typeName, valueName, `Redefinition of "${typeName}" value "${valueName}"`]);
                     }
                 }
             } catch {
-                errors.push([typeName, null, `Circular base type detected for type '${typeName}'`]);
+                errors.push([typeName, null, `Circular base type detected for type "${typeName}"`]);
             }
 
         // Typedef?
@@ -103,7 +103,7 @@ export function validateTypeModelErrors(types) {
 
             // Inconsistent type name?
             if (typeName !== typedef.name) {
-                errors.push([typeName, null, `Inconsistent type name '${typedef.name}' for '${typeName}'`]);
+                errors.push([typeName, null, `Inconsistent type name "${typedef.name}" for "${typeName}"`]);
             }
 
             // Check the type and its attributes
@@ -115,7 +115,7 @@ export function validateTypeModelErrors(types) {
 
             // Inconsistent type name?
             if (typeName !== action.name) {
-                errors.push([typeName, null, `Inconsistent type name '${action.name}' for '${typeName}'`]);
+                errors.push([typeName, null, `Inconsistent type name "${action.name}" for "${typeName}"`]);
             }
 
             // Check action section types
@@ -129,11 +129,11 @@ export function validateTypeModelErrors(types) {
             }
 
             // Compute effective input member counts
-            const memberSections = {};
+            const memberSections = new Map();
             for (const section of ['path', 'query', 'input']) {
                 if (section in action) {
                     const sectionTypeName = action[section];
-                    if (sectionTypeName in types) {
+                    if (Object.hasOwn(types, sectionTypeName)) {
                         const sectionUserType = getEffectiveUserType(types, sectionTypeName);
                         if (sectionUserType !== null && 'struct' in sectionUserType) {
                             const sectionStruct = sectionUserType.struct;
@@ -142,10 +142,10 @@ export function validateTypeModelErrors(types) {
                             try {
                                 for (const member of getStructMembers(types, sectionStruct)) {
                                     const memberName = member.name;
-                                    if (!(memberName in memberSections)) {
-                                        memberSections[memberName] = [];
+                                    if (!memberSections.has(memberName)) {
+                                        memberSections.set(memberName, []);
                                     }
-                                    memberSections[memberName].push(sectionStruct.name);
+                                    memberSections.get(memberName).push(sectionStruct.name);
                                 }
                             } catch {
                                 // Do nothing
@@ -156,10 +156,10 @@ export function validateTypeModelErrors(types) {
             }
 
             // Check for duplicate input members
-            for (const [memberName, memberSectionNames] of Object.entries(memberSections)) {
+            for (const [memberName, memberSectionNames] of memberSections.entries()) {
                 if (memberSectionNames.length > 1) {
                     for (const sectionType of memberSectionNames.sort()) {
-                        errors.push([sectionType, memberName, `Redefinition of '${sectionType}' member '${memberName}'`]);
+                        errors.push([sectionType, memberName, `Redefinition of "${sectionType}" member "${memberName}"`]);
                     }
                 }
             }
@@ -171,7 +171,7 @@ export function validateTypeModelErrors(types) {
 
 
 function getEffectiveType(types, type) {
-    if ('user' in type && type.user in types) {
+    if ('user' in type && Object.hasOwn(types, type.user)) {
         const userType = types[type.user];
         if ('typedef' in userType) {
             return getEffectiveType(types, userType.typedef.type);
@@ -182,24 +182,24 @@ function getEffectiveType(types, type) {
 
 
 function getEffectiveUserType(types, userTypeName) {
-    const userType = userTypeName in types ? types[userTypeName] : null;
+    const userType = Object.hasOwn(types, userTypeName) ? types[userTypeName] : null;
     if (userType !== null && 'typedef' in userType) {
         const typeEffective = getEffectiveType(types, userType.typedef.type);
         if (!('user' in typeEffective)) {
             return null;
         }
-        return typeEffective.user in types ? types[typeEffective.user] : null;
+        return Object.hasOwn(types, typeEffective.user) ? types[typeEffective.user] : null;
     }
     return userType;
 }
 
 
-function getStructMembers(types, struct, visited = {}) {
+function getStructMembers(types, struct, visited = new Set()) {
     return getTypeItems(types, struct, visited, 'struct', 'members');
 }
 
 
-function getEnumValues(types, enum_, visited = {}) {
+function getEnumValues(types, enum_, visited = new Set()) {
     return getTypeItems(types, enum_, visited, 'enum', 'values');
 }
 
@@ -211,8 +211,8 @@ function getTypeItems(types, type, visited, defName, memberName) {
             const userType = getEffectiveUserType(types, base);
             if (userType !== null && defName in userType) {
                 const userTypeName = userType[defName].name;
-                if (!(userTypeName in visited)) {
-                    visited[userTypeName] = true;
+                if (!visited.has(userTypeName)) {
+                    visited.add(userTypeName);
                     items.push(...getTypeItems(types, userType[defName], visited, defName, memberName));
                 } else {
                     throw new TypeError();
@@ -256,9 +256,9 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
     // Helper function to push an error tuple
     const error = (message) => {
         if (memberName !== null) {
-            errors.push([typeName, memberName, `${message} from '${typeName}' member '${memberName}'`]);
+            errors.push([typeName, memberName, `${message} from "${typeName}" member "${memberName}"`]);
         } else {
-            errors.push([typeName, null, `${message} from '${typeName}'`]);
+            errors.push([typeName, null, `${message} from "${typeName}"`]);
         }
     };
 
@@ -285,7 +285,7 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
 
             // Valid dict key type (string or enum)
             if (!('builtin' in dictKeyType && dictKeyType.builtin === 'string') &&
-                !('user' in dictKeyType && dictKeyType.user in types && 'enum' in types[dictKeyType.user])) {
+                !('user' in dictKeyType && Object.hasOwn(types, dictKeyType.user) && 'enum' in types[dictKeyType.user])) {
                 error('Invalid dictionary key type');
             }
         }
@@ -295,14 +295,14 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
         const userTypeName = type.user;
 
         // Unknown user type?
-        if (!(userTypeName in types)) {
-            error(`Unknown type '${userTypeName}'`);
+        if (!Object.hasOwn(types, userTypeName)) {
+            error(`Unknown type "${userTypeName}"`);
         } else {
             const userType = types[userTypeName];
 
             // Action type references not allowed
             if ('action' in userType) {
-                error(`Invalid reference to action '${userTypeName}'`);
+                error(`Invalid reference to action "${userTypeName}"`);
             }
         }
     }
@@ -312,7 +312,7 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
         const typeEffective = getEffectiveType(types, type);
         const [typeKey] = Object.keys(typeEffective);
         const typeAttrKey = typeKey === 'builtin' ? typeEffective[typeKey] : typeKey;
-        const allowedAttr = typeAttrKey in typeToAllowedAttr ? typeToAllowedAttr[typeAttrKey] : null;
+        const allowedAttr = Object.hasOwn(typeToAllowedAttr, typeAttrKey) ? typeToAllowedAttr[typeAttrKey] : null;
         const disallowedAttr = Object.fromEntries(Object.keys(attr).map((attrKey) => [attrKey, null]));
         delete disallowedAttr.nullable;
         if (allowedAttr !== null) {
@@ -324,7 +324,7 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
             for (const attrKey of Object.keys(disallowedAttr)) {
                 const attrValue = `${attr[attrKey]}`;
                 const attrText = `${attrToText[attrKey]} ${attrValue}`;
-                error(`Invalid attribute '${attrText}'`);
+                error(`Invalid attribute "${attrText}"`);
             }
         }
     }

package/lib/typeModel.js

@@ -108,16 +108,16 @@ struct Array
 # A dictionary type
 struct Dict
 
-    # The contained key type
+    # The contained value type
     Type type
 
-    # The contained key type's attributes
+    # The contained value type's attributes
     optional Attributes attr
 
-    # The contained value type
+    # The contained key type
     optional Type keyType
 
-    # The contained value type's attributes
+    # The contained key type's attributes
     optional Attributes keyAttr
 
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "schema-markdown",
-    "version": "1.2.13",
+    "version": "1.3.1",
     "description": "A schema definition and validation library",
     "keywords": [
         "schema",
@@ -26,8 +26,8 @@
     "devDependencies": {
         "@eslint/js": "~10.0",
         "c8": "~11.0",
-        "eslint": "~10.1",
-        "globals": "~17.4",
+        "eslint": "~10.6",
+        "globals": "~17.7",
         "jsdoc": "~4.0"
     }
 }