cddl2ts 0.3.0 → 0.4.0

package/src/utils.ts

@@ -0,0 +1,61 @@
+import {
+    Assignment,
+    PropertyReference,
+    Property,
+    Array,
+    NativeTypeWithOperator,
+    Group,
+    Variable
+} from 'cddl'
+import camelcase from 'camelcase'
+
+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 Array {
+    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 && '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
+}
+
+export function hasTypeProperty(t: any): t is { Type: string } {
+    return t && typeof t.Type === 'string'
+}

package/tests/__snapshots__/group_choice.test.ts.snap

@@ -0,0 +1,72 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`group choice conversion > should generate a union type for multiple group choices 1`] = `
+"export type Extensible = Record<string, unknown>;
+export type ProxyConfiguration = AutodetectProxyConfiguration | DirectProxyConfiguration | ManualProxyConfiguration;
+
+export type AutodetectProxyConfiguration = Extensible & {
+  proxyType: "autodetect";
+};
+
+export type DirectProxyConfiguration = Extensible & {
+  proxyType: "direct";
+};
+
+export // 1. Simple Group Choice
+type ManualProxyConfiguration = Extensible & {
+  proxyType: "manual";
+};
+
+export // 2. Nested Group Choice
+type SimpleGroupChoice = Int | string;
+
+export // 3. Group Choice with Multiple Items (Sequence) - interpreted as tuple
+type NestedGroupChoice = (Int | Tstr);
+
+export // 4. Map Group Choice - interpreted as map (interface) union
+type SequenceGroupChoice = [number, string] | number;
+
+export // 5. Type Choice inside Group - should be value union
+type MapGroupChoice = {
+  a: 1;
+} | {
+  b: 2;
+};
+
+export // 6. Array with Group Choice - should be array of union?
+type TypeChoiceInsideGroup = number | string;
+
+export // 7. Map with nested group (bare and parens) - should be object like
+type ArrayGroupChoice = Int | string[];
+
+export type MapWithBareGroup = number;
+
+export // 8. Group wrapped in map with multiple properties
+type MapWithParensGroup = number;
+
+export // 9. Property type choice without operators
+type MapGroupWrap = ;
+
+export // 10. Nested choice with group reference
+interface PropChoiceNoOp {
+  a: number | number;
+  b: string;
+}
+
+export // 11. Complex type (group) followed by property without comma
+type NestedChoiceRef = number | string;
+
+export // 12. Multi-item group choice (verifies isChoice persistence)
+interface MapNoComma {
+  a: number;
+  b: string;
+}
+
+export type GroupChoiceMulti = {
+  a: number;
+} | {
+  b: string;
+} | {
+  c: number;
+};"
+`;

package/tests/__snapshots__/literals.test.ts.snap

@@ -0,0 +1,8 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`literals > should support bigint and null literals 1`] = `
+"export interface LiteralTest {
+  bigInt: 9007199254740996;
+  nullVal: null;
+}"
+`;

package/tests/__snapshots__/mixin_union.test.ts.snap

@@ -0,0 +1,19 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`mixin union types > should generate union type aliases for mixin choices 1`] = `
+"export type Mixins = MixinA & MixinB;
+
+export interface MixinA {
+  a: number;
+}
+
+export interface MixinB {
+  b: string;
+}
+
+export type UnionMixin = MixinA | MixinB;
+
+export type ComplexMixins = (MixinA | MixinB) & {
+  c: boolean;
+};"
+`;

package/tests/__snapshots__/mod.test.ts.snap

@@ -0,0 +1,102 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`cddl2ts > should generate correct types for test.cddl 1`] = `
+[
+  [
+    "export type Message = CommandResponse | ErrorResponse | Event;
+
+export type ErrorResponse = Extensible & {
+  id?: JsUint | null;
+  error: ErrorCode;
+  message: string;
+  stacktrace?: string;
+};
+
+export type ResultData = BrowsingContextResult | EmptyResult | NetworkResult | ScriptResult | SessionResult;
+export type ErrorCode = "invalid argument" | "invalid session id" | "no such alert" | "no such frame" | "no such handle" | "no such node" | "no such script" | "session not created" | "unknown command" | "unknown error" | "unsupported operation";
+export type JsInt = number;
+export type JsUint = number;
+export type Handle = string;
+export type SharedId = string;
+
+export interface UndefinedValue {
+  type: "undefined";
+}
+
+export interface NullValue {
+  type: null;
+}
+
+export interface StringValue {
+  type: "string";
+  value: string;
+}
+
+export type SpecialNumber = "NaN" | "-0" | "Infinity" | "-Infinity";
+
+export interface NumberValue {
+  type: "number";
+  value: Number | SpecialNumber;
+}
+
+export interface SessionCapabilitiesRequest {
+  alwaysMatch?: SessionCapabilityRequest;
+  firstMatch?: SessionCapabilityRequest[];
+  nested: {
+    obj: 123;
+    moreNesting: {
+      id: JsUint | null;
+      like: boolean;
+    };
+  };
+}
+
+export interface SomeGroup {
+  /**
+   * this is the optional leading param
+   * this is not leading
+   *
+   * @default 'foobar'
+   */
+  optional?: string;
+  /**
+   * @default 'portrait'
+   */
+  orientation?: "portrait" | "landscape";
+  /**
+   * @default 1
+   */
+  scale?: number;
+  /**
+   * @default true
+   */
+  shrinkToFit?: boolean;
+  /**
+   * @default true
+   */
+  shrinkToFitP?: boolean;
+  /**
+   * this is the pageRanges param
+   *
+   * @default 1
+   */
+  bottom?: number;
+  pageRanges?: (JsUint | string)[];
+  /**
+   * @default null
+   */
+  foo?: string;
+  /**
+   * @default 'mouse'
+   */
+  pointerType?: InputPointerType;
+}
+
+export type ScriptListLocalValue = ScriptLocalValue[];
+export type ScriptMappingLocalValue = (ScriptLocalValue | ScriptLocalValue)[];
+
+export // some comments here
+type Extensible = Record<string, any>;",
+  ],
+]
+`;

package/tests/__snapshots__/repro_proxy.test.ts.snap

@@ -0,0 +1,14 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`repro proxy > should generate correct output for ProxyConfiguration 1`] = `
+"export type Extensible = Record<string, unknown>;
+export type ProxyConfiguration = AutodetectProxyConfiguration | DirectProxyConfiguration;
+
+export interface AutodetectProxyConfiguration extends Extensible {
+  proxyType: "autodetect";
+}
+
+export interface DirectProxyConfiguration extends Extensible {
+  proxyType: "direct";
+}"
+`;

package/tests/__snapshots__/union_extension.test.ts.snap

@@ -0,0 +1,18 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`union extension > should generate an intersection type instead of interface extends when extending a union 1`] = `
+"export type Extensible = Record<string, unknown>;
+export type Event = EventData & Extensible;
+export type EventData = MouseEvent | KeyboardEvent;
+
+export interface MouseEvent {
+  type: "mouse";
+  x: Number;
+  y: Number;
+}
+
+export interface KeyboardEvent {
+  type: "key";
+  code: Number;
+}"
+`;