cddl 0.14.10 → 0.15.0

package/build/index.d.ts

@@ -7,4 +7,5 @@ declare const _default: {
 export default _default;
 export { Lexer, Parser };
 export * from './ast.js';
+export * from './utils.js';
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAA;AAC9B,OAAO,MAAM,MAAM,aAAa,CAAA;AAEhC,wBAAgB,KAAK,CAAE,QAAQ,EAAE,MAAM,mCAGtC;;;;AAED,wBAAwB;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAA;AACxB,cAAc,UAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAA;AAC9B,OAAO,MAAM,MAAM,aAAa,CAAA;AAEhC,wBAAgB,KAAK,CAAE,QAAQ,EAAE,MAAM,mCAGtC;;;;AAED,wBAAwB;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA"}

package/build/index.js

@@ -7,3 +7,4 @@ export function parse(filePath) {
 export default { parse };
 export { Lexer, Parser };
 export * from './ast.js';
+export * from './utils.js';

package/build/utils.d.ts

@@ -1,7 +1,26 @@
+import type { Assignment, Array as CDDLArray, Group, NativeTypeWithOperator, Property, PropertyReference, Variable } from './ast.js';
 import { Token } from './tokens.js';
 export declare function isLetter(ch: string): boolean;
 export declare function isAlphabeticCharacter(ch: string): boolean;
 export declare function isDigit(ch: string): boolean;
 export declare function hasSpecialNumberCharacter(ch: number): boolean;
 export declare function parseNumberValue(token: Token): string | number;
+export declare function pascalCase(name: string): string;
+export declare function isVariable(assignment: Assignment): assignment is Variable;
+export declare function isGroup(t: any): t is Group;
+export declare function isCDDLArray(t: any): t is CDDLArray;
+export declare function isProperty(t: any): t is Property;
+export declare function isUnNamedProperty(t: any): t is Property & {
+    Name: '';
+};
+export declare function isNamedGroupReference(t: any): t is PropertyReference & {
+    Value: string;
+};
+export declare function isPropertyReference(t: any): t is PropertyReference;
+export declare function isNativeTypeWithOperator(t: any): t is NativeTypeWithOperator;
+export declare function isRange(t: any): boolean;
+export declare function isLiteralWithValue(t: any): t is {
+    Type: 'literal';
+    Value: unknown;
+};
 //# sourceMappingURL=utils.d.ts.map

package/build/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,EAAE,MAAM,aAAa,CAAA;AAE3C,wBAAgB,QAAQ,CAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED,wBAAgB,qBAAqB,CAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,OAAO,CAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED,wBAAgB,yBAAyB,CAAE,EAAE,EAAE,MAAM,WAOpD;AAED,wBAAgB,gBAAgB,CAAE,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAa/D"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACR,UAAU,EACV,KAAK,IAAI,SAAS,EAClB,KAAK,EACL,sBAAsB,EACtB,QAAQ,EACR,iBAAiB,EACjB,QAAQ,EACX,MAAM,UAAU,CAAA;AAEjB,OAAO,EAAU,KAAK,EAAE,MAAM,aAAa,CAAA;AAE3C,wBAAgB,QAAQ,CAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED,wBAAgB,qBAAqB,CAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,OAAO,CAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED,wBAAgB,yBAAyB,CAAE,EAAE,EAAE,MAAM,WAOpD;AAED,wBAAgB,gBAAgB,CAAE,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAa/D;AAED,wBAAgB,UAAU,CAAE,IAAI,EAAE,MAAM,UAEvC;AAED,wBAAgB,UAAU,CAAE,UAAU,EAAE,UAAU,GAAG,UAAU,IAAI,QAAQ,CAE1E;AAED,wBAAgB,OAAO,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,KAAK,CAE3C;AAED,wBAAgB,WAAW,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,UAAU,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,QAAQ,CAEjD;AAED,wBAAgB,iBAAiB,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,QAAQ,GAAG;IAAE,IAAI,EAAE,EAAE,CAAA;CAAE,CAEvE;AAED,wBAAgB,qBAAqB,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,iBAAiB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAEzF;AAED,wBAAgB,mBAAmB,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,iBAAiB,CAEnE;AAED,wBAAgB,wBAAwB,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,sBAAsB,CAE7E;AAED,wBAAgB,OAAO,CAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CAExC;AAED,wBAAgB,kBAAkB,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI;IAC9C,IAAI,EAAE,SAAS,CAAA;IACf,KAAK,EAAE,OAAO,CAAA;CACjB,CAEA"}

package/build/utils.js

@@ -1,3 +1,4 @@
+import camelcase from 'camelcase';
 import { Tokens } from './tokens.js';
 export function isLetter(ch) {
     return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z';
@@ -24,3 +25,36 @@ export function parseNumberValue(token) {
     }
     return parseInt(token.Literal, 10);
 }
+export function pascalCase(name) {
+    return camelcase(name, { pascalCase: true });
+}
+export function isVariable(assignment) {
+    return assignment.Type === 'variable';
+}
+export function isGroup(t) {
+    return t && t.Type === 'group';
+}
+export function isCDDLArray(t) {
+    return t && t.Type === 'array';
+}
+export function isProperty(t) {
+    return t && typeof t.Name === 'string' && typeof t.HasCut === 'boolean';
+}
+export function isUnNamedProperty(t) {
+    return isProperty(t) && t.Name === '';
+}
+export function isNamedGroupReference(t) {
+    return isGroup(t) && isPropertyReference(t) && typeof t.Value === 'string';
+}
+export function isPropertyReference(t) {
+    return t && typeof t === 'object' && 'Value' in t;
+}
+export function isNativeTypeWithOperator(t) {
+    return t && typeof t.Type === 'object' && 'Operator' in t;
+}
+export function isRange(t) {
+    return t && typeof t.Type === 'object' && t.Type.Type === 'range';
+}
+export function isLiteralWithValue(t) {
+    return t && t.Type === 'literal' && 'Value' in t;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cddl",
-  "version": "0.14.10",
+  "version": "0.15.0",
   "description": "Concise data definition language (RFC 8610) implementation and JSON validator in Node.js",
   "author": "Christian Bromann <mail@bromann.dev>",
   "license": "MIT",
@@ -26,6 +26,7 @@
     "@types/yargs": "^17.0.35"
   },
   "dependencies": {
+    "camelcase": "^9.0.0",
     "yargs": "^18.0.0"
   },
   "scripts": {

package/src/index.ts

@@ -9,3 +9,4 @@ export function parse (filePath: string) {
 export default { parse }
 export { Lexer, Parser }
 export * from './ast.js'
+export * from './utils.js'

package/src/utils.ts

@@ -1,3 +1,15 @@
+import camelcase from 'camelcase'
+
+import type {
+    Assignment,
+    Array as CDDLArray,
+    Group,
+    NativeTypeWithOperator,
+    Property,
+    PropertyReference,
+    Variable
+} from './ast.js'
+
 import { Tokens, Token } from './tokens.js'
 
 export function isLetter (ch: string): boolean {
@@ -35,3 +47,50 @@ export function parseNumberValue (token: Token): string | number {
 
     return parseInt(token.Literal, 10)
 }
+
+export function pascalCase (name: string) {
+    return camelcase(name, { pascalCase: true })
+}
+
+export function isVariable (assignment: Assignment): assignment is Variable {
+    return assignment.Type === 'variable'
+}
+
+export function isGroup (t: any): t is Group {
+    return t && t.Type === 'group'
+}
+
+export function isCDDLArray (t: any): t is CDDLArray {
+    return t && t.Type === 'array'
+}
+
+export function isProperty (t: any): t is Property {
+    return t && typeof t.Name === 'string' && typeof t.HasCut === 'boolean'
+}
+
+export function isUnNamedProperty (t: any): t is Property & { Name: '' } {
+    return isProperty(t) && t.Name === ''
+}
+
+export function isNamedGroupReference (t: any): t is PropertyReference & { Value: string } {
+    return isGroup(t) && isPropertyReference(t) && typeof t.Value === 'string'
+}
+
+export function isPropertyReference (t: any): t is PropertyReference {
+    return t && typeof t === 'object' && 'Value' in t
+}
+
+export function isNativeTypeWithOperator (t: any): t is NativeTypeWithOperator {
+    return t && typeof t.Type === 'object' && 'Operator' in t
+}
+
+export function isRange (t: any): boolean {
+    return t && typeof t.Type === 'object' && (t.Type as any).Type === 'range'
+}
+
+export function isLiteralWithValue (t: any): t is {
+    Type: 'literal'
+    Value: unknown
+} {
+    return t && t.Type === 'literal' && 'Value' in t
+}

package/tests/utils.test.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect } from 'vitest'
+
+import type {
+    Array as CDDLArray,
+    Assignment,
+    Comment,
+    Group,
+    NativeTypeWithOperator,
+    Property,
+    PropertyReference,
+    Variable
+} from '../src/ast.js'
+import { Tokens, type Token } from '../src/tokens.js'
+import {
+    hasSpecialNumberCharacter,
+    isAlphabeticCharacter,
+    isCDDLArray,
+    isDigit,
+    isGroup,
+    isLetter,
+    isLiteralWithValue,
+    isNamedGroupReference,
+    isNativeTypeWithOperator,
+    isProperty,
+    isPropertyReference,
+    isRange,
+    isUnNamedProperty,
+    isVariable,
+    parseNumberValue,
+    pascalCase
+} from '../src/utils.js'
+
+const comments: Comment[] = []
+
+function createVariable (): Variable {
+    return {
+        Type: 'variable',
+        Name: 'my-variable',
+        IsChoiceAddition: false,
+        PropertyType: 'tstr',
+        Comments: comments
+    }
+}
+
+function createGroup (): Group {
+    return {
+        Type: 'group',
+        Name: 'my-group',
+        IsChoiceAddition: false,
+        Properties: [],
+        Comments: comments
+    }
+}
+
+function createArray (): CDDLArray {
+    return {
+        Type: 'array',
+        Name: 'my-array',
+        Values: [],
+        Comments: comments
+    }
+}
+
+function createProperty (overrides: Partial<Property> = {}): Property {
+    return {
+        HasCut: false,
+        Occurrence: { n: 1, m: 1 },
+        Name: 'foo',
+        Type: 'tstr',
+        Comments: comments,
+        ...overrides
+    }
+}
+
+describe('utils', () => {
+    describe('character helpers', () => {
+        it('should detect letters and alphabetic characters', () => {
+            expect(isLetter('a')).toBe(true)
+            expect(isLetter('Z')).toBe(true)
+            expect(isLetter('1')).toBe(false)
+
+            expect(isAlphabeticCharacter('a')).toBe(true)
+            expect(isAlphabeticCharacter(Tokens.ATSIGN)).toBe(true)
+            expect(isAlphabeticCharacter(Tokens.UNDERSCORE)).toBe(true)
+            expect(isAlphabeticCharacter(Tokens.DOLLAR)).toBe(true)
+            expect(isAlphabeticCharacter('-')).toBe(false)
+        })
+
+        it('should detect digits and special number characters', () => {
+            expect(isDigit('1')).toBe(true)
+            expect(isDigit('0')).toBe(true)
+            expect(isDigit('a')).toBe(false)
+            expect(isDigit(Tokens.NL)).toBe(false)
+            expect(isDigit(Tokens.SPACE)).toBe(false)
+
+            expect(hasSpecialNumberCharacter(Tokens.MINUS.charCodeAt(0))).toBe(true)
+            expect(hasSpecialNumberCharacter(Tokens.DOT.charCodeAt(0))).toBe(true)
+            expect(hasSpecialNumberCharacter('x'.charCodeAt(0))).toBe(true)
+            expect(hasSpecialNumberCharacter('b'.charCodeAt(0))).toBe(true)
+            expect(hasSpecialNumberCharacter('1'.charCodeAt(0))).toBe(false)
+        })
+    })
+
+    describe('number parsing helpers', () => {
+        it('should parse floats, integers and prefixed numbers', () => {
+            const floatToken: Token = { Type: Tokens.FLOAT, Literal: '12.5' }
+            const intToken: Token = { Type: Tokens.INT, Literal: '42' }
+            const hexToken: Token = { Type: Tokens.INT, Literal: '0x10' }
+            const binaryToken: Token = { Type: Tokens.INT, Literal: '0b10' }
+
+            expect(parseNumberValue(floatToken)).toBe(12.5)
+            expect(parseNumberValue(intToken)).toBe(42)
+            expect(parseNumberValue(hexToken)).toBe('0x10')
+            expect(parseNumberValue(binaryToken)).toBe('0b10')
+        })
+    })
+
+    describe('name helpers', () => {
+        it('should convert names to pascal case', () => {
+            expect(pascalCase('my-example_name')).toBe('MyExampleName')
+        })
+    })
+
+    describe('assignment guards', () => {
+        it('should detect variables, groups and arrays', () => {
+            const variable: Assignment = createVariable()
+            const group: Assignment = createGroup()
+            const array: Assignment = createArray()
+
+            expect(isVariable(variable)).toBe(true)
+            expect(isVariable(group)).toBe(false)
+
+            expect(isGroup(group)).toBe(true)
+            expect(isGroup(variable)).toBe(false)
+
+            expect(isCDDLArray(array)).toBe(true)
+            expect(isCDDLArray(group)).toBe(false)
+        })
+    })
+
+    describe('property guards', () => {
+        it('should detect named and unnamed properties', () => {
+            const property = createProperty()
+            const unnamedProperty = createProperty({ Name: '' })
+
+            expect(isProperty(property)).toBe(true)
+            expect(isProperty({ Name: 'foo' })).toBe(false)
+
+            expect(isUnNamedProperty(unnamedProperty)).toBe(true)
+            expect(isUnNamedProperty(property)).toBe(false)
+        })
+    })
+
+    describe('reference and operator guards', () => {
+        it('should detect property references and named group references', () => {
+            const groupReference: PropertyReference = {
+                Type: 'group',
+                Value: 'my-group',
+                Unwrapped: false
+            }
+            const numericGroupReference: PropertyReference = {
+                Type: 'group',
+                Value: 123,
+                Unwrapped: false
+            }
+
+            expect(isPropertyReference(groupReference)).toBe(true)
+            expect(isPropertyReference({ Type: 'group' })).toBe(false)
+
+            expect(isNamedGroupReference(groupReference)).toBe(true)
+            expect(isNamedGroupReference(numericGroupReference)).toBe(false)
+        })
+
+        it('should detect native types with operators and ranges', () => {
+            const nativeTypeWithOperator: NativeTypeWithOperator = {
+                Type: {
+                    Type: 'group',
+                    Value: 'my-group',
+                    Unwrapped: false
+                },
+                Operator: {
+                    Type: 'default',
+                    Value: 'tstr'
+                }
+            }
+            const rangeReference: PropertyReference = {
+                Type: 'range',
+                Value: {
+                    Min: 0,
+                    Max: 10,
+                    Inclusive: true
+                },
+                Unwrapped: false
+            }
+
+            expect(isNativeTypeWithOperator(nativeTypeWithOperator)).toBe(true)
+            expect(isNativeTypeWithOperator({ Type: 'tstr' })).toBe(false)
+
+            expect(isRange({ Type: rangeReference })).toBe(true)
+            expect(isRange({ Type: 'range' })).toBe(false)
+        })
+    })
+
+    describe('literal guards', () => {
+        it('should detect literals with values', () => {
+            expect(isLiteralWithValue({ Type: 'literal', Value: 'foo' })).toBe(true)
+            expect(isLiteralWithValue({ Type: 'literal' })).toBe(false)
+            expect(isLiteralWithValue({ Type: 'group', Value: 'foo' })).toBe(false)
+        })
+    })
+})