@orca-pt/orca-components 1.0.1

package/dist/components/renderers/OrcaYouTube.vue.d.ts

@@ -0,0 +1,10 @@
+/**
+ * OrcaYouTube - Renders YouTube video embed
+ * Converts YouTube URLs to embed format and displays in iframe
+ */
+type __VLS_Props = {
+    url: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/composables/__tests__/useContentParser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/composables/core/index.d.ts

@@ -0,0 +1,3 @@
+export { findMatches, type MatchCandidate, type ValidMatch, } from "./matchFinder";
+export { processMatch } from "./matchProcessor";
+export { parseContentRecursively } from "./recursiveParser";

package/dist/composables/core/matchFinder.d.ts

@@ -0,0 +1,13 @@
+import type { ContentPartType } from "../../types";
+export type MatchCandidate = {
+    type: ContentPartType;
+    match: RegExpMatchArray | null;
+    index: number;
+};
+export type ValidMatch = MatchCandidate & {
+    match: RegExpMatchArray;
+};
+/**
+ * Find all matches in content
+ */
+export declare function findMatches(content: string): ValidMatch[];

package/dist/composables/core/matchProcessor.d.ts

@@ -0,0 +1,9 @@
+import type { ContentPart, ContentPartType } from "../../types";
+/**
+ * Process match and return content part
+ *
+ * @param type - Content type to process
+ * @param payload - Content payload
+ * @returns ContentPart or null for loading types
+ */
+export declare function processMatch(type: ContentPartType, payload: string): ContentPart | null;

package/dist/composables/core/recursiveParser.d.ts

@@ -0,0 +1,6 @@
+import type { ContentPart } from "../../types";
+/**
+ * Parse content recursively to extract all parts
+ * Used when extracting content from inside loading markers
+ */
+export declare function parseContentRecursively(content: string): ContentPart[];

package/dist/composables/parsers/__tests__/parsers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/composables/parsers/baseParser.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Base Parser Utilities
+ * Common logic for all YAML-like parsers
+ */
+/**
+ * Field definition for parsing
+ */
+export type FieldDef = {
+    name: string;
+    type?: "string" | "number";
+    required?: boolean;
+    defaultValue?: any;
+};
+/**
+ * Parse YAML-like list format into array of objects
+ *
+ * @example
+ * ```
+ * - field1: value1
+ *   field2: value2
+ * - field1: value3  field2: value4
+ * ```
+ */
+export declare function parseYamlList<T>(payload: string, fields: FieldDef[], mapper: (extracted: Record<string, any>) => T): T[];
+/**
+ * Parse simple key-value format
+ *
+ * @example
+ * ```
+ * key1: value1
+ * key2: value2
+ * ```
+ */
+export declare function parseKeyValue(payload: string, fields: string[]): Record<string, string>;

package/dist/composables/parsers/index.d.ts

@@ -0,0 +1,5 @@
+export { parseCard } from "./parseCard";
+export { parseButton } from "./parseButton";
+export { parseAudio } from "./parseAudio";
+export { parseLocation } from "./parseLocation";
+export { parseTracing } from "./parseTracing";

package/dist/composables/parsers/parseAudio.d.ts

@@ -0,0 +1,2 @@
+import type { AudioData } from "../../types";
+export declare function parseAudio(payload: string): AudioData[];

package/dist/composables/parsers/parseButton.d.ts

@@ -0,0 +1,2 @@
+import type { ButtonData } from "../../types";
+export declare function parseButton(payload: string): ButtonData[];

package/dist/composables/parsers/parseCard.d.ts

@@ -0,0 +1,2 @@
+import type { CardData } from "../../types";
+export declare function parseCard(payload: string): CardData[];

package/dist/composables/parsers/parseLocation.d.ts

@@ -0,0 +1,11 @@
+import type { LocationData } from "../../types";
+/**
+ * Parse location data from comma-separated coordinates
+ *
+ * @template
+ * 35.6892, 51.3890
+ *
+ * @example
+ * "35.6892, 51.3890" -> { latitude: 35.6892, longitude: 51.3890 }
+ */
+export declare function parseLocation(payload: string): LocationData;

package/dist/composables/parsers/parseTracing.d.ts

@@ -0,0 +1,9 @@
+import type { TracingData } from "../../types";
+/**
+ * Parse tracing data from YAML-like format
+ *
+ * @template
+ * visibility: all
+ * content: {"request_id": "req_123", "status": "success"}
+ */
+export declare function parseTracing(payload: string): TracingData;

package/dist/composables/parsing/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Utils Module Exports
+ * Clean separation of concerns
+ */
+export { MARKERS, GENERAL_LOADING_TYPES, type MarkerConfig, } from "./markerDefinitions";
+export { escapeRegex, createMarkerPattern, generatePatterns, filterMarkers, getMarkerByType, isLoadingType, isGeneralLoadingType, getMarkersByCategory, getGeneralLoadingMarkers, getContentMarkers, CONTENT_PATTERNS, type PatternDefinition, } from "./markerUtils";
+export { removeMarkers, removeLoadingMarkers, removeContentMarkers, removeAllMarkers, } from "./markerOperations";
+export { removeOnlyLoadingMarkers, removeCompleteMarkers, } from "./markerCleaner";

package/dist/composables/parsing/markerCleaner.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Marker Cleaner Facade
+ * Provides convenient API using pure functions from markerOperations
+ */
+/**
+ * Remove only loading markers (preserves content between them)
+ * Used when processing complete loading blocks
+ */
+export declare function removeOnlyLoadingMarkers(content: string): string;
+/**
+ * Remove complete markers (with both start and end)
+ * Preserves incomplete loading markers (only start, no end)
+ * Used for cleaning text before matches
+ */
+export declare function removeCompleteMarkers(content: string): string;

package/dist/composables/parsing/markerDefinitions.d.ts

@@ -0,0 +1,20 @@
+import type { ContentPartType } from "../../types";
+/**
+ * Marker Types - Pure Data
+ * No logic, just type definitions
+ */
+export type MarkerConfig = {
+    type: ContentPartType;
+    start: string;
+    end: string;
+};
+/**
+ * All marker definitions - Single Source of Truth
+ * ONLY data, no functions
+ */
+export declare const MARKERS: MarkerConfig[];
+/**
+ * General loading type names - Derived from MARKERS
+ * Single source of truth for general loading types
+ */
+export declare const GENERAL_LOADING_TYPES: readonly ["general-loading", "thinking-loading", "searching-loading", "coding-loading", "analyzing-loading", "generating-loading", "custom-loading"];

package/dist/composables/parsing/markerOperations.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Marker Cleaner - Pure Operations
+ * All functions are pure, stateless, and composable
+ */
+import type { MarkerConfig } from "./markerDefinitions";
+/**
+ * Remove markers from content
+ * @param content - Content to clean
+ * @param markers - Markers to remove
+ * @param preserveContent - Keep content between markers or remove entirely
+ */
+export declare function removeMarkers(content: string, markers: MarkerConfig[], preserveContent?: boolean): string;
+/**
+ * Remove only loading markers (preserves content between them)
+ */
+export declare function removeLoadingMarkers(content: string, loadingMarkers: MarkerConfig[]): string;
+/**
+ * Remove content markers (removes everything)
+ */
+export declare function removeContentMarkers(content: string, contentMarkers: MarkerConfig[]): string;
+/**
+ * Remove all markers with different strategies
+ * @param content - Content to clean
+ * @param loadingMarkers - Loading markers (preserve content)
+ * @param contentMarkers - Content markers (remove everything)
+ */
+export declare function removeAllMarkers(content: string, loadingMarkers: MarkerConfig[], contentMarkers: MarkerConfig[]): string;

package/dist/composables/parsing/markerUtils.d.ts

@@ -0,0 +1,58 @@
+import type { ContentPartType } from "../../types";
+import { type MarkerConfig } from "./markerDefinitions";
+/**
+ * Marker Utilities - Pure Functions
+ * No side effects, stateless
+ */
+/**
+ * Escape special regex characters
+ */
+export declare function escapeRegex(str: string): string;
+/**
+ * Create regex pattern from marker config
+ */
+export declare function createMarkerPattern(config: MarkerConfig): RegExp;
+/**
+ * Pattern definition for matching
+ */
+export type PatternDefinition = {
+    type: ContentPartType;
+    regex: RegExp;
+};
+/**
+ * Generate patterns from markers
+ */
+export declare function generatePatterns(markers: MarkerConfig[]): PatternDefinition[];
+/**
+ * Auto-generated patterns from marker configs
+ */
+export declare const CONTENT_PATTERNS: PatternDefinition[];
+/**
+ * Filter markers by predicate
+ */
+export declare function filterMarkers(markers: MarkerConfig[], predicate: (marker: MarkerConfig) => boolean): MarkerConfig[];
+/**
+ * Get marker config by type
+ */
+export declare function getMarkerByType(markers: MarkerConfig[], type: ContentPartType): MarkerConfig | undefined;
+/**
+ * Check if type is loading type
+ */
+export declare function isLoadingType(type: ContentPartType): boolean;
+/**
+ * Check if type is general loading type
+ * Uses the centralized list from markerDefinitions
+ */
+export declare function isGeneralLoadingType(type: ContentPartType): boolean;
+/**
+ * Get markers by category
+ */
+export declare function getMarkersByCategory(markers: MarkerConfig[], category: "loading" | "content"): MarkerConfig[];
+/**
+ * Get general loading markers
+ */
+export declare function getGeneralLoadingMarkers(markers: MarkerConfig[]): MarkerConfig[];
+/**
+ * Get content markers (non-loading)
+ */
+export declare function getContentMarkers(markers: MarkerConfig[]): MarkerConfig[];

package/dist/composables/useCodeButtons.d.ts

@@ -0,0 +1,8 @@
+import { type Ref } from "vue";
+/**
+ * Composable for managing code block copy/collapse buttons
+ * Optimized with debouncing and efficient DOM manipulation
+ */
+export declare function useCodeButtons(containerRef: Ref<HTMLElement | null>, shouldAddButtons: () => boolean): {
+    addCodeButtons: () => void;
+};

package/dist/composables/useContentParser.d.ts

@@ -0,0 +1,12 @@
+import { type ComputedRef, type MaybeRef } from "vue";
+import type { ContentPart } from "../types";
+/**
+ * Composable for parsing Orca content markers
+ * Supports both reactive and non-reactive values for streaming compatibility
+ */
+export declare function useContentParser(description: MaybeRef<string>): ComputedRef<ContentPart[]>;
+/**
+ * Parse content into parts
+ * Extracted for testability
+ */
+export declare function parseContent(content: string): ContentPart[];

package/dist/composables/useImageModal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Composable for managing image modal state
+ * Provides clean API for opening/closing image modals
+ */
+export declare function useImageModal(): {
+    modalVisible: import("vue").Ref<boolean, boolean>;
+    currentImage: import("vue").Ref<string, string>;
+    openModal: (imageUrl: string) => void;
+    closeModal: () => void;
+};

package/dist/composables/useLoadingStates.d.ts

@@ -0,0 +1,13 @@
+import { type MaybeRef } from "vue";
+/**
+ * Composable for managing loading states
+ * Optimized with computed properties and memoization
+ */
+export declare function useLoadingStates(description: MaybeRef<string>): {
+    isLoading: import("vue").Ref<boolean, boolean>;
+    isImageLoading: import("vue").Ref<boolean, boolean>;
+    isVideoLoading: import("vue").Ref<boolean, boolean>;
+    isCardLoading: import("vue").Ref<boolean, boolean>;
+    isLocationLoading: import("vue").Ref<boolean, boolean>;
+    getLoadingMessage: (loadingType: string) => string;
+};

package/dist/composables/useMarkdown.d.ts

@@ -0,0 +1,8 @@
+import "highlight.js/styles/stackoverflow-light.css";
+import "katex/dist/katex.min.css";
+/**
+ * Composable for rendering markdown with KaTeX support
+ */
+export declare function useMarkdown(): {
+    render: (text: string) => string;
+};

package/dist/constants/loadingTypes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Loading content part types that should be filtered out
+ * These are handled separately in the loading indicators section
+ */
+export declare const LOADING_CONTENT_TYPES: readonly ["general-loading", "thinking-loading", "searching-loading", "coding-loading", "analyzing-loading", "generating-loading", "custom-loading", "image-loading", "video-loading", "youtube-loading", "card-loading", "map-loading"];
+/**
+ * Type guard to check if a content part is a loading type
+ */
+export declare function isLoadingType(type: string): type is (typeof LOADING_CONTENT_TYPES)[number];

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Orca Components
+ * Native components for rendering special content markers
+ * @packageDocumentation
+ */
+import "./styles/tailwind.css";
+export { default as OrcaMarkdown } from "./components/OrcaMarkdown.vue";
+export type { AudioData, ButtonData, CardData, ContentPart, ContentPartType, GetFileNameFromUrlFn, GetYouTubeIdFn, IsImageFileFn, OrcaMarkdownEmits, OrcaMarkdownProps, LocationData, MapboxConfig, SendMessageData, TracingData, VideoPlayerOptions, } from "./types";
+export { cleanOrcaMarkers, generateMapId, getAppendIconStyle, getFileNameFromUrl, getGroupedButtons, getOutlinedButtonStyle, getOutlinedButtonTextStyle, getVuetifyColor, getYouTubeId, hasLoadingMarkers, isImageFile, } from "./utils/helpers";
+export declare const version = "1.0.1";
+export declare const packageInfo: {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+};