@nimbalyst/extension-sdk 0.1.0

package/dist/externalsPlugin.js

@@ -0,0 +1,251 @@
+/**
+ * Vite/Rollup plugin that transforms external imports to window.__nimbalyst_extensions references.
+ *
+ * This plugin runs at BUILD TIME, transforming imports BEFORE minification.
+ * This is more robust than runtime regex transformation because:
+ * 1. Source code has predictable import syntax
+ * 2. Minification happens AFTER transformation
+ * 3. Build errors are caught early
+ *
+ * HOW IT WORKS:
+ * Instead of marking modules as "external" (which keeps bare import statements that
+ * blob URLs can't resolve), we resolve imports to virtual modules that access
+ * window.__nimbalyst_extensions at runtime.
+ *
+ * Example:
+ *   import React, { useState } from 'react'
+ *   ->
+ *   // Generated virtual module gets bundled inline:
+ *   const __mod = window.__nimbalyst_extensions["react"];
+ *   export default __mod;
+ *   export const useState = __mod.useState;
+ *   // etc.
+ *
+ * The extension's code then imports from this virtual module, which after bundling
+ * becomes direct property accesses on window.__nimbalyst_extensions.
+ */
+/**
+ * Map of external module names to their window.__nimbalyst_extensions keys.
+ */
+const EXTERNALS_MAP = {
+    // React
+    react: 'react',
+    'react-dom': 'react-dom',
+    'react-dom/client': 'react-dom/client',
+    'react/jsx-runtime': 'react/jsx-runtime',
+    'react/jsx-dev-runtime': 'react/jsx-dev-runtime',
+    // Lexical
+    lexical: 'lexical',
+    '@lexical/react/LexicalComposerContext': '@lexical/react/LexicalComposerContext',
+    '@lexical/react/useLexicalEditable': '@lexical/react/useLexicalEditable',
+    '@lexical/react/useLexicalNodeSelection': '@lexical/react/useLexicalNodeSelection',
+    '@lexical/utils': '@lexical/utils',
+    '@lexical/markdown': '@lexical/markdown',
+    // Nimbalyst runtime
+    '@nimbalyst/editor-context': '@nimbalyst/editor-context',
+    '@nimbalyst/runtime/ui/icons/MaterialSymbol': '@nimbalyst/runtime/ui/icons/MaterialSymbol',
+    '@nimbalyst/screenshot-service': '@nimbalyst/screenshot-service',
+    '@nimbalyst/datamodel-platform-service': '@nimbalyst/datamodel-platform-service',
+    // Shared libraries
+    'pdfjs-dist': 'pdfjs-dist',
+    virtua: 'virtua',
+};
+/**
+ * Check if a module ID matches any external pattern.
+ * Returns the key to use in window.__nimbalyst_extensions or null if not external.
+ */
+function getExternalKey(id) {
+    // Direct match
+    if (EXTERNALS_MAP[id]) {
+        return EXTERNALS_MAP[id];
+    }
+    // Pattern match for @lexical/* and @nimbalyst/runtime/*
+    if (id.startsWith('@lexical/')) {
+        return id;
+    }
+    if (id.startsWith('@nimbalyst/runtime')) {
+        return id;
+    }
+    return null;
+}
+/**
+ * Creates a Vite plugin that transforms external imports at build time.
+ *
+ * This approach uses renderChunk to transform the final output after bundling
+ * but captures the original import information during the transform phase.
+ *
+ * The key insight: we DON'T mark these as external. Instead, we let Rollup
+ * try to resolve them, fail, and then our resolveId catches them and returns
+ * a virtual module. The virtual module's code accesses window.__nimbalyst_extensions.
+ */
+export function nimbalystExternalsPlugin() {
+    const virtualModulePrefix = '\0nimbalyst-external:';
+    return {
+        name: 'nimbalyst-externals',
+        enforce: 'pre',
+        resolveId(source, _importer, _options) {
+            const externalKey = getExternalKey(source);
+            if (externalKey) {
+                return virtualModulePrefix + externalKey;
+            }
+            return null;
+        },
+        load(id) {
+            if (!id.startsWith(virtualModulePrefix)) {
+                return null;
+            }
+            const externalKey = id.slice(virtualModulePrefix.length);
+            // Generate a simple module that re-exports from window.__nimbalyst_extensions.
+            // We use a Proxy to handle ANY property access, making this future-proof.
+            // The Proxy ensures that any named import will work without us having to
+            // enumerate all possible exports.
+            return `
+// Virtual module for: ${externalKey}
+// This gets the module from the host at runtime
+const __nimbalyst_mod__ = window.__nimbalyst_extensions?.["${externalKey}"];
+
+if (!__nimbalyst_mod__) {
+  console.error('[Extension] Missing host dependency: ${externalKey}');
+}
+
+// Default export for: import X from '${externalKey}'
+export default __nimbalyst_mod__;
+
+// Create a proxy that allows any named export
+// This handles: import { anything } from '${externalKey}'
+const __proxy__ = new Proxy(__nimbalyst_mod__ || {}, {
+  get(target, prop) {
+    if (prop in target) {
+      return target[prop];
+    }
+    // For properties that don't exist, return undefined
+    // This prevents errors for optional exports
+    return undefined;
+  }
+});
+
+// Re-export common properties explicitly for tree-shaking
+// These are the most commonly used exports from each package type
+${generateCommonExports(externalKey)}
+`;
+        },
+    };
+}
+/**
+ * Generate explicit named exports for common properties.
+ * This helps with tree-shaking while the Proxy handles edge cases.
+ */
+function generateCommonExports(externalKey) {
+    // Determine which exports to generate based on the module
+    let exports = [];
+    if (externalKey === 'react') {
+        exports = [
+            'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext',
+            'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue',
+            'useDeferredValue', 'useTransition', 'useId', 'useSyncExternalStore',
+            'createElement', 'createContext', 'createRef', 'forwardRef', 'lazy', 'memo',
+            'startTransition', 'Children', 'Component', 'Fragment', 'Profiler',
+            'PureComponent', 'StrictMode', 'Suspense', 'cloneElement', 'isValidElement',
+            'version', 'useInsertionEffect', 'cache', 'use', 'act',
+        ];
+    }
+    else if (externalKey === 'react-dom' || externalKey === 'react-dom/client') {
+        exports = [
+            'createRoot', 'hydrateRoot', 'render', 'hydrate', 'createPortal', 'flushSync',
+            'unmountComponentAtNode', 'findDOMNode', 'unstable_batchedUpdates',
+        ];
+    }
+    else if (externalKey === 'react/jsx-runtime' || externalKey === 'react/jsx-dev-runtime') {
+        exports = ['jsx', 'jsxs', 'jsxDEV', 'Fragment'];
+    }
+    else if (externalKey === 'lexical') {
+        exports = [
+            // Selection and state
+            '$getRoot', '$getSelection', '$setSelection', '$insertNodes', '$getNodeByKey',
+            '$createParagraphNode', '$createTextNode', '$createRangeSelection',
+            '$getNearestNodeFromDOMNode', '$nodesOfType',
+            // Type guards
+            '$isRangeSelection', '$isNodeSelection', '$isTextNode', '$isParagraphNode',
+            '$isElementNode', '$isRootNode', '$isDecoratorNode', '$isLineBreakNode',
+            '$isRootOrShadowRoot',
+            // Node operations
+            '$splitNode', '$copyNode', '$generateHtmlFromNodes', '$generateNodesFromDOM',
+            '$applyNodeReplacement',
+            // Command priorities
+            'COMMAND_PRIORITY_LOW', 'COMMAND_PRIORITY_NORMAL', 'COMMAND_PRIORITY_HIGH',
+            'COMMAND_PRIORITY_EDITOR', 'COMMAND_PRIORITY_CRITICAL',
+            // Commands
+            'createCommand', 'SELECTION_CHANGE_COMMAND', 'KEY_ENTER_COMMAND',
+            'KEY_BACKSPACE_COMMAND', 'KEY_DELETE_COMMAND', 'KEY_TAB_COMMAND',
+            'KEY_ESCAPE_COMMAND', 'INSERT_PARAGRAPH_COMMAND', 'INSERT_LINE_BREAK_COMMAND',
+            'PASTE_COMMAND', 'COPY_COMMAND', 'CUT_COMMAND', 'CLICK_COMMAND',
+            'FORMAT_TEXT_COMMAND', 'FORMAT_ELEMENT_COMMAND', 'UNDO_COMMAND', 'REDO_COMMAND',
+            // Editor and nodes
+            'createEditor', 'LineBreakNode', 'ParagraphNode', 'TextNode',
+            'ElementNode', 'DecoratorNode', 'LexicalNode', 'RootNode',
+            // Serialization
+            'SerializedLexicalNode', 'SerializedEditor', 'EditorState',
+            'DOMConversionMap', 'DOMConversionOutput', 'DOMExportOutput',
+            'LexicalEditor', 'EditorConfig', 'NodeKey', 'Spread',
+        ];
+    }
+    else if (externalKey === '@lexical/react/LexicalComposerContext') {
+        exports = ['useLexicalComposerContext', 'LexicalComposerContext', 'createLexicalComposerContext'];
+    }
+    else if (externalKey === '@lexical/react/useLexicalEditable') {
+        exports = ['useLexicalEditable', 'default'];
+    }
+    else if (externalKey === '@lexical/react/useLexicalNodeSelection') {
+        exports = ['useLexicalNodeSelection', 'default'];
+    }
+    else if (externalKey === '@lexical/utils') {
+        exports = [
+            'mergeRegister', '$findMatchingParent', '$getNearestNodeOfType',
+            '$getNearestBlockElementAncestorOrThrow', '$insertNodeToNearestRoot',
+            'addClassNamesToElement', 'removeClassNamesFromElement',
+            'isMimeType', 'mediaFileReader', '$restoreEditorState',
+            'positionNodeOnRange', '$wrapNodeInElement', 'calculateZoomLevel',
+        ];
+    }
+    else if (externalKey === '@lexical/markdown') {
+        exports = [
+            '$convertFromMarkdownString', '$convertToMarkdownString',
+            'TRANSFORMERS', 'registerMarkdownShortcuts',
+            'ELEMENT_TRANSFORMERS', 'TEXT_FORMAT_TRANSFORMERS', 'TEXT_MATCH_TRANSFORMERS',
+            'HEADING', 'QUOTE', 'CODE', 'UNORDERED_LIST', 'ORDERED_LIST',
+            'CHECK_LIST', 'LINK', 'INLINE_CODE', 'BOLD_ITALIC_STAR', 'BOLD_ITALIC_UNDERSCORE',
+            'BOLD_STAR', 'BOLD_UNDERSCORE', 'ITALIC_STAR', 'ITALIC_UNDERSCORE',
+            'STRIKETHROUGH', 'HIGHLIGHT',
+        ];
+    }
+    else if (externalKey === '@nimbalyst/editor-context') {
+        exports = ['useDocumentPath'];
+    }
+    else if (externalKey === '@nimbalyst/runtime/ui/icons/MaterialSymbol') {
+        exports = ['MaterialSymbol'];
+    }
+    else if (externalKey === '@nimbalyst/screenshot-service') {
+        exports = ['screenshotService'];
+    }
+    else if (externalKey === '@nimbalyst/datamodel-platform-service') {
+        exports = ['DataModelPlatformServiceImpl', 'getInstance'];
+    }
+    else if (externalKey === 'pdfjs-dist') {
+        exports = ['getDocument', 'GlobalWorkerOptions', 'version'];
+    }
+    else if (externalKey === 'virtua') {
+        exports = ['VList', 'Virtualizer', 'WindowVirtualizer'];
+    }
+    if (exports.length === 0) {
+        return '// No common exports defined for this module';
+    }
+    // Generate export statements
+    const lines = exports.map(name => {
+        // Handle 'default' specially
+        if (name === 'default') {
+            return `// default export handled above`;
+        }
+        return `export const ${name} = __nimbalyst_mod__?.${name};`;
+    });
+    return lines.join('\n');
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Nimbalyst Extension SDK
+ *
+ * This package provides utilities for building Nimbalyst extensions:
+ * - Vite configuration helpers
+ * - TypeScript types
+ * - Build validation
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import react from '@vitejs/plugin-react';
+ * import { createExtensionConfig } from '@nimbalyst/extension-sdk/vite';
+ *
+ * export default createExtensionConfig({
+ *   entry: './src/index.tsx',
+ *   plugins: [
+ *     react({ jsxRuntime: 'automatic', jsxImportSource: 'react' }),
+ *   ],
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { REQUIRED_EXTERNALS, EXTERNAL_PATTERNS, ROLLUP_EXTERNALS, type RequiredExternal, } from './externals.js';
+export * from './types/index.js';
+export { useEditorLifecycle, type UseEditorLifecycleOptions, type UseEditorLifecycleResult, type DiffState, } from './useEditorLifecycle.js';
+export { useDocumentPath, type DocumentPathContextValue, } from './documentPath.js';
+export { MaterialSymbol } from './MaterialSymbol.js';
+export { createReadOnlyHost, type ReadOnlyHost, type ReadOnlyHostOptions, } from './createReadOnlyHost.js';
+export { copyToClipboard, readClipboard } from './clipboard.js';
+export { validateExtensionBundle, printValidationResult, type ValidationResult, } from './validate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAC;AAGxB,cAAc,kBAAkB,CAAC;AAGjC,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,SAAS,GACf,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,eAAe,EACf,KAAK,wBAAwB,GAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,EACL,kBAAkB,EAClB,KAAK,YAAY,EACjB,KAAK,mBAAmB,GACzB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGhE,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,KAAK,gBAAgB,GACtB,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,39 @@
+/**
+ * Nimbalyst Extension SDK
+ *
+ * This package provides utilities for building Nimbalyst extensions:
+ * - Vite configuration helpers
+ * - TypeScript types
+ * - Build validation
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import react from '@vitejs/plugin-react';
+ * import { createExtensionConfig } from '@nimbalyst/extension-sdk/vite';
+ *
+ * export default createExtensionConfig({
+ *   entry: './src/index.tsx',
+ *   plugins: [
+ *     react({ jsxRuntime: 'automatic', jsxImportSource: 'react' }),
+ *   ],
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+// Re-export externals
+export { REQUIRED_EXTERNALS, EXTERNAL_PATTERNS, ROLLUP_EXTERNALS, } from './externals.js';
+// Re-export types
+export * from './types/index.js';
+// Re-export hooks
+export { useEditorLifecycle, } from './useEditorLifecycle.js';
+// Re-export host-provided editor context and UI helpers for extensions.
+export { useDocumentPath, } from './documentPath.js';
+export { MaterialSymbol } from './MaterialSymbol.js';
+// Re-export read-only host factory (for web viewers and testing)
+export { createReadOnlyHost, } from './createReadOnlyHost.js';
+// Re-export clipboard utilities
+export { copyToClipboard, readClipboard } from './clipboard.js';
+// Re-export validation
+export { validateExtensionBundle, printValidationResult, } from './validate.js';

package/dist/tailwind.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Nimbalyst Tailwind CSS Preset for Extensions
+ *
+ * This preset provides the Nimbalyst theme colors and utilities for use in extensions.
+ * Extensions that use Tailwind CSS should extend this preset to ensure consistent
+ * theming with the host application.
+ *
+ * @example
+ * ```ts
+ * // tailwind.config.ts
+ * import { nimbalystPreset } from '@nimbalyst/extension-sdk/tailwind';
+ *
+ * export default {
+ *   presets: [nimbalystPreset],
+ *   content: ['./src/**\/*.{ts,tsx}'],
+ * };
+ * ```
+ */
+import type { Config } from 'tailwindcss';
+/**
+ * Nimbalyst theme color configuration for Tailwind CSS.
+ * These map to the --nim-* CSS variables defined by the host application.
+ */
+export declare const nimbalystColors: {
+    nim: {
+        DEFAULT: string;
+        secondary: string;
+        tertiary: string;
+        hover: string;
+        selected: string;
+        active: string;
+    };
+    'nim-text': {
+        DEFAULT: string;
+        muted: string;
+        faint: string;
+        disabled: string;
+    };
+    'nim-border': {
+        DEFAULT: string;
+        focus: string;
+    };
+    'nim-primary': {
+        DEFAULT: string;
+        hover: string;
+    };
+    'nim-link': {
+        DEFAULT: string;
+        hover: string;
+    };
+    'nim-success': string;
+    'nim-warning': string;
+    'nim-error': string;
+    'nim-info': string;
+};
+/**
+ * Shorthand background color utilities for common patterns.
+ */
+export declare const nimbalystBackgroundColors: {
+    nim: string;
+    'nim-secondary': string;
+    'nim-tertiary': string;
+    'nim-hover': string;
+    'nim-selected': string;
+    'nim-active': string;
+    'nim-primary': string;
+    'nim-primary-hover': string;
+};
+/**
+ * Shorthand text color utilities for common patterns.
+ */
+export declare const nimbalystTextColors: {
+    nim: string;
+    'nim-muted': string;
+    'nim-faint': string;
+    'nim-disabled': string;
+    'nim-link': string;
+    'nim-link-hover': string;
+    'nim-primary': string;
+    'nim-success': string;
+    'nim-warning': string;
+    'nim-error': string;
+    'nim-info': string;
+};
+/**
+ * Shorthand border color utilities.
+ */
+export declare const nimbalystBorderColors: {
+    nim: string;
+    'nim-focus': string;
+    'nim-primary': string;
+};
+/**
+ * Nimbalyst Tailwind CSS preset.
+ *
+ * Use this preset in your extension's tailwind.config.ts to get access
+ * to the Nimbalyst theme colors and utilities.
+ *
+ * @example
+ * ```ts
+ * // tailwind.config.ts
+ * import { nimbalystPreset } from '@nimbalyst/extension-sdk/tailwind';
+ *
+ * export default {
+ *   presets: [nimbalystPreset],
+ *   content: ['./src/**\/*.{ts,tsx}'],
+ * };
+ * ```
+ */
+export declare const nimbalystPreset: Config;
+export default nimbalystPreset;
+//# sourceMappingURL=tailwind.d.ts.map

package/dist/tailwind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tailwind.d.ts","sourceRoot":"","sources":["../src/tailwind.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsC3B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;CASrC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;CAY/B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;CAIjC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,eAAe,EAAE,MAY7B,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/dist/tailwind.js

@@ -0,0 +1,129 @@
+/**
+ * Nimbalyst Tailwind CSS Preset for Extensions
+ *
+ * This preset provides the Nimbalyst theme colors and utilities for use in extensions.
+ * Extensions that use Tailwind CSS should extend this preset to ensure consistent
+ * theming with the host application.
+ *
+ * @example
+ * ```ts
+ * // tailwind.config.ts
+ * import { nimbalystPreset } from '@nimbalyst/extension-sdk/tailwind';
+ *
+ * export default {
+ *   presets: [nimbalystPreset],
+ *   content: ['./src/**\/*.{ts,tsx}'],
+ * };
+ * ```
+ */
+/**
+ * Nimbalyst theme color configuration for Tailwind CSS.
+ * These map to the --nim-* CSS variables defined by the host application.
+ */
+export const nimbalystColors = {
+    // Nimbalyst theme colors - conventional naming that matches CSS/Tailwind mental models
+    nim: {
+        // Backgrounds (use: bg-nim, bg-nim-secondary, etc.)
+        DEFAULT: 'var(--nim-bg)',
+        secondary: 'var(--nim-bg-secondary)',
+        tertiary: 'var(--nim-bg-tertiary)',
+        hover: 'var(--nim-bg-hover)',
+        selected: 'var(--nim-bg-selected)',
+        active: 'var(--nim-bg-active)',
+    },
+    'nim-text': {
+        // Text (use: text-nim-text, text-nim-text-muted, etc.)
+        DEFAULT: 'var(--nim-text)',
+        muted: 'var(--nim-text-muted)',
+        faint: 'var(--nim-text-faint)',
+        disabled: 'var(--nim-text-disabled)',
+    },
+    'nim-border': {
+        // Borders (use: border-nim-border, border-nim-border-focus)
+        DEFAULT: 'var(--nim-border)',
+        focus: 'var(--nim-border-focus)',
+    },
+    'nim-primary': {
+        // Primary action color (use: bg-nim-primary, text-nim-primary)
+        DEFAULT: 'var(--nim-primary)',
+        hover: 'var(--nim-primary-hover)',
+    },
+    'nim-link': {
+        // Links (use: text-nim-link)
+        DEFAULT: 'var(--nim-link)',
+        hover: 'var(--nim-link-hover)',
+    },
+    // Status colors
+    'nim-success': 'var(--nim-success)',
+    'nim-warning': 'var(--nim-warning)',
+    'nim-error': 'var(--nim-error)',
+    'nim-info': 'var(--nim-info)',
+};
+/**
+ * Shorthand background color utilities for common patterns.
+ */
+export const nimbalystBackgroundColors = {
+    nim: 'var(--nim-bg)',
+    'nim-secondary': 'var(--nim-bg-secondary)',
+    'nim-tertiary': 'var(--nim-bg-tertiary)',
+    'nim-hover': 'var(--nim-bg-hover)',
+    'nim-selected': 'var(--nim-bg-selected)',
+    'nim-active': 'var(--nim-bg-active)',
+    'nim-primary': 'var(--nim-primary)',
+    'nim-primary-hover': 'var(--nim-primary-hover)',
+};
+/**
+ * Shorthand text color utilities for common patterns.
+ */
+export const nimbalystTextColors = {
+    nim: 'var(--nim-text)',
+    'nim-muted': 'var(--nim-text-muted)',
+    'nim-faint': 'var(--nim-text-faint)',
+    'nim-disabled': 'var(--nim-text-disabled)',
+    'nim-link': 'var(--nim-link)',
+    'nim-link-hover': 'var(--nim-link-hover)',
+    'nim-primary': 'var(--nim-primary)',
+    'nim-success': 'var(--nim-success)',
+    'nim-warning': 'var(--nim-warning)',
+    'nim-error': 'var(--nim-error)',
+    'nim-info': 'var(--nim-info)',
+};
+/**
+ * Shorthand border color utilities.
+ */
+export const nimbalystBorderColors = {
+    nim: 'var(--nim-border)',
+    'nim-focus': 'var(--nim-border-focus)',
+    'nim-primary': 'var(--nim-primary)',
+};
+/**
+ * Nimbalyst Tailwind CSS preset.
+ *
+ * Use this preset in your extension's tailwind.config.ts to get access
+ * to the Nimbalyst theme colors and utilities.
+ *
+ * @example
+ * ```ts
+ * // tailwind.config.ts
+ * import { nimbalystPreset } from '@nimbalyst/extension-sdk/tailwind';
+ *
+ * export default {
+ *   presets: [nimbalystPreset],
+ *   content: ['./src/**\/*.{ts,tsx}'],
+ * };
+ * ```
+ */
+export const nimbalystPreset = {
+    content: [],
+    darkMode: ['class', '[data-theme="dark"], [data-theme="crystal-dark"]'],
+    theme: {
+        extend: {
+            colors: nimbalystColors,
+            backgroundColor: nimbalystBackgroundColors,
+            textColor: nimbalystTextColors,
+            borderColor: nimbalystBorderColors,
+        },
+    },
+    plugins: [],
+};
+export default nimbalystPreset;