uifork 0.0.1 → 0.0.2

package/README.md

@@ -1,5 +1,131 @@
 # uifork
 
-⚠️ Placeholder package.
+A CLI tool for managing UI component versions and switching between them.
 
-This name is reserved. Initial release coming soon.
+## Installation
+
+### Global Installation
+
+```bash
+npm install -g uifork
+```
+
+### Local Development Setup
+
+1. Clone this repository
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+3. Make the CLI script executable:
+   ```bash
+   chmod +x cli.js
+   ```
+4. Link the package globally for development:
+   ```bash
+   npm link
+   ```
+
+## Usage
+
+### Initialize a UI Switcher
+
+Convert a single component file into a versioned UI switcher:
+
+```bash
+uifork init frontend/src/SomeDropdownComponent.tsx
+```
+
+This will:
+
+- Rename the original file to `ComponentName.v1.tsx` (or `.ts`)
+- Generate a `ComponentName.versions.ts` file
+- Create a `ComponentName.UISwitcher.tsx` component
+- Create a `ComponentName.tsx` wrapper file that exports the component
+
+### Watch for Changes
+
+Watch a component directory for version file changes:
+
+```bash
+uifork watch SomeDropdownComponent
+```
+
+The watch command will:
+
+- Automatically find files matching `*.versions.ts` pattern
+- Watch for new version files (ComponentName.v*.tsx or ComponentName.v*.ts)
+- Auto-update imports in `versions.ts`
+- Handle file renames bidirectionally
+
+### Promote a Version
+
+Promote a specific version to be the main component and remove all versioning scaffolding:
+
+```bash
+uifork promote SomeDropdownComponent v2
+```
+
+This will:
+
+- Replace `ComponentName.tsx` with the content from `ComponentName.v2.tsx`
+- Delete all version files (`ComponentName.v*.tsx`)
+- Delete `ComponentName.versions.ts`
+- Delete `ComponentName.UISwitcher.tsx`
+- Effectively "undo" the versioning system, leaving just the promoted version as the main component
+
+## Component Structure
+
+After running `uifork init`, your component files will be created in the same directory:
+
+```
+src/components/
+├── ComponentName.tsx              # Main wrapper export (use this for imports)
+├── ComponentName.UISwitcher.tsx   # Version switcher component
+├── ComponentName.versions.ts      # Version configuration
+├── ComponentName.v1.tsx           # Your original component (version 1)
+├── ComponentName.v2.tsx           # Additional versions as needed
+└── ComponentName.v1_1.tsx        # Sub-versions (e.g., v1_1, v2_1)
+```
+
+All files are created in the same directory as your original component, using a flat naming convention.
+
+## Adding New Versions
+
+1. Create new version files: `ComponentName.v2.tsx`, `ComponentName.v1_1.tsx`, etc.
+2. Run `uifork watch ComponentName.versions.ts` (or just `uifork watch ComponentName`) to automatically update `versions.ts`
+3. Or manually add imports and version entries to `ComponentName.versions.ts`
+
+## UI Switcher Controls
+
+- **Cmd + Arrow Up/Down**: Cycle through versions
+- **Bottom-right selector**: Click to choose specific version
+- Selections are saved to localStorage per component ID
+
+## Commands
+
+- `uifork init <component-path>` - Initialize a UI switcher from a component file
+- `uifork watch <component-name>` - Watch for version changes in a component
+- `uifork promote <component-path> <version-id>` - Promote a version to be the main component and remove versioning scaffolding
+- `uifork --help` - Show help information
+- `uifork --version` - Show version number
+
+## Examples
+
+```bash
+# Initialize a new UI switcher
+uifork init src/components/Button.tsx
+# Creates: Button.tsx, Button.v1.tsx, Button.versions.ts, Button.UISwitcher.tsx
+
+# Watch for changes (by component name or path)
+uifork watch Button
+# or
+uifork watch src/components/Button.versions.ts
+
+# Promote a version to be the main component (removes all versioning)
+uifork promote Button v2
+# This replaces Button.tsx with Button.v2.tsx and deletes all version files
+
+# Import and use the component
+import Button from './Button'  # Uses Button.tsx wrapper
+```

package/cli.js

@@ -0,0 +1,450 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { UISwitcherScaffold } = require("./lib/init");
+const { VersionSync } = require("./lib/watch");
+const { VersionPromoter } = require("./lib/promote");
+const { findComponentManager } = require("./lib/cli-helpers");
+
+function showHelp() {
+  console.log(`
+uifork - A CLI tool for managing UI component versions
+
+Usage:
+  uifork init <component-path>                    Initialize a new branched component
+  uifork watch [directory]                        Watch for version changes (defaults to current directory)
+  uifork new <component-path> [version-id]        Create a new version
+  uifork duplicate <component-path> <version-id> [target-version]  Duplicate/fork a version
+  uifork rename <component-path> <version-id> <new-version-id>  Rename a version
+  uifork delete <component-path> <version-id>    Delete a version
+  uifork promote <component-path> <version-id>   Promote a version to be the main component
+
+Examples:
+  uifork init frontend/src/SomeDropdownComponent.tsx
+  uifork watch
+  uifork watch ./src
+  uifork new SomeDropdownComponent
+  uifork new SomeDropdownComponent v3
+  uifork duplicate SomeDropdownComponent v1 v2
+  uifork rename SomeDropdownComponent v1 v2
+  uifork delete SomeDropdownComponent v2
+  uifork promote SomeDropdownComponent v2
+
+Commands:
+  init      Convert a single component file into a versioned branched component
+  watch     Start the watch server and discover all versioned components
+  new       Create a new version (auto-increments if version-id not provided)
+  duplicate Duplicate/fork a version (auto-increments target if not provided)
+  rename    Rename a version
+  delete    Delete a version
+  promote   Promote a version to be the main component and remove versioning scaffolding
+
+Options:
+  -h, --help     Show this help message
+  -v, --version  Show version number
+  --W            Don't start watching after init (init command only)
+`);
+}
+
+function showVersion() {
+  const packageJson = require("./package.json");
+  console.log(`uifork v${packageJson.version}`);
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const command = args[0];
+const argument = args[1];
+
+// Handle help and version flags
+if (args.includes("-h") || args.includes("--help")) {
+  showHelp();
+  process.exit(0);
+}
+
+if (args.includes("-v") || args.includes("--version")) {
+  showVersion();
+  process.exit(0);
+}
+
+// Handle commands
+switch (command) {
+  case "init":
+    if (!argument) {
+      console.error("Error: Component path is required for init command");
+      console.error("Usage: uifork init <component-path>");
+      console.error(
+        "Example: uifork init frontend/src/modules/chart-builder/ZoomDatePickerDropdown.tsx",
+      );
+      process.exit(1);
+    }
+
+    try {
+      const shouldWatch = !args.includes("--W");
+      const scaffolder = new UISwitcherScaffold(argument, shouldWatch);
+      scaffolder.scaffold();
+    } catch (error) {
+      console.error(`Error during scaffolding: ${error.message}`);
+      process.exit(1);
+    }
+    break;
+
+  case "watch":
+    // Watch can be called without arguments - defaults to current directory
+    try {
+      new VersionSync(argument || process.cwd());
+    } catch (error) {
+      console.error(`Error during watching: ${error.message}`);
+      process.exit(1);
+    }
+    break;
+
+  case "promote":
+    if (!argument) {
+      console.error(
+        "Error: Component path and version ID are required for promote command",
+      );
+      console.error("Usage: uifork promote <component-path> <version-id>");
+      console.error("Example: uifork promote SomeDropdownComponent v2");
+      console.error(
+        "Example: uifork promote frontend/src/SomeDropdownComponent.tsx v1_2",
+      );
+      process.exit(1);
+    }
+
+    const versionId = args[2];
+    if (!versionId) {
+      console.error("Error: Version ID is required for promote command");
+      console.error("Usage: uifork promote <component-path> <version-id>");
+      console.error("Example: uifork promote SomeDropdownComponent v2");
+      console.error(
+        "Example: uifork promote frontend/src/SomeDropdownComponent.tsx v1_2",
+      );
+      process.exit(1);
+    }
+
+    try {
+      const promoter = new VersionPromoter(argument, versionId);
+      promoter.promote();
+    } catch (error) {
+      console.error(`Error during promotion: ${error.message}`);
+      process.exit(1);
+    }
+    break;
+
+  case "new":
+  case "create":
+    if (!argument) {
+      console.error("Error: Component path is required");
+      console.error("Usage: uifork new <component-path> [version-id]");
+      console.error("Example: uifork new SomeDropdownComponent");
+      console.error("Example: uifork new SomeDropdownComponent v3");
+      process.exit(1);
+    }
+
+    try {
+      const manager = findComponentManager(argument);
+      const versionId = args[2]; // Optional version ID
+
+      let targetVersion;
+      if (versionId) {
+        if (!manager.validateVersionKey(versionId)) {
+          throw new Error(`Invalid version format: ${versionId}`);
+        }
+        targetVersion = versionId;
+      } else {
+        const nextVersionNum = manager.getNextVersionNumber();
+        targetVersion = manager.versionNumberToKey(nextVersionNum);
+      }
+
+      const targetFilePath = manager.getVersionFilePath(targetVersion);
+      if (fs.existsSync(targetFilePath)) {
+        throw new Error(`Version already exists: ${targetVersion}`);
+      }
+
+      const extension = manager.getMostCommonExtension();
+      const fileVersion = manager.versionKeyToFileVersion(targetVersion);
+      const finalFilePath = path.join(
+        manager.watchDir,
+        `${manager.componentName}.v${fileVersion}${extension}`,
+      );
+
+      const displayVersion = targetVersion
+        .replace(/^v/, "")
+        .replace(/_/g, ".")
+        .toUpperCase();
+
+      const importSuffix = manager.versionToImportSuffix(fileVersion);
+      const componentName = `${manager.componentName}${importSuffix}`;
+
+      let templateContent;
+      if (extension === ".tsx" || extension === ".jsx") {
+        templateContent = `import React from 'react';
+
+export default function ${componentName}() {
+  return (
+    <div>
+      ${displayVersion}
+    </div>
+  );
+}
+`;
+      } else {
+        templateContent = `import React from 'react';
+
+export default function ${componentName}() {
+  return React.createElement('div', null, '${displayVersion}');
+}
+`;
+      }
+
+      fs.writeFileSync(finalFilePath, templateContent, "utf8");
+      manager.generateVersionsFile();
+
+      console.log(`✅ Created new version: ${targetVersion}`);
+      console.log(`   Component: ${manager.componentName}`);
+      console.log(`   File: ${path.basename(finalFilePath)}`);
+    } catch (error) {
+      console.error(`Error creating version: ${error.message}`);
+      process.exit(1);
+    }
+    break;
+
+  case "duplicate":
+  case "fork":
+    if (!argument) {
+      console.error("Error: Component path and version ID are required");
+      console.error(
+        "Usage: uifork duplicate <component-path> <version-id> [target-version]",
+      );
+      console.error("Example: uifork duplicate SomeDropdownComponent v1");
+      console.error("Example: uifork duplicate SomeDropdownComponent v1 v2");
+      process.exit(1);
+    }
+
+    const sourceVersion = args[2];
+    if (!sourceVersion) {
+      console.error("Error: Source version ID is required");
+      console.error(
+        "Usage: uifork duplicate <component-path> <version-id> [target-version]",
+      );
+      process.exit(1);
+    }
+
+    try {
+      const manager = findComponentManager(argument);
+
+      if (!manager.validateVersionKey(sourceVersion)) {
+        throw new Error(`Invalid source version format: ${sourceVersion}`);
+      }
+
+      const sourceFilePath = manager.getVersionFilePath(sourceVersion);
+      if (!fs.existsSync(sourceFilePath)) {
+        throw new Error(`Source version file not found: ${sourceVersion}`);
+      }
+
+      let targetVersion;
+      const newVersion = args[3]; // Optional target version
+      if (newVersion) {
+        if (!manager.validateVersionKey(newVersion)) {
+          throw new Error(`Invalid target version format: ${newVersion}`);
+        }
+        targetVersion = newVersion;
+      } else {
+        const nextVersionNum = manager.getNextVersionNumber();
+        targetVersion = manager.versionNumberToKey(nextVersionNum);
+      }
+
+      const targetFilePath = manager.getVersionFilePath(targetVersion);
+      if (fs.existsSync(targetFilePath)) {
+        throw new Error(`Target version already exists: ${targetVersion}`);
+      }
+
+      const sourceContent = fs.readFileSync(sourceFilePath, "utf8");
+      const extension = path.extname(sourceFilePath);
+      const fileVersion = manager.versionKeyToFileVersion(targetVersion);
+      const finalTargetPath = path.join(
+        manager.watchDir,
+        `${manager.componentName}.v${fileVersion}${extension}`,
+      );
+
+      fs.writeFileSync(finalTargetPath, sourceContent, "utf8");
+      manager.generateVersionsFile();
+
+      console.log(`✅ Duplicated version: ${sourceVersion} → ${targetVersion}`);
+      console.log(`   Component: ${manager.componentName}`);
+      console.log(`   Source: ${path.basename(sourceFilePath)}`);
+      console.log(`   Target: ${path.basename(finalTargetPath)}`);
+    } catch (error) {
+      console.error(`Error duplicating version: ${error.message}`);
+      process.exit(1);
+    }
+    break;
+
+  case "rename":
+    if (!argument) {
+      console.error(
+        "Error: Component path, version ID, and new version ID are required",
+      );
+      console.error(
+        "Usage: uifork rename <component-path> <version-id> <new-version-id>",
+      );
+      console.error("Example: uifork rename SomeDropdownComponent v1 v2");
+      process.exit(1);
+    }
+
+    const oldVersion = args[2];
+    const newVersionId = args[3];
+
+    if (!oldVersion || !newVersionId) {
+      console.error("Error: Both version ID and new version ID are required");
+      console.error(
+        "Usage: uifork rename <component-path> <version-id> <new-version-id>",
+      );
+      process.exit(1);
+    }
+
+    try {
+      const manager = findComponentManager(argument);
+
+      if (!manager.validateVersionKey(oldVersion)) {
+        throw new Error(`Invalid source version format: ${oldVersion}`);
+      }
+
+      if (!manager.validateVersionKey(newVersionId)) {
+        throw new Error(`Invalid target version format: ${newVersionId}`);
+      }
+
+      if (oldVersion === newVersionId) {
+        throw new Error("Source and target versions are the same");
+      }
+
+      const fileVersion = manager.versionKeyToFileVersion(oldVersion);
+      const extensions = [".tsx", ".ts", ".jsx", ".js"];
+      let sourceFilePath = null;
+
+      for (const ext of extensions) {
+        const candidatePath = path.join(
+          manager.watchDir,
+          `${manager.componentName}.v${fileVersion}${ext}`,
+        );
+        if (fs.existsSync(candidatePath)) {
+          sourceFilePath = candidatePath;
+          break;
+        }
+      }
+
+      if (!sourceFilePath) {
+        throw new Error(
+          `Source version file not found: ${oldVersion}. Checked: ${extensions
+            .map((ext) => `${manager.componentName}.v${fileVersion}${ext}`)
+            .join(", ")}`,
+        );
+      }
+
+      const targetFileVersion = manager.versionKeyToFileVersion(newVersionId);
+      let targetFilePath = null;
+      for (const ext of extensions) {
+        const candidatePath = path.join(
+          manager.watchDir,
+          `${manager.componentName}.v${targetFileVersion}${ext}`,
+        );
+        if (fs.existsSync(candidatePath)) {
+          targetFilePath = candidatePath;
+          break;
+        }
+      }
+
+      if (targetFilePath) {
+        throw new Error(`Target version already exists: ${newVersionId}`);
+      }
+
+      const extension = path.extname(sourceFilePath);
+      const finalTargetPath = path.join(
+        manager.watchDir,
+        `${manager.componentName}.v${targetFileVersion}${extension}`,
+      );
+
+      const sourceContent = fs.readFileSync(sourceFilePath, "utf8");
+
+      const importSuffix = manager.versionToImportSuffix(fileVersion);
+      const newImportSuffix = manager.versionToImportSuffix(targetFileVersion);
+      const oldComponentName = `${manager.componentName}${importSuffix}`;
+      const newComponentName = `${manager.componentName}${newImportSuffix}`;
+
+      const updatedContent = sourceContent.replace(
+        new RegExp(oldComponentName, "g"),
+        newComponentName,
+      );
+
+      fs.writeFileSync(finalTargetPath, updatedContent, "utf8");
+      fs.unlinkSync(sourceFilePath);
+      manager.generateVersionsFile();
+
+      console.log(`✅ Renamed version: ${oldVersion} → ${newVersionId}`);
+      console.log(`   Component: ${manager.componentName}`);
+      console.log(`   Source: ${path.basename(sourceFilePath)}`);
+      console.log(`   Target: ${path.basename(finalTargetPath)}`);
+    } catch (error) {
+      console.error(`Error renaming version: ${error.message}`);
+      process.exit(1);
+    }
+    break;
+
+  case "delete":
+    if (!argument) {
+      console.error("Error: Component path and version ID are required");
+      console.error("Usage: uifork delete <component-path> <version-id>");
+      console.error("Example: uifork delete SomeDropdownComponent v2");
+      process.exit(1);
+    }
+
+    const deleteVersionId = args[2];
+    if (!deleteVersionId) {
+      console.error("Error: Version ID is required");
+      console.error("Usage: uifork delete <component-path> <version-id>");
+      process.exit(1);
+    }
+
+    try {
+      const manager = findComponentManager(argument);
+
+      if (!manager.validateVersionKey(deleteVersionId)) {
+        throw new Error(`Invalid version format: ${deleteVersionId}`);
+      }
+
+      const filePath = manager.getVersionFilePath(deleteVersionId);
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`Version file not found: ${deleteVersionId}`);
+      }
+
+      const versionFiles = manager.getVersionFiles();
+      if (versionFiles.length === 1) {
+        throw new Error(
+          "Cannot delete the last remaining version. At least one version must exist.",
+        );
+      }
+
+      fs.unlinkSync(filePath);
+      manager.generateVersionsFile();
+
+      console.log(`✅ Deleted version: ${deleteVersionId}`);
+      console.log(`   Component: ${manager.componentName}`);
+      console.log(`   File: ${path.basename(filePath)}`);
+    } catch (error) {
+      console.error(`Error deleting version: ${error.message}`);
+      process.exit(1);
+    }
+    break;
+
+  default:
+    if (!command) {
+      showHelp();
+      process.exit(0);
+    } else {
+      console.error(`Unknown command: ${command}`);
+      console.error('Run "uifork --help" for available commands');
+      process.exit(1);
+    }
+}

package/dist/components/BranchedComponent.d.ts

@@ -0,0 +1,10 @@
+import { BranchedComponentProps } from '../types';
+/**
+ * A component that renders a specific version based on localStorage state.
+ * Used to wrap components that have multiple versions managed by uifork.
+ *
+ * The UIFork component controls which version is active by writing to localStorage.
+ * BranchedComponent reads from localStorage and renders the appropriate version.
+ */
+export declare function BranchedComponent<T extends Record<string, unknown>>({ id, versions, props, defaultVersion, }: BranchedComponentProps<T>): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=BranchedComponent.d.ts.map

package/dist/components/BranchedComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BranchedComponent.d.ts","sourceRoot":"","sources":["../../src/components/BranchedComponent.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEvD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACnE,EAAE,EACF,QAAQ,EACR,KAAK,EACL,cAAc,GACf,EAAE,sBAAsB,CAAC,CAAC,CAAC,kDAoF3B"}

package/dist/components/ComponentSelector.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { ComponentInfo } from '../types';
+interface ComponentSelectorProps {
+    selectedComponent: string;
+    onToggle: () => void;
+    onSettingsClick: (e: React.MouseEvent) => void;
+}
+export declare function ComponentSelector({ selectedComponent, onToggle, onSettingsClick, }: ComponentSelectorProps): import("react/jsx-runtime").JSX.Element;
+export declare function ComponentSelectorDropdown({ mountedComponents, selectedComponent, isOpen, position, onSelect, componentSelectorRef, }: {
+    mountedComponents: ComponentInfo[];
+    selectedComponent: string;
+    isOpen: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+    onSelect: (componentName: string) => void;
+    componentSelectorRef: React.RefObject<HTMLDivElement>;
+}): import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=ComponentSelector.d.ts.map

package/dist/components/ComponentSelector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentSelector.d.ts","sourceRoot":"","sources":["../../src/components/ComponentSelector.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,UAAU,sBAAsB;IAC9B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,eAAe,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;CAChD;AAKD,wBAAgB,iBAAiB,CAAC,EAChC,iBAAiB,EACjB,QAAQ,EACR,eAAe,GAChB,EAAE,sBAAsB,2CAiCxB;AAED,wBAAgB,yBAAyB,CAAC,EACxC,iBAAiB,EACjB,iBAAiB,EACjB,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,oBAAoB,GACrB,EAAE;IACD,iBAAiB,EAAE,aAAa,EAAE,CAAC;IACnC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,QAAQ,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,oBAAoB,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;CACvD,kDA6CA"}

package/dist/components/MenuItem.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+interface MenuItemProps {
+    icon: React.ComponentType<{
+        className?: string;
+    }>;
+    label: string;
+    onClick: (e: React.MouseEvent) => void;
+    variant?: "default" | "delete";
+    stopPropagation?: boolean;
+}
+export declare function MenuItem({ icon: Icon, label, onClick, variant, stopPropagation, }: MenuItemProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=MenuItem.d.ts.map

package/dist/components/MenuItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuItem.d.ts","sourceRoot":"","sources":["../../src/components/MenuItem.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,UAAU,aAAa;IACrB,IAAI,EAAE,KAAK,CAAC,aAAa,CAAC;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IACvC,OAAO,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,wBAAgB,QAAQ,CAAC,EACvB,IAAI,EAAE,IAAI,EACV,KAAK,EACL,OAAO,EACP,OAAmB,EACnB,eAAuB,GACxB,EAAE,aAAa,2CAmBf"}

package/dist/components/SettingsView.d.ts

@@ -0,0 +1,12 @@
+interface SettingsViewProps {
+    onBack: () => void;
+    theme: "light" | "dark" | "system";
+    setTheme: (theme: "light" | "dark" | "system") => void;
+    position: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+    setPosition: (position: "top-left" | "top-right" | "bottom-left" | "bottom-right") => void;
+    codeEditor: "vscode" | "cursor";
+    setCodeEditor: (editor: "vscode" | "cursor") => void;
+}
+export declare function SettingsView({ onBack, theme, setTheme, position, setPosition, codeEditor, setCodeEditor, }: SettingsViewProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=SettingsView.d.ts.map

package/dist/components/SettingsView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SettingsView.d.ts","sourceRoot":"","sources":["../../src/components/SettingsView.tsx"],"names":[],"mappings":"AAIA,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IACnC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,KAAK,IAAI,CAAC;IACvD,QAAQ,EAAE,UAAU,GAAG,WAAW,GAAG,aAAa,GAAG,cAAc,CAAC;IACpE,WAAW,EAAE,CACX,QAAQ,EAAE,UAAU,GAAG,WAAW,GAAG,aAAa,GAAG,cAAc,KAChE,IAAI,CAAC;IACV,UAAU,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAChC,aAAa,EAAE,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,KAAK,IAAI,CAAC;CACtD;AAED,wBAAgB,YAAY,CAAC,EAC3B,MAAM,EACN,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,UAAU,EACV,aAAa,GACd,EAAE,iBAAiB,2CA+DnB"}

package/dist/components/Tooltip.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface TooltipProps {
+    label: string;
+    children: React.ReactElement;
+    placement?: "top" | "bottom" | "left" | "right";
+}
+export declare function Tooltip({ label, children, placement }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=Tooltip.d.ts.map

package/dist/components/Tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tooltip.d.ts","sourceRoot":"","sources":["../../src/components/Tooltip.tsx"],"names":[],"mappings":"AACA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAS3D,UAAU,YAAY;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;IAC7B,SAAS,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;CACjD;AAED,wBAAgB,OAAO,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAiB,EAAE,EAAE,YAAY,2CAuL3E"}