@vuer-ai/vuer-uikit 0.0.98 → 0.0.100

package/cli/dial-cli.js

@@ -1,833 +0,0 @@
-#!/usr/bin/env node
-
-// src/cli/dial-cli.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { basename, dirname, join, resolve } from "path";
-import { parseArgs } from "util";
-import { fileURLToPath } from "url";
-import { execSync } from "child_process";
-import * as docgen from "react-docgen-typescript";
-import * as ts from "typescript";
-function getVersionInfo() {
-  try {
-    const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname2 = dirname(__filename2);
-    const possiblePaths = [
-      resolve(__dirname2, "../package.json"),
-      // Built version: cli/dial-cli.js -> package.json
-      resolve(__dirname2, "../../package.json")
-      // Source version: src/cli/dial-cli.ts -> package.json
-    ];
-    let packageJson = null;
-    for (const path of possiblePaths) {
-      try {
-        if (existsSync(path)) {
-          packageJson = JSON.parse(readFileSync(path, "utf-8"));
-          break;
-        }
-      } catch {
-      }
-    }
-    const version = packageJson?.version || "unknown";
-    let gitHash;
-    try {
-      gitHash = execSync("git rev-parse --short HEAD", { encoding: "utf-8", cwd: dirname(__dirname2) }).trim();
-    } catch {
-      gitHash = void 0;
-    }
-    return { version, gitHash };
-  } catch (error) {
-    return { version: "unknown" };
-  }
-}
-function parseTypeAlias(sourceFile, typeName) {
-  let typeDefinition = null;
-  function visit(node) {
-    if (ts.isTypeAliasDeclaration(node) && node.name.text === typeName) {
-      typeDefinition = {
-        name: typeName,
-        kind: "typeAlias",
-        raw: node.getFullText().trim()
-      };
-      const fullText = node.getFullText();
-      const jsDocMatch = fullText.match(/\/\*\*([\s\S]*?)\*\//);
-      if (jsDocMatch) {
-        const jsDocContent = jsDocMatch[1];
-        typeDefinition.dialTags = parseDialTags(jsDocContent);
-        typeDefinition.jsDoc = jsDocContent.trim();
-      }
-      if (ts.isTupleTypeNode(node.type)) {
-        typeDefinition.type = "tuple";
-        typeDefinition.elements = [];
-        node.type.elements.forEach((element, index) => {
-          const elementData = {
-            index,
-            raw: element.getFullText().trim()
-          };
-          if (ts.isNamedTupleMember(element)) {
-            elementData.name = element.name?.getText();
-            elementData.type = element.type?.getText();
-            const sourceText = element.getFullText();
-            const commentMatch = sourceText.match(/\/\/(.+)/);
-            if (commentMatch) {
-              elementData.comment = commentMatch[1].trim();
-              const dialTags = {};
-              const minMatch = commentMatch[1].match(/@dial-min\s+([\d.]+)/);
-              if (minMatch) {
-                dialTags.min = parseFloat(minMatch[1]);
-                elementData.min = dialTags.min;
-              }
-              const maxMatch = commentMatch[1].match(/@dial-max\s+([\d.]+)/);
-              if (maxMatch) {
-                dialTags.max = parseFloat(maxMatch[1]);
-                elementData.max = dialTags.max;
-              }
-              const stepMatch = commentMatch[1].match(/@dial-step\s+([\d.]+)/);
-              if (stepMatch) {
-                dialTags.step = parseFloat(stepMatch[1]);
-                elementData.step = dialTags.step;
-              }
-              const dtypeMatch = commentMatch[1].match(/@dial-dtype\s+(\w+)/);
-              if (dtypeMatch) {
-                dialTags.dtype = dtypeMatch[1];
-                elementData.dtype = dtypeMatch[1];
-              } else {
-                elementData.dtype = "number";
-              }
-              elementData.dialTags = dialTags;
-            }
-          }
-          typeDefinition.elements.push(elementData);
-        });
-      } else if (ts.isArrayTypeNode(node.type)) {
-        typeDefinition.type = "array";
-        typeDefinition.elementType = node.type.elementType?.getText();
-      } else {
-        typeDefinition.type = "other";
-        typeDefinition.typeNode = node.type ? node.type.getText() : "unknown";
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return typeDefinition;
-}
-function parseInterfaceProperties(sourceFile, interfaceName) {
-  const properties = [];
-  let interfaceDialTags = {};
-  const groupConfigs = {};
-  function visit(node) {
-    if (ts.isInterfaceDeclaration(node) && node.name.text === interfaceName) {
-      const interfaceJsDocNodes = ts.getJSDocCommentsAndTags(node);
-      if (interfaceJsDocNodes && interfaceJsDocNodes.length > 0) {
-        const interfaceFullText = interfaceJsDocNodes[0].getFullText();
-        interfaceDialTags = parseDialTags(interfaceFullText);
-        const lines = interfaceFullText.split("\n");
-        lines.forEach((line) => {
-          const groupMatch = line.match(/@dial\s+(\w+)(.*)/);
-          if (groupMatch) {
-            const groupName = groupMatch[1];
-            const configStr = groupMatch[2];
-            if (configStr.includes("@dial-no-wrap")) {
-              groupConfigs[groupName] = { noWrap: true };
-            }
-          }
-        });
-      }
-      node.members.forEach((member) => {
-        if (ts.isPropertySignature(member) && member.name && ts.isIdentifier(member.name)) {
-          const propName = member.name.text;
-          const jsDocNodes = ts.getJSDocCommentsAndTags(member);
-          let propertyDialTags = {};
-          if (jsDocNodes && jsDocNodes.length > 0) {
-            const fullText = jsDocNodes[0].getFullText();
-            propertyDialTags = parseDialTags(fullText);
-          }
-          const mergedDialTags = { ...interfaceDialTags, ...propertyDialTags };
-          const prop = {
-            name: propName,
-            dtype: mergedDialTags.dtype || "number"
-          };
-          if (mergedDialTags.min !== void 0) prop.min = mergedDialTags.min;
-          if (mergedDialTags.max !== void 0) prop.max = mergedDialTags.max;
-          if (mergedDialTags.step !== void 0) prop.step = mergedDialTags.step;
-          if (mergedDialTags.icon) prop.icon = mergedDialTags.icon;
-          if (mergedDialTags.grouping || mergedDialTags.column || mergedDialTags.rowCount || mergedDialTags.colCount || mergedDialTags.labelPosition || mergedDialTags.noWrap) {
-            prop.tags = {};
-            if (mergedDialTags.grouping) {
-              prop.tags.grouping = mergedDialTags.grouping;
-              if (groupConfigs[mergedDialTags.grouping]?.noWrap) {
-                prop.tags.noWrap = true;
-              }
-            }
-            if (mergedDialTags.column) prop.tags.layout = "column";
-            if (mergedDialTags.rowCount) prop.tags.row = mergedDialTags.rowCount;
-            if (mergedDialTags.colCount) prop.tags.col = mergedDialTags.colCount;
-            if (mergedDialTags.labelPosition) prop.tags.labelPosition = mergedDialTags.labelPosition;
-            if (mergedDialTags.noWrap) prop.tags.noWrap = true;
-          }
-          properties.push(prop);
-        }
-      });
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return properties;
-}
-function parseDialTags(description) {
-  const dialTags = {};
-  if (!description) return dialTags;
-  if (/@dial-ignore\b/i.test(description)) {
-    dialTags.ignore = true;
-    return dialTags;
-  }
-  const groupingPattern = /@dial\s+(transform|visibility|geometry|segments)\b/gm;
-  let match;
-  while ((match = groupingPattern.exec(description)) !== null) {
-    dialTags.grouping = match[1];
-  }
-  const propertyPattern = /@dial-([\w-]+)(?:\s+([^\n@]+?))?(?:\n|@|$)/gm;
-  while ((match = propertyPattern.exec(description)) !== null) {
-    const [, key, value] = match;
-    switch (key) {
-      case "options":
-        if (value) {
-          try {
-            dialTags.options = JSON.parse(value);
-          } catch {
-            dialTags.options = value;
-          }
-        }
-        break;
-      case "min":
-      case "max":
-      case "step":
-        if (value) {
-          dialTags[key] = parseFloat(value);
-        }
-        break;
-      case "col":
-      case "column":
-        dialTags.column = true;
-        break;
-      case "row":
-        if (value && /^\d+$/.test(value)) {
-          dialTags.rowCount = parseInt(value, 10);
-        }
-        break;
-      case "col-3":
-      case "col-2":
-      case "col-4": {
-        const colMatch = key.match(/col-(\d+)/);
-        if (colMatch) {
-          dialTags.colCount = parseInt(colMatch[1], 10);
-        }
-        break;
-      }
-      case "row-3":
-      case "row-2":
-      case "row-4": {
-        const rowMatch = key.match(/row-(\d+)/);
-        if (rowMatch) {
-          dialTags.rowCount = parseInt(rowMatch[1], 10);
-        }
-        break;
-      }
-      case "dtype":
-        if (value) {
-          dialTags.dtype = value.trim();
-        }
-        break;
-      case "dtypes":
-        if (value) {
-          dialTags.dtypes = value.split(",").map((s) => s.trim());
-        }
-        break;
-      case "type":
-        if (value) {
-          dialTags.type = value.trim();
-        }
-        break;
-      case "icon":
-        if (value) {
-          dialTags.icon = value.trim();
-        }
-        break;
-      case "default":
-        if (value) {
-          try {
-            dialTags.default = JSON.parse(value);
-          } catch {
-            dialTags.default = value.trim();
-          }
-        }
-        break;
-      case "placeholders":
-        if (value) {
-          dialTags.placeholders = value.split(",").map((s) => s.trim());
-        }
-        break;
-      case "tooltips":
-        if (value) {
-          dialTags.tooltips = value.split(",").map((s) => s.trim());
-        }
-        break;
-      case "mins":
-        if (value) {
-          dialTags.mins = value.split(",").map((s) => parseFloat(s.trim()));
-        }
-        break;
-      case "maxs":
-        if (value) {
-          dialTags.maxs = value.split(",").map((s) => parseFloat(s.trim()));
-        }
-        break;
-      case "steps":
-        if (value) {
-          dialTags.steps = value.split(",").map((s) => parseFloat(s.trim()));
-        }
-        break;
-      case "label-left":
-      case "left":
-        dialTags.labelPosition = "left";
-        break;
-      case "label-right":
-      case "right":
-        dialTags.labelPosition = "right";
-        break;
-      case "label-center":
-      case "label-middle":
-      case "center":
-      case "middle":
-        dialTags.labelPosition = "center";
-        break;
-      case "label-top":
-      case "top":
-        dialTags.labelPosition = "top";
-        break;
-      case "label-bottom":
-      case "bottom":
-        dialTags.labelPosition = "bottom";
-        break;
-      case "label-inline":
-      case "inline":
-        dialTags.labelPosition = "inline";
-        break;
-      case "no-wrap":
-        dialTags.noWrap = true;
-        break;
-      default:
-        break;
-    }
-  }
-  return dialTags;
-}
-function propToDialSchema(propName, propData, groupConfigs) {
-  const description = propData.description || "";
-  const dialTags = parseDialTags(description);
-  if (dialTags.ignore) {
-    return null;
-  }
-  let dtype = dialTags.dtype;
-  if (!dtype) {
-    const type = propData.type;
-    const typeName = type?.name || "";
-    if (typeName === "boolean") {
-      dtype = "boolean";
-    } else if (typeName === "number") {
-      dtype = "number";
-    } else if (typeName.includes("[]")) {
-      dtype = "array";
-    } else {
-      dtype = "string";
-    }
-  }
-  const schema = {
-    name: propName,
-    dtype
-  };
-  if (dialTags.default !== void 0) {
-    schema.value = dialTags.default;
-  } else {
-    const defaultValue = propData.defaultValue;
-    if (defaultValue?.value) {
-      try {
-        schema.value = JSON.parse(defaultValue.value);
-      } catch {
-        schema.value = defaultValue.value;
-      }
-    }
-  }
-  if (dialTags.min !== void 0) schema.min = dialTags.min;
-  if (dialTags.max !== void 0) schema.max = dialTags.max;
-  if (dialTags.step !== void 0) schema.step = dialTags.step;
-  if (dialTags.options) schema.options = dialTags.options;
-  if (dialTags.icon) schema.icon = dialTags.icon;
-  if (dialTags.placeholders) schema.placeholders = dialTags.placeholders;
-  if (dialTags.tooltips) schema.tooltips = dialTags.tooltips;
-  if (dialTags.dtypes) schema.dtypes = dialTags.dtypes;
-  if (dialTags.mins) schema.mins = dialTags.mins;
-  if (dialTags.maxs) schema.maxs = dialTags.maxs;
-  if (dialTags.steps) schema.steps = dialTags.steps;
-  const tags = {};
-  if (dialTags.grouping) {
-    tags.grouping = dialTags.grouping;
-    if (groupConfigs && groupConfigs[dialTags.grouping]?.noWrap) {
-      tags.noWrap = true;
-    }
-  }
-  if (dialTags.column) {
-    tags.col = true;
-  }
-  if (dialTags.rowCount) {
-    tags.row = dialTags.rowCount;
-    tags.layout = "row";
-  }
-  if (dialTags.colCount) {
-    tags.col = dialTags.colCount;
-    tags.layout = "column";
-  }
-  if (dialTags.labelPosition) {
-    tags.labelPosition = dialTags.labelPosition;
-  }
-  if (Object.keys(tags).length > 0) {
-    schema.tags = tags;
-  }
-  return schema;
-}
-async function processFile(filePath, outputDir, options, flags = {}) {
-  if (!flags.quiet) {
-    console.log(`
-\u{1F4E6} Processing ${filePath}...`);
-  }
-  const docs = docgen.parse(filePath, options);
-  const sourceCode = readFileSync(filePath, "utf-8");
-  const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
-  const enhancedMetadata = docs.map((doc) => {
-    const dialSchema = [];
-    const groupConfigs = {};
-    if (doc.description) {
-      const componentTags = parseDialTags(doc.description);
-      const descLines = doc.description.split("\n");
-      descLines.forEach((line) => {
-        const groupMatch = line.match(/@dial\s+(\w+)(.*)/);
-        if (groupMatch) {
-          const groupName = groupMatch[1];
-          const configStr = groupMatch[2];
-          if (configStr.includes("@dial-no-wrap")) {
-            groupConfigs[groupName] = { noWrap: true };
-          }
-        }
-      });
-    }
-    const propsInterfaceName = doc.displayName + "Props";
-    function findInterfaceJSDoc(node) {
-      if (ts.isInterfaceDeclaration(node) && node.name.text === propsInterfaceName) {
-        const interfaceJsDocNodes = ts.getJSDocCommentsAndTags(node);
-        if (interfaceJsDocNodes && interfaceJsDocNodes.length > 0) {
-          const interfaceFullText = interfaceJsDocNodes[0].getFullText();
-          const lines = interfaceFullText.split("\n");
-          lines.forEach((line) => {
-            const groupMatch = line.match(/@dial\s+(\w+)(.*)/);
-            if (groupMatch) {
-              const groupName = groupMatch[1];
-              const configStr = groupMatch[2];
-              if (configStr.includes("@dial-no-wrap")) {
-                groupConfigs[groupName] = { noWrap: true };
-              }
-            }
-          });
-        }
-      }
-      ts.forEachChild(node, findInterfaceJSDoc);
-    }
-    findInterfaceJSDoc(sourceFile);
-    for (const [propName, propData] of Object.entries(doc.props || {})) {
-      const propDescription = propData.description || "";
-      const propDialTags = parseDialTags(propDescription);
-      if (propDialTags.ignore) {
-        continue;
-      }
-      const propType = propData.type;
-      const referencedType = propDialTags.type || propType?.name;
-      if (referencedType) {
-        const typeDefinition = parseTypeAlias(sourceFile, referencedType);
-        if (typeDefinition) {
-          const schema = propToDialSchema(propName, propData, groupConfigs);
-          if (!schema) {
-            continue;
-          }
-          if (typeDefinition.elements && typeDefinition.elements.length > 0) {
-            schema.dtype = "vector";
-            const mins = [];
-            const maxs = [];
-            const steps = [];
-            const dtypes = [];
-            const placeholders = [];
-            const tooltips = [];
-            typeDefinition.elements.forEach((element) => {
-              if (element.name) {
-                mins.push(element.min !== void 0 ? element.min : 0);
-                maxs.push(element.max !== void 0 ? element.max : 100);
-                steps.push(element.step !== void 0 ? element.step : 1);
-                dtypes.push(element.dtype || "number");
-                placeholders.push(element.name);
-                const tooltip = element.name.includes("Segments") ? `${element.name.replace("Segments", " segments")}` : element.name.charAt(0).toUpperCase() + element.name.slice(1);
-                tooltips.push(tooltip);
-              }
-            });
-            if (mins.length > 0) schema.mins = mins;
-            if (maxs.length > 0) schema.maxs = maxs;
-            if (steps.length > 0) schema.steps = steps;
-            if (dtypes.length > 0) schema.dtypes = dtypes;
-            if (placeholders.length > 0) schema.placeholders = placeholders;
-            if (tooltips.length > 0) schema.tooltips = tooltips;
-            schema.typeDefinition = typeDefinition;
-          }
-          dialSchema.push(schema);
-          const interfaceProps = parseInterfaceProperties(sourceFile, referencedType);
-          interfaceProps.forEach((prop) => {
-            dialSchema.push({
-              ...prop,
-              name: `${propName}.${prop.name}`,
-              tags: {
-                grouping: "nested",
-                parent: propName,
-                hidden: true,
-                metadata: true
-              }
-            });
-          });
-        } else {
-          const schema = propToDialSchema(propName, propData, groupConfigs);
-          if (schema) {
-            dialSchema.push(schema);
-          }
-        }
-      } else {
-        const schema = propToDialSchema(propName, propData, groupConfigs);
-        if (schema) {
-          dialSchema.push(schema);
-        }
-      }
-    }
-    return {
-      displayName: doc.displayName,
-      description: doc.description,
-      dialSchema,
-      groupConfigs,
-      props: doc.props
-    };
-  });
-  if (!existsSync(outputDir)) {
-    mkdirSync(outputDir, { recursive: true });
-  }
-  const baseName = basename(filePath, ".tsx").toLowerCase();
-  writeFileSync(join(outputDir, `${baseName}-raw.json`), JSON.stringify(docs, null, 2));
-  if (!flags.quiet) {
-    console.log(`\u{1F4DD} Wrote raw metadata to ${baseName}-raw.json`);
-  }
-  writeFileSync(
-    join(outputDir, `${baseName}-combined.json`),
-    JSON.stringify(enhancedMetadata, null, 2)
-  );
-  if (!flags.quiet) {
-    console.log(`\u{1F4DD} Wrote enhanced metadata to ${baseName}-combined.json`);
-  }
-  const schemas = enhancedMetadata.map((c) => {
-    const groups = Object.entries(c.groupConfigs || {}).map(([name, config]) => ({
-      name,
-      ...config
-    }));
-    return {
-      component: c.displayName,
-      schemas: c.dialSchema,
-      groups: groups.length > 0 ? groups : void 0,
-      config: c.dialConfig
-    };
-  });
-  writeFileSync(join(outputDir, `${baseName}-schemas.json`), JSON.stringify(schemas, null, 2));
-  if (!flags.quiet) {
-    console.log(`\u{1F4DD} Wrote dial schemas to ${baseName}-schemas.json`);
-  }
-  if (flags.verbose && enhancedMetadata.length > 0) {
-    console.log("\n\u{1F4CA} Generated dial schemas:");
-    enhancedMetadata.forEach((meta) => {
-      console.log(`
-  Component: ${meta.displayName}`);
-      console.log(`  Properties: ${meta.dialSchema.length}`);
-      if (meta.dialSchema.length > 0) {
-        console.log(`  Sample schema:`);
-        console.log(JSON.stringify(meta.dialSchema[0], null, 4).split("\n").map((line) => "    " + line).join("\n"));
-      }
-    });
-  }
-}
-function getHelpText() {
-  const { version, gitHash } = getVersionInfo();
-  const versionString = gitHash ? `v${version} (${gitHash})` : `v${version}`;
-  return `
-dial-cli - Generate dial metadata from TypeScript/React components
-
-SYNOPSIS
-  dial-cli [options] <file.tsx> [file2.tsx ...]
-
-DESCRIPTION
-  The dial-cli tool parses TypeScript and React component files to extract
-  @dial annotations from JSDoc comments and generates JSON metadata files
-  that can be used to automatically create UI controls.
-
-  The tool generates three types of output files for each input:
-    \u2022 *-raw.json      - Raw output from react-docgen-typescript
-    \u2022 *-combined.json - Enhanced metadata with dial schema information
-    \u2022 *-schemas.json  - Just the dial schemas for UI generation
-
-OPTIONS
-  -o, --output <dir>
-      Output directory for generated metadata files (default: ./metadata)
-
-  -i, --ignore <prop>
-      Property names or patterns to exclude from dial schema generation
-      Can be specified multiple times: -i prop1 -i prop2
-      Or as a comma-separated list: -i prop1,prop2,prop3
-      Supports glob patterns: -i "*Style" -i "on*" -i "_*"
-
-  -h, --help
-      Display this help message and exit
-
-  -v, --version
-      Display version information and exit
-
-  --verbose
-      Enable verbose output with detailed processing information
-
-  --quiet
-      Suppress all output except errors
-
-DIAL ANNOTATIONS
-  The tool recognizes the following @dial annotations in JSDoc comments:
-
-  Grouping:
-    @dial <group>           Group related properties (transform, visibility, etc.)
-
-  Property Configuration:
-    @dial-dtype <type>      Data type (vector3, euler, boolean, int, etc.)
-    @dial-min <number>      Minimum value for numeric inputs
-    @dial-max <number>      Maximum value for numeric inputs
-    @dial-step <number>     Step increment for numeric inputs
-    @dial-default <value>   Default value (overrides component default)
-    @dial-options [...]     Array of preset values
-    @dial-icon <name>       Lucide icon name for the control
-    @dial-ignore            Exclude this property from dial schema generation
-
-  FormLayout:
-    @dial-col-<n>          Display in column layout with n columns
-    @dial-row-<n>          Display in row layout with n items per row
-    @dial-label-<pos>      Label position (left, right, top, bottom, inline)
-
-  Vector Types:
-    @dial-mins <n,n,n>     Comma-separated min values for vector elements
-    @dial-maxs <n,n,n>     Comma-separated max values for vector elements
-    @dial-steps <n,n,n>    Comma-separated step values for vector elements
-    @dial-dtypes <t,t,t>   Comma-separated data types for vector elements
-
-EXAMPLES
-  Generate metadata for a single component:
-    $ dial-cli MyComponent.tsx
-
-  Specify a custom output directory:
-    $ dial-cli -o ./docs/metadata MyComponent.tsx
-
-  Process multiple files:
-    $ dial-cli Component1.tsx Component2.tsx Component3.tsx
-
-  Process all components in a directory:
-    $ dial-cli src/components/*.tsx
-
-  Generate metadata with verbose output:
-    $ dial-cli --verbose MyComponent.tsx
-
-  Exclude specific properties from schema generation:
-    $ dial-cli -i className -i style -i children MyComponent.tsx
-    $ dial-cli --ignore ref,key,id MyComponent.tsx
-
-EXAMPLE COMPONENT
-  interface Props {
-    /**
-     * Position in 3D space
-     * @dial transform
-     * @dial-dtype vector3
-     * @dial-mins -10,-10,-10
-     * @dial-maxs 10,10,10
-     * @dial-steps 0.1,0.1,0.1
-     * @dial-icon Move3d
-     */
-    position: [number, number, number];
-
-    /**
-     * Visibility toggle
-     * @dial visibility
-     * @dial-dtype boolean
-     * @dial-icon Eye
-     */
-    visible: boolean;
-  }
-
-FILES
-  The tool generates the following files in the output directory:
-
-    <component>-raw.json
-        Raw docgen output with all prop information
-
-    <component>-combined.json
-        Enhanced metadata including dial schemas and type definitions
-
-    <component>-schemas.json
-        Extracted dial schemas ready for UI generation
-
-ENVIRONMENT
-  NODE_ENV
-      Set to 'development' for debug output
-
-SEE ALSO
-  Documentation: https://uikit.vuer.ai/dial
-  GitHub: https://github.com/vuer-ai/vuer-uikit
-
-VERSION
-  dial-cli ${versionString} (part of @vuer-ai/vuer-uikit)
-
-AUTHORS
-  Vuer AI Team <team@vuer.ai>
-`;
-}
-async function main() {
-  const { values, positionals } = parseArgs({
-    args: process.argv.slice(2),
-    options: {
-      output: {
-        type: "string",
-        short: "o",
-        default: "./metadata"
-      },
-      ignore: {
-        type: "string",
-        short: "i",
-        multiple: true,
-        default: []
-      },
-      help: {
-        type: "boolean",
-        short: "h"
-      },
-      version: {
-        type: "boolean",
-        short: "v"
-      },
-      verbose: {
-        type: "boolean"
-      },
-      quiet: {
-        type: "boolean"
-      }
-    },
-    allowPositionals: true
-  });
-  if (values.version) {
-    const { version, gitHash } = getVersionInfo();
-    const versionString = gitHash ? `v${version} (${gitHash})` : `v${version}`;
-    console.log(`dial-cli ${versionString} (part of @vuer-ai/vuer-uikit)`);
-    process.exit(0);
-  }
-  if (values.help || positionals.length === 0) {
-    console.log(getHelpText());
-    process.exit(0);
-  }
-  if (positionals.length === 1 && (positionals[0] === "man" || positionals[0] === "help")) {
-    console.log(getHelpText());
-    process.exit(0);
-  }
-  const outputDir = resolve(process.cwd(), values.output);
-  const ignoreList = [];
-  const ignoreValues = values.ignore;
-  if (ignoreValues) {
-    if (Array.isArray(ignoreValues)) {
-      ignoreValues.forEach((val) => {
-        ignoreList.push(...val.split(",").map((s) => s.trim()));
-      });
-    } else if (typeof ignoreValues === "string") {
-      ignoreList.push(...ignoreValues.split(",").map((s) => s.trim()));
-    }
-  }
-  const options = {
-    savePropValueAsString: true,
-    shouldExtractLiteralValuesFromEnum: true,
-    shouldRemoveUndefinedFromOptional: true,
-    propFilter: (prop) => {
-      if (prop.name === "ref" || prop.name === "key") {
-        return false;
-      }
-      for (const pattern of ignoreList) {
-        if (pattern.includes("*") || pattern.includes("?")) {
-          const regex = new RegExp("^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$");
-          if (regex.test(prop.name)) {
-            return false;
-          }
-        } else if (prop.name === pattern) {
-          return false;
-        }
-      }
-      return true;
-    }
-  };
-  const flags = {
-    verbose: values.verbose,
-    quiet: values.quiet,
-    ignoreList
-  };
-  if (!flags.quiet) {
-    const { version, gitHash } = getVersionInfo();
-    const versionString = gitHash ? `v${version} (${gitHash})` : `v${version}`;
-    console.log(`\u{1F680} Dial Documentation Generator ${versionString}`);
-    console.log(`\u{1F4C2} Output directory: ${outputDir}`);
-    if (flags.verbose && ignoreList.length > 0) {
-      console.log(`\u{1F6AB} Ignoring properties: ${ignoreList.join(", ")}`);
-    }
-  }
-  let filesProcessed = 0;
-  let filesErrored = 0;
-  for (const file of positionals) {
-    const filePath = resolve(process.cwd(), file);
-    if (!existsSync(filePath)) {
-      console.error(`\u274C File not found: ${filePath}`);
-      filesErrored++;
-      continue;
-    }
-    try {
-      await processFile(filePath, outputDir, options, flags);
-      filesProcessed++;
-    } catch (error) {
-      console.error(`\u274C Error processing ${filePath}:`, error);
-      filesErrored++;
-    }
-  }
-  if (!flags.quiet) {
-    console.log("\n\u2705 Documentation generation complete!");
-    if (flags.verbose) {
-      console.log(`   Files processed: ${filesProcessed}`);
-      if (filesErrored > 0) {
-        console.log(`   Files with errors: ${filesErrored}`);
-      }
-    }
-  }
-}
-main().catch((error) => {
-  console.error("Fatal error:", error);
-  process.exit(1);
-});
-export {
-  parseDialTags,
-  parseInterfaceProperties,
-  parseTypeAlias,
-  propToDialSchema
-};