@peers-app/peers-ui 0.0.14

package/dist/command-palette/command-palette.js

@@ -0,0 +1,371 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandSearchQuery = exports.isCommandPaletteOpen = void 0;
+exports.registerCommand = registerCommand;
+exports.unregisterCommand = unregisterCommand;
+exports.getCommand = getCommand;
+exports.getAllCommands = getAllCommands;
+exports.searchCommands = searchCommands;
+exports.openCommandPalette = openCommandPalette;
+exports.closeCommandPalette = closeCommandPalette;
+exports.toggleCommandPalette = toggleCommandPalette;
+exports.executeCommand = executeCommand;
+exports.initializeCommandPalette = initializeCommandPalette;
+exports.destroyCommandPalette = destroyCommandPalette;
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+const tabs_state_1 = require("../tabs-layout/tabs-state");
+// Command palette state (using device scope but with temporary defaults)
+exports.isCommandPaletteOpen = (0, peers_sdk_1.deviceVar)('commandPaletteOpen', {
+    defaultValue: false,
+});
+exports.commandSearchQuery = (0, peers_sdk_1.deviceVar)('commandSearchQuery', {
+    defaultValue: '',
+});
+// Command registry
+const registeredCommands = new Map();
+// Detect platform for keyboard shortcuts  
+const isMac = typeof navigator !== 'undefined'
+    ? /Mac|iPod|iPhone|iPad/.test(navigator.userAgent)
+    : false;
+const modKey = isMac ? 'Cmd' : 'Ctrl';
+// Core system commands
+const coreCommands = [
+    {
+        id: 'search',
+        label: 'Search Everything',
+        description: 'Search across all content',
+        shortcut: `${modKey}+K`,
+        iconClassName: 'bi-search',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('search');
+        }
+    },
+    {
+        id: 'close-tab',
+        label: 'Close Tab',
+        description: 'Close the current tab',
+        shortcut: `${modKey}+W`,
+        iconClassName: 'bi-x',
+        category: 'Tabs',
+        action: () => {
+            closeCommandPalette();
+            // Import dynamically to avoid circular dependency
+            Promise.resolve().then(() => __importStar(require('../tabs-layout/tabs-state'))).then(({ closeCurrentTab }) => {
+                closeCurrentTab();
+            });
+        }
+    },
+    {
+        id: 'next-tab',
+        label: 'Next Tab',
+        description: 'Switch to next tab',
+        shortcut: 'Ctrl+Tab',
+        iconClassName: 'bi-arrow-right',
+        category: 'Tabs',
+        action: () => {
+            closeCommandPalette();
+            Promise.resolve().then(() => __importStar(require('../tabs-layout/tabs-state'))).then(({ switchToNextTab }) => {
+                switchToNextTab();
+            });
+        }
+    },
+    {
+        id: 'previous-tab',
+        label: 'Previous Tab',
+        description: 'Switch to previous tab',
+        shortcut: 'Ctrl+Shift+Tab',
+        iconClassName: 'bi-arrow-left',
+        category: 'Tabs',
+        action: () => {
+            closeCommandPalette();
+            Promise.resolve().then(() => __importStar(require('../tabs-layout/tabs-state'))).then(({ switchToPreviousTab }) => {
+                switchToPreviousTab();
+            });
+        }
+    },
+    {
+        id: 'go-home',
+        label: 'Go to Threads',
+        description: 'Navigate to threads/home',
+        shortcut: `${modKey}+H`,
+        iconClassName: 'bi-cpu',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('threads');
+        }
+    },
+    {
+        id: 'go-settings',
+        label: 'Open Settings',
+        description: 'Open application settings',
+        iconClassName: 'bi-gear-fill',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('settings');
+        }
+    },
+    {
+        id: 'go-assistants',
+        label: 'Go to Assistants',
+        description: 'View and manage assistants',
+        iconClassName: 'bi-person-fill-gear',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('assistants');
+        }
+    },
+    {
+        id: 'go-workflows',
+        label: 'Go to Workflows',
+        description: 'View and manage workflows',
+        iconClassName: 'bi-database-fill-gear',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('workflows');
+        }
+    },
+    {
+        id: 'go-tools',
+        label: 'Go to Tools',
+        description: 'View and manage tools',
+        iconClassName: 'bi-tools',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('tools');
+        }
+    },
+    {
+        id: 'go-events',
+        label: 'Go to Events',
+        description: 'View and manage events',
+        iconClassName: 'bi-lightning-charge-fill',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('events');
+        }
+    },
+    {
+        id: 'go-predicates',
+        label: 'Go to Predicates',
+        description: 'View and manage predicates',
+        iconClassName: 'bi-node-plus-fill',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('predicates');
+        }
+    },
+    {
+        id: 'go-peer-types',
+        label: 'Go to Peer Types',
+        description: 'View and manage peer types',
+        iconClassName: 'bi-code-square',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('peer-types');
+        }
+    },
+    {
+        id: 'go-packages',
+        label: 'Go to Packages',
+        description: 'View and manage packages',
+        iconClassName: 'bi-box-fill',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('packages');
+        }
+    },
+    {
+        id: 'go-variables',
+        label: 'Go to Variables',
+        description: 'View and manage variables',
+        iconClassName: 'bi-braces',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('variables');
+        }
+    },
+    {
+        id: 'go-knowledge-values',
+        label: 'Go to Knowledge Values',
+        description: 'View and manage knowledge values',
+        iconClassName: 'bi-journal-bookmark-fill',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('knowledge-values');
+        }
+    },
+    {
+        id: 'go-knowledge-frames',
+        label: 'Go to Knowledge Frames',
+        description: 'View and manage knowledge frames',
+        iconClassName: 'bi-window-dock',
+        category: 'Navigation',
+        action: () => {
+            closeCommandPalette();
+            (0, tabs_state_1.goToTabPath)('knowledge-frames');
+        }
+    }
+];
+// Register core commands
+coreCommands.forEach(cmd => registeredCommands.set(cmd.id, cmd));
+// Command registration functions
+function registerCommand(command) {
+    registeredCommands.set(command.id, command);
+}
+function unregisterCommand(commandId) {
+    registeredCommands.delete(commandId);
+}
+function getCommand(commandId) {
+    return registeredCommands.get(commandId);
+}
+function getAllCommands() {
+    return Array.from(registeredCommands.values()).filter(cmd => !cmd.isAvailable || cmd.isAvailable());
+}
+function searchCommands(query) {
+    if (!query.trim())
+        return getAllCommands();
+    const lowerQuery = query.toLowerCase();
+    return getAllCommands().filter(cmd => cmd.label.toLowerCase().includes(lowerQuery) ||
+        cmd.description?.toLowerCase().includes(lowerQuery) ||
+        cmd.category?.toLowerCase().includes(lowerQuery));
+}
+// Command palette controls
+function openCommandPalette() {
+    (0, exports.isCommandPaletteOpen)(true);
+    (0, exports.commandSearchQuery)('');
+}
+function closeCommandPalette() {
+    (0, exports.isCommandPaletteOpen)(false);
+    (0, exports.commandSearchQuery)('');
+}
+function toggleCommandPalette() {
+    if ((0, exports.isCommandPaletteOpen)()) {
+        closeCommandPalette();
+    }
+    else {
+        openCommandPalette();
+    }
+}
+function executeCommand(commandId) {
+    const command = getCommand(commandId);
+    if (command) {
+        command.action();
+    }
+}
+// Keyboard shortcut handling
+const shortcutToCommandMap = new Map();
+// Build shortcut map from registered commands
+function buildShortcutMap() {
+    shortcutToCommandMap.clear();
+    getAllCommands().forEach(cmd => {
+        if (cmd.shortcut) {
+            shortcutToCommandMap.set(normalizeShortcut(cmd.shortcut), cmd.id);
+        }
+    });
+}
+function normalizeShortcut(shortcut) {
+    return shortcut.toLowerCase()
+        .replace('cmd', 'meta')
+        .replace('command', 'meta')
+        .replace(/\s+/g, '');
+}
+function getKeyFromEvent(event) {
+    const parts = [];
+    if (event.metaKey)
+        parts.push('meta');
+    if (event.ctrlKey)
+        parts.push('ctrl');
+    if (event.altKey)
+        parts.push('alt');
+    if (event.shiftKey)
+        parts.push('shift');
+    parts.push(event.key.toLowerCase());
+    return parts.join('+');
+}
+// Global keyboard event handler
+const handleKeyDown = (event) => {
+    const key = getKeyFromEvent(event);
+    // Handle Cmd+K (Mac) / Ctrl+K (Windows/Linux) to open command palette
+    const paletteShortcut = isMac ? 'meta+k' : 'ctrl+k';
+    if (key === paletteShortcut) {
+        event.preventDefault();
+        toggleCommandPalette();
+        return;
+    }
+    // Handle Escape to close command palette
+    if (key === 'escape' && (0, exports.isCommandPaletteOpen)()) {
+        event.preventDefault();
+        closeCommandPalette();
+        return;
+    }
+    // If command palette is open, don't handle other shortcuts
+    if ((0, exports.isCommandPaletteOpen)()) {
+        return;
+    }
+    // Handle other registered shortcuts
+    const commandId = shortcutToCommandMap.get(key);
+    if (commandId) {
+        event.preventDefault();
+        executeCommand(commandId);
+    }
+};
+// Initialize keyboard shortcuts
+function initializeCommandPalette() {
+    buildShortcutMap();
+    document.addEventListener('keydown', handleKeyDown);
+}
+// Clean up (for testing or hot reloading)
+function destroyCommandPalette() {
+    document.removeEventListener('keydown', handleKeyDown);
+    shortcutToCommandMap.clear();
+}
+// Auto-initialize when this module loads
+if (typeof window !== 'undefined') {
+    initializeCommandPalette();
+}

package/dist/components/checkbox.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface IProps extends React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> {
+    checked: any;
+    type?: React.HTMLInputTypeAttribute;
+}
+export declare function Checkbox(props: IProps): React.JSX.Element;
+export {};

package/dist/components/checkbox.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Checkbox = Checkbox;
+const react_1 = __importDefault(require("react"));
+const hooks_1 = require("../hooks");
+function Checkbox(props) {
+    const [checked, setChecked] = (0, hooks_1.useObservable)(props.checked);
+    const type = props.type ?? 'checkbox';
+    function onChange(evt) {
+        let _value = evt.target.checked;
+        if (type === 'checkbox') {
+            _value = !!_value;
+        }
+        setChecked(_value);
+    }
+    return (react_1.default.createElement("input", { onChange: onChange, type: type, ...props, checked: checked }));
+}

package/dist/components/group-switcher.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface GroupSwitcherProps {
+    colorMode: string;
+}
+export declare function GroupSwitcher({ colorMode }: GroupSwitcherProps): React.JSX.Element;
+export {};