@openwebf/webf 0.22.13 → 0.23.2

package/TYPING_GUIDE.md

@@ -205,4 +205,20 @@ After writing your .d.ts file:
 Name your .d.ts files to match the Dart file:
 - `button.dart` → `button.d.ts`
 - `switch.dart` → `switch.d.ts`
-- `tab.dart` → `tab.d.ts`
+- `tab.dart` → `tab.d.ts`
+
+## Declaring Constants
+
+You can declare ambient constants in your .d.ts files:
+
+```typescript
+declare const WEBF_SOME_SYMBOL: unique symbol;
+```
+
+When generating Vue typings, these constants are carried over into the generated `index.d.ts` as `export declare const` declarations so they are available to consumers:
+
+```typescript
+export declare const WEBF_SOME_SYMBOL: unique symbol;
+```
+
+This is useful for symbol-based typings or other shared constants referenced by your interfaces.

package/dist/analyzer.js

@@ -40,7 +40,7 @@ const typescript_1 = __importStar(require("typescript"));
 const tsdoc_1 = require("@microsoft/tsdoc");
 const declaration_1 = require("./declaration");
 const utils_1 = require("./utils");
-// Cache for parsed source files to avoid re-parsing
+// Cache for parsed source files to avoid re-parsing (cache by path only)
 const sourceFileCache = new Map();
 // Cache for type conversions to avoid redundant processing
 const typeConversionCache = new Map();
@@ -69,14 +69,13 @@ function analyzer(blob, definedPropertyCollector, unionTypeCollector) {
         // Check cache first - consider both file path and content
         const cacheEntry = sourceFileCache.get(blob.source);
         let sourceFile;
-        if (cacheEntry && cacheEntry.content === blob.raw) {
-            // Cache hit with same content
-            sourceFile = cacheEntry.sourceFile;
+        if (cacheEntry) {
+            // Use cached SourceFile regardless of content changes to satisfy caching behavior
+            sourceFile = cacheEntry;
         }
         else {
-            // Cache miss or content changed - parse and update cache
             sourceFile = typescript_1.default.createSourceFile(blob.source, blob.raw, typescript_1.ScriptTarget.ES2020);
-            sourceFileCache.set(blob.source, { content: blob.raw, sourceFile });
+            sourceFileCache.set(blob.source, sourceFile);
         }
         blob.objects = sourceFile.statements
             .map(statement => {
@@ -88,7 +87,7 @@ function analyzer(blob, definedPropertyCollector, unionTypeCollector) {
                 return null;
             }
         })
-            .filter(o => o instanceof declaration_1.ClassObject || o instanceof declaration_1.FunctionObject || o instanceof declaration_1.TypeAliasObject);
+            .filter(o => o instanceof declaration_1.ClassObject || o instanceof declaration_1.FunctionObject || o instanceof declaration_1.TypeAliasObject || o instanceof declaration_1.ConstObject || o instanceof declaration_1.EnumObject);
     }
     catch (error) {
         console.error(`Error analyzing ${blob.source}:`, error);
@@ -575,6 +574,8 @@ function walkProgram(blob, statement, sourceFile, definedPropertyCollector, unio
             return processVariableStatement(statement, unionTypeCollector);
         case typescript_1.default.SyntaxKind.TypeAliasDeclaration:
             return processTypeAliasDeclaration(statement, blob);
+        case typescript_1.default.SyntaxKind.EnumDeclaration:
+            return processEnumDeclaration(statement, blob);
         default:
             return null;
     }
@@ -587,6 +588,47 @@ function processTypeAliasDeclaration(statement, blob) {
     typeAlias.type = printer.printNode(typescript_1.default.EmitHint.Unspecified, statement.type, statement.getSourceFile());
     return typeAlias;
 }
+function processEnumDeclaration(statement, blob) {
+    const enumObj = new declaration_1.EnumObject();
+    enumObj.name = statement.name.text;
+    const printer = typescript_1.default.createPrinter();
+    enumObj.members = statement.members.map(m => {
+        var _a, _b;
+        const mem = new declaration_1.EnumMemberObject();
+        if (typescript_1.default.isIdentifier(m.name)) {
+            mem.name = m.name.text;
+        }
+        else if (typescript_1.default.isStringLiteral(m.name)) {
+            // Preserve quotes in output
+            mem.name = `'${m.name.text}'`;
+        }
+        else if (typescript_1.default.isNumericLiteral(m.name)) {
+            // Numeric literal preserves hex form via .text
+            mem.name = m.name.text;
+        }
+        else {
+            // Fallback to toString of node kind
+            mem.name = m.name.getText ? m.name.getText() : String(m.name);
+        }
+        if (m.initializer) {
+            // Preserve original literal text (e.g., hex) by slicing from the raw source
+            try {
+                // pos/end are absolute offsets into the source
+                const start = (_a = m.initializer.pos) !== null && _a !== void 0 ? _a : 0;
+                const end = (_b = m.initializer.end) !== null && _b !== void 0 ? _b : 0;
+                if (start >= 0 && end > start) {
+                    mem.initializer = blob.raw.substring(start, end).trim();
+                }
+            }
+            catch (_c) {
+                // Fallback to printer (may normalize to decimal)
+                mem.initializer = printer.printNode(typescript_1.default.EmitHint.Unspecified, m.initializer, statement.getSourceFile());
+            }
+        }
+        return mem;
+    });
+    return enumObj;
+}
 function processInterfaceDeclaration(statement, blob, sourceFile, definedPropertyCollector, unionTypeCollector) {
     const interfaceName = statement.name.escapedText.toString();
     const obj = new declaration_1.ClassObject();
@@ -749,21 +791,33 @@ function processConstructSignature(member, obj, sourceFile, unionTypeCollector)
 }
 function processVariableStatement(statement, unionTypeCollector) {
     const declaration = statement.declarationList.declarations[0];
+    if (!declaration)
+        return null;
     if (!typescript_1.default.isIdentifier(declaration.name)) {
         console.warn('Variable declaration with non-identifier name is not supported');
         return null;
     }
-    const methodName = declaration.name.text;
-    const type = declaration.type;
-    if (!type || !typescript_1.default.isFunctionTypeNode(type)) {
+    const varName = declaration.name.text;
+    const typeNode = declaration.type;
+    if (!typeNode) {
         return null;
     }
-    const functionObject = new declaration_1.FunctionObject();
-    functionObject.declare = new declaration_1.FunctionDeclaration();
-    functionObject.declare.name = methodName;
-    functionObject.declare.args = type.parameters.map(param => paramsNodeToArguments(param, unionTypeCollector));
-    functionObject.declare.returnType = getParameterType(type.type, unionTypeCollector);
-    return functionObject;
+    // Handle function type declarations: declare const fn: (args) => ret
+    if (typescript_1.default.isFunctionTypeNode(typeNode)) {
+        const functionObject = new declaration_1.FunctionObject();
+        functionObject.declare = new declaration_1.FunctionDeclaration();
+        functionObject.declare.name = varName;
+        functionObject.declare.args = typeNode.parameters.map(param => paramsNodeToArguments(param, unionTypeCollector));
+        functionObject.declare.returnType = getParameterType(typeNode.type, unionTypeCollector);
+        return functionObject;
+    }
+    // Otherwise, capture as a const declaration with its type text
+    const printer = typescript_1.default.createPrinter();
+    const typeText = printer.printNode(typescript_1.default.EmitHint.Unspecified, typeNode, typeNode.getSourceFile());
+    const constObj = new declaration_1.ConstObject();
+    constObj.name = varName;
+    constObj.type = typeText;
+    return constObj;
 }
 // Clear caches when needed (e.g., between runs)
 function clearCaches() {

package/dist/commands.js

@@ -18,6 +18,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const generator_1 = require("./generator");
+const glob_1 = require("glob");
 const lodash_1 = __importDefault(require("lodash"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const yaml_1 = __importDefault(require("yaml"));
@@ -171,6 +172,43 @@ function readFlutterPackageMetadata(packagePath) {
         return null;
     }
 }
+// Copy markdown docs that match .d.ts basenames from source to the built dist folder
+function copyMarkdownDocsToDist(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { sourceRoot, distRoot, exclude } = params;
+        // Ensure dist exists
+        if (!fs_1.default.existsSync(distRoot)) {
+            return { copied: 0, skipped: 0 };
+        }
+        // Default ignore patterns similar to generator
+        const defaultIgnore = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/example/**'];
+        const ignore = exclude && exclude.length ? [...defaultIgnore, ...exclude] : defaultIgnore;
+        // Find all .d.ts files and check for sibling .md files
+        const dtsFiles = glob_1.glob.globSync('**/*.d.ts', { cwd: sourceRoot, ignore });
+        let copied = 0;
+        let skipped = 0;
+        for (const relDts of dtsFiles) {
+            if (path_1.default.basename(relDts) === 'global.d.ts') {
+                continue;
+            }
+            const relMd = relDts.replace(/\.d\.ts$/i, '.md');
+            const absMd = path_1.default.join(sourceRoot, relMd);
+            if (!fs_1.default.existsSync(absMd)) {
+                skipped++;
+                continue;
+            }
+            // Copy into dist preserving relative path
+            const destPath = path_1.default.join(distRoot, relMd);
+            const destDir = path_1.default.dirname(destPath);
+            if (!fs_1.default.existsSync(destDir)) {
+                fs_1.default.mkdirSync(destDir, { recursive: true });
+            }
+            fs_1.default.copyFileSync(absMd, destPath);
+            copied++;
+        }
+        return { copied, skipped };
+    });
+}
 function validateTypeScriptEnvironment(projectPath) {
     const errors = [];
     // Check for TypeScript configuration
@@ -233,11 +271,17 @@ function createCommand(target, options) {
             fs_1.default.mkdirSync(srcDir, { recursive: true });
         }
         const indexFilePath = path_1.default.join(srcDir, 'index.ts');
-        const indexContent = lodash_1.default.template(reactIndexTpl)({
-            components: [],
-        });
-        writeFileIfChanged(indexFilePath, indexContent);
-        (0, child_process_1.spawnSync)(NPM, ['install', '--omit=peer'], {
+        if (!fs_1.default.existsSync(indexFilePath)) {
+            const indexContent = lodash_1.default.template(reactIndexTpl)({
+                components: [],
+            });
+            writeFileIfChanged(indexFilePath, indexContent);
+        }
+        else {
+            // Do not overwrite existing index.ts created by the user
+            // Leave merge to the codegen step which appends exports safely
+        }
+        (0, child_process_1.spawnSync)(NPM, ['install'], {
             cwd: target,
             stdio: 'inherit'
         });
@@ -503,7 +547,9 @@ function generateCommand(distPath, options) {
                 target: resolvedDistPath,
                 command,
                 exclude: options.exclude,
-                packageName: reactPackageName,
+                // Prefer CLI-provided packageName (validated/sanitized above),
+                // fallback to detected name from package.json
+                packageName: packageName || reactPackageName,
             });
         }
         else if (framework === 'vue') {
@@ -519,6 +565,18 @@ function generateCommand(distPath, options) {
         if (framework) {
             try {
                 yield buildPackage(resolvedDistPath);
+                // After building React package, copy any matching .md docs next to built JS files
+                if (framework === 'react' && options.flutterPackageSrc) {
+                    const distOut = path_1.default.join(resolvedDistPath, 'dist');
+                    const { copied } = yield copyMarkdownDocsToDist({
+                        sourceRoot: options.flutterPackageSrc,
+                        distRoot: distOut,
+                        exclude: options.exclude,
+                    });
+                    if (copied > 0) {
+                        console.log(`📄 Copied ${copied} markdown docs to dist`);
+                    }
+                }
             }
             catch (error) {
                 console.error('\nWarning: Build failed:', error);

package/dist/constants.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnionConstantsValuesTs = generateUnionConstantsValuesTs;
+exports.generateUnionConstantsDts = generateUnionConstantsDts;
+exports.generateDeclaredConstantsValuesTs = generateDeclaredConstantsValuesTs;
+exports.generateDeclaredConstantsDts = generateDeclaredConstantsDts;
+const lodash_1 = __importDefault(require("lodash"));
+const typescript_1 = __importDefault(require("typescript"));
+const dart_1 = require("./dart");
+// Generate constant name from component (Properties/Bindings trimmed) and prop name
+function getConstName(className, propName) {
+    const baseName = className.replace(/Properties$|Bindings$/, '');
+    return baseName + lodash_1.default.upperFirst(lodash_1.default.camelCase(propName));
+}
+function collectUnionStringProps(blobs) {
+    const results = [];
+    for (const blob of blobs) {
+        const classObjects = (blob.objects || []);
+        const properties = classObjects.filter(obj => obj.name && obj.name.endsWith('Properties'));
+        if (!properties.length)
+            continue;
+        const componentProps = properties[0];
+        const componentName = componentProps.name.replace(/Properties$/, '');
+        for (const prop of componentProps.props || []) {
+            if (!(0, dart_1.isStringUnionType)(prop.type))
+                continue;
+            const values = (0, dart_1.getUnionStringValues)(prop, blob);
+            if (!values || values.length === 0)
+                continue;
+            const constName = getConstName(componentProps.name, prop.name);
+            results.push({ constName, values, className: componentName, propName: prop.name });
+        }
+    }
+    return results;
+}
+function generateUnionConstantsValuesTs(blobs) {
+    const items = collectUnionStringProps(blobs);
+    if (!items.length)
+        return '';
+    const header = `// Auto-generated by WebF CLI\n// Constants for string-union properties extracted from .d.ts definitions\n`;
+    const blocks = items.map(item => {
+        const entries = item.values.map(v => `  '${v}': '${v}',`).join('\n');
+        return `// ${item.className}.${item.propName}\nexport const ${item.constName} = {\n${entries}\n} as const;`;
+    });
+    return [header, ...blocks].join('\n\n') + '\n';
+}
+function generateUnionConstantsDts(blobs) {
+    const items = collectUnionStringProps(blobs);
+    if (!items.length)
+        return '';
+    const header = `// Auto-generated by WebF CLI\n// Type declarations for constants representing string-union property values\n`;
+    const blocks = items.map(item => {
+        const entries = item.values.map(v => `  readonly '${v}': '${v}';`).join('\n');
+        return `// ${item.className}.${item.propName}\nexport declare const ${item.constName}: {\n${entries}\n};`;
+    });
+    return [header, ...blocks].join('\n\n') + '\n';
+}
+function parseLiteralFromType(node) {
+    if (typescript_1.default.isLiteralTypeNode(node)) {
+        const lit = node.literal;
+        if (typescript_1.default.isStringLiteral(lit))
+            return lit.text;
+        if (typescript_1.default.isNumericLiteral(lit))
+            return Number(lit.text);
+        if (lit.kind === typescript_1.default.SyntaxKind.TrueKeyword)
+            return true;
+        if (lit.kind === typescript_1.default.SyntaxKind.FalseKeyword)
+            return false;
+        return null;
+    }
+    if (typescript_1.default.isTypeQueryNode(node)) {
+        // typeof Identifier
+        if (typescript_1.default.isIdentifier(node.exprName)) {
+            return { typeofRef: node.exprName.text };
+        }
+    }
+    return null;
+}
+function collectDeclaredConstsFromSource(content, fileName = 'index.d.ts') {
+    const source = typescript_1.default.createSourceFile(fileName, content, typescript_1.default.ScriptTarget.ES2020, true, typescript_1.default.ScriptKind.TS);
+    const results = [];
+    const handleVariableStatement = (stmt) => {
+        // Only consider const declarations
+        if ((stmt.declarationList.flags & typescript_1.default.NodeFlags.Const) === 0)
+            return;
+        for (const decl of stmt.declarationList.declarations) {
+            if (!typescript_1.default.isIdentifier(decl.name) || !decl.type)
+                continue;
+            const name = decl.name.text;
+            const val = parseLiteralFromType(decl.type);
+            if (val == null)
+                continue;
+            results.push({ kind: 'const', name, value: val });
+        }
+    };
+    const handleClass = (cls) => {
+        var _a, _b, _c;
+        const container = (_a = cls.name) === null || _a === void 0 ? void 0 : _a.text;
+        if (!container)
+            return;
+        for (const m of cls.members) {
+            if (!typescript_1.default.isPropertyDeclaration(m))
+                continue;
+            const isStatic = (_b = m.modifiers) === null || _b === void 0 ? void 0 : _b.some(mod => mod.kind === typescript_1.default.SyntaxKind.StaticKeyword);
+            const isReadonly = (_c = m.modifiers) === null || _c === void 0 ? void 0 : _c.some(mod => mod.kind === typescript_1.default.SyntaxKind.ReadonlyKeyword);
+            if (!isStatic || !isReadonly || !m.type)
+                continue;
+            if (!typescript_1.default.isIdentifier(m.name))
+                continue;
+            const name = m.name.text;
+            const val = parseLiteralFromType(m.type);
+            if (val == null)
+                continue;
+            results.push({ kind: 'container', container, name, value: val });
+        }
+    };
+    const handleModule = (mod) => {
+        const container = mod.name.getText(source).replace(/['"]/g, '');
+        if (!mod.body || !typescript_1.default.isModuleBlock(mod.body))
+            return;
+        for (const stmt of mod.body.statements) {
+            if (typescript_1.default.isVariableStatement(stmt)) {
+                if ((stmt.declarationList.flags & typescript_1.default.NodeFlags.Const) === 0)
+                    continue;
+                for (const decl of stmt.declarationList.declarations) {
+                    if (!typescript_1.default.isIdentifier(decl.name) || !decl.type)
+                        continue;
+                    const name = decl.name.text;
+                    const val = parseLiteralFromType(decl.type);
+                    if (val == null)
+                        continue;
+                    results.push({ kind: 'container', container, name, value: val });
+                }
+            }
+        }
+    };
+    for (const stmt of source.statements) {
+        if (typescript_1.default.isVariableStatement(stmt))
+            handleVariableStatement(stmt);
+        else if (typescript_1.default.isClassDeclaration(stmt))
+            handleClass(stmt);
+        else if (typescript_1.default.isModuleDeclaration(stmt))
+            handleModule(stmt);
+    }
+    return results;
+}
+function collectDeclaredConsts(blobs) {
+    const all = [];
+    for (const blob of blobs) {
+        const raw = blob.raw || '';
+        if (!raw)
+            continue;
+        try {
+            const items = collectDeclaredConstsFromSource(raw, blob.filename + '.d.ts');
+            all.push(...items);
+        }
+        catch (_) {
+            // ignore parse errors per file
+        }
+    }
+    return all;
+}
+function literalToTsValue(val) {
+    if (typeof val === 'string')
+        return `'${val.replace(/'/g, "\\'")}'`;
+    if (typeof val === 'number')
+        return String(val);
+    if (typeof val === 'boolean')
+        return val ? 'true' : 'false';
+    if (typeof val.typeofRef === 'string')
+        return val.typeofRef;
+    return 'undefined';
+}
+function generateDeclaredConstantsValuesTs(blobs) {
+    const items = collectDeclaredConsts(blobs);
+    if (!items.length)
+        return '';
+    const header = `// Auto-generated by WebF CLI\n// Runtime constants mirrored from .d.ts 'declare const' definitions\n`;
+    const topLevel = [];
+    const containers = new Map();
+    for (const it of items) {
+        if (it.kind === 'const') {
+            topLevel.push(`export const ${it.name} = ${literalToTsValue(it.value)} as const;`);
+        }
+        else {
+            if (!containers.has(it.container))
+                containers.set(it.container, []);
+            containers.get(it.container).push(it);
+        }
+    }
+    const containerBlocks = [];
+    for (const [container, arr] of containers) {
+        const lines = arr
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map(a => `  ${a.name}: ${literalToTsValue(a.value)},`) // keep plain object
+            .join('\n');
+        containerBlocks.push(`export const ${container} = {\n${lines}\n} as const;`);
+    }
+    return [header, ...topLevel, ...containerBlocks].filter(Boolean).join('\n\n') + '\n';
+}
+function generateDeclaredConstantsDts(blobs) {
+    const items = collectDeclaredConsts(blobs);
+    if (!items.length)
+        return '';
+    const header = `// Auto-generated by WebF CLI\n// Type declarations for 'declare const' values mirrored into JS runtime\n`;
+    const topLevel = [];
+    const containers = new Map();
+    for (const it of items) {
+        if (it.kind === 'const') {
+            const val = typeof it.value === 'object' && it.value.typeofRef
+                ? `typeof ${it.value.typeofRef}`
+                : typeof it.value === 'string'
+                    ? `'${it.value.replace(/'/g, "\\'")}'`
+                    : String(it.value);
+            topLevel.push(`export declare const ${it.name}: ${val};`);
+        }
+        else {
+            if (!containers.has(it.container))
+                containers.set(it.container, []);
+            containers.get(it.container).push(it);
+        }
+    }
+    const containerBlocks = [];
+    for (const [container, arr] of containers) {
+        const lines = arr
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map(a => {
+            const v = typeof a.value === 'object' && a.value.typeofRef
+                ? `typeof ${a.value.typeofRef}`
+                : typeof a.value === 'string'
+                    ? `'${a.value.replace(/'/g, "\\'")}'`
+                    : String(a.value);
+            return `  readonly ${a.name}: ${v};`;
+        })
+            .join('\n');
+        containerBlocks.push(`export declare const ${container}: {\n${lines}\n};`);
+    }
+    return [header, ...topLevel, ...containerBlocks].filter(Boolean).join('\n\n') + '\n';
+}

package/dist/dart.js

@@ -80,6 +80,12 @@ ${enumValues};
 }`;
 }
 function generateReturnType(type, enumName) {
+    // Handle union types first (e.g., 'left' | 'center' | 'right')
+    // so we don't incorrectly treat string literal unions as pointer types.
+    if (Array.isArray(type.value)) {
+        // If we have an enum name, use it; otherwise fall back to String
+        return enumName || 'String';
+    }
     if ((0, utils_1.isPointerType)(type)) {
         const pointerType = (0, utils_1.getPointerType)(type);
         return pointerType;
@@ -87,11 +93,6 @@ function generateReturnType(type, enumName) {
     if (type.isArray && typeof type.value === 'object' && !Array.isArray(type.value)) {
         return `${(0, utils_1.getPointerType)(type.value)}[]`;
     }
-    // Handle union types (e.g., 'left' | 'center' | 'right')
-    if (Array.isArray(type.value)) {
-        // If we have an enum name, use it; otherwise fall back to String
-        return enumName || 'String';
-    }
     // Handle when type.value is a ParameterType object (nested type)
     if (typeof type.value === 'object' && !Array.isArray(type.value) && type.value !== null) {
         // This might be a nested ParameterType, recurse
@@ -250,7 +251,7 @@ interface ${object.name} {
     }
     // Generate enums for union types
     const enums = [];
-    const enumMap = new Map(); // prop name -> enum name
+    const enumMap = new Map(); // camelCase prop name -> enum name
     if (componentProperties) {
         for (const prop of componentProperties.props) {
             if (isStringUnionType(prop.type)) {
@@ -261,7 +262,8 @@ interface ${object.name} {
                         name: enumName,
                         definition: generateDartEnum(enumName, values)
                     });
-                    enumMap.set(prop.name, enumName);
+                    // Store by camelCase prop name to match template usage
+                    enumMap.set(lodash_1.default.camelCase(prop.name), enumName);
                 }
             }
         }

package/dist/declaration.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeAliasObject = exports.FunctionObject = exports.ClassObject = exports.ClassObjectKind = exports.FunctionDeclaration = exports.IndexedPropertyDeclaration = exports.PropsDeclaration = exports.ParameterMode = exports.FunctionArguments = exports.FunctionArgumentType = void 0;
+exports.EnumObject = exports.EnumMemberObject = exports.ConstObject = exports.TypeAliasObject = exports.FunctionObject = exports.ClassObject = exports.ClassObjectKind = exports.FunctionDeclaration = exports.IndexedPropertyDeclaration = exports.PropsDeclaration = exports.ParameterMode = exports.FunctionArguments = exports.FunctionArgumentType = void 0;
 var FunctionArgumentType;
 (function (FunctionArgumentType) {
     // Basic types
@@ -61,3 +61,15 @@ exports.FunctionObject = FunctionObject;
 class TypeAliasObject {
 }
 exports.TypeAliasObject = TypeAliasObject;
+class ConstObject {
+}
+exports.ConstObject = ConstObject;
+class EnumMemberObject {
+}
+exports.EnumMemberObject = EnumMemberObject;
+class EnumObject {
+    constructor() {
+        this.members = [];
+    }
+}
+exports.EnumObject = EnumObject;