caplink-saas-ui-shared-component-library 0.5.13 → 0.5.15

package/dist/components/dag/hooks/index.d.ts

@@ -0,0 +1,4 @@
+import { useDag } from './use-dag';
+import { useGetAdjacentNodes, useGetAdjacentNodesProps } from './use-get-adjacent-nodes';
+export { useDag, useGetAdjacentNodes };
+export type { useGetAdjacentNodesProps };

package/dist/components/dag/hooks/use-dag.d.ts

@@ -0,0 +1,2 @@
+import { UseDagProps } from '../model';
+export declare const useDag: () => UseDagProps;

package/dist/components/dag/hooks/use-get-adjacent-nodes.d.ts

@@ -0,0 +1,6 @@
+import { HandleType, Node } from '@xyflow/react';
+export type useGetAdjacentNodesProps = {
+    nodeId?: string;
+    type: HandleType;
+};
+export declare const useGetAdjacentNodes: ({ nodeId, type }: useGetAdjacentNodesProps) => Node[];

package/dist/components/dag/model/dag-types.d.ts

@@ -0,0 +1,115 @@
+import { ComponentType, CSSProperties, PropsWithChildren } from 'react';
+export type Node<T extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    data: T;
+    type?: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    targetPosition?: Position;
+    sourcePosition?: Position;
+    dragging?: boolean;
+    zIndex?: number;
+    selected?: boolean;
+    style?: CSSProperties;
+    className?: string;
+};
+export type NodeProps<T extends Node = Node> = Pick<T, 'id' | 'data' | 'sourcePosition' | 'targetPosition' | 'selected'> & Required<Pick<T, 'type' | 'dragging' | 'zIndex'>> & {
+    isConnectable: boolean;
+    positionAbsoluteX: number;
+    positionAbsoluteY: number;
+};
+export type DefaultNodeDataProps = {
+    content: React.ReactNode;
+    className?: string;
+    hideHandles?: boolean;
+    targetHandleClassName?: string;
+    sourceHandleClassName?: string;
+} & Record<string, unknown>;
+export type Edge<T extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    animated?: boolean;
+    data?: T;
+    type?: string;
+    style?: React.CSSProperties;
+    selected?: boolean;
+    selectable?: boolean;
+    source: string;
+    target: string;
+    deletable?: boolean;
+};
+export type EdgePosition = {
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+    sourcePosition: Position;
+    targetPosition: Position;
+};
+export type EdgeProps<T extends Edge = Edge> = Pick<T, 'id' | 'animated' | 'data' | 'style' | 'selected' | 'source' | 'target' | 'selectable' | 'deletable'> & EdgePosition & {
+    markerEnd?: string;
+};
+export type DefaultEdgeProps = {
+    edgePath?: 'simpleBezier' | 'smoothStep';
+} & Record<string, unknown>;
+export declare enum Position {
+    Left = "left",
+    Top = "top",
+    Right = "right",
+    Bottom = "bottom"
+}
+export type Connection = {
+    source: string;
+    sourceHandle: string | null;
+    target: string;
+    targetHandle: string | null;
+};
+type NodeTypes = Record<string, ComponentType<NodeProps & {
+    data: unknown;
+    type: unknown;
+}>>;
+type EdgeTypes = Record<string, ComponentType<EdgeProps & {
+    data: unknown;
+    type: unknown;
+}>>;
+export type DagProps = PropsWithChildren<{
+    isLoading?: boolean;
+    initialNodes?: Node[];
+    initialEdges?: Edge[];
+    nodeTypes?: NodeTypes;
+    edgeTypes?: EdgeTypes;
+    onNodeClick?: (event: React.MouseEvent, node: Node) => void;
+    onNodeDragStop?: (event: React.MouseEvent, node: Node) => void;
+    onNodeDragStart?: (event: React.MouseEvent, node: Node) => void;
+    onConnect?: (connection: Connection) => void;
+}>;
+export type UseDagProps = {
+    getEdges: () => Edge[];
+    getNodes: () => Node[];
+    getNode: (nodeId: string) => Node | undefined;
+    getEdge: (edgeId: string) => Edge | undefined;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    fitView: (props: {
+        duration?: number;
+        maxZoom?: number;
+        minZoom?: number;
+        nodes?: Node[];
+        padding?: number;
+    }) => void;
+    addEdges: (edges: Edge[]) => void;
+    addNodes: (nodes: Node[]) => void;
+    deleteNodes: (node: Node | Node[]) => void;
+    deleteEdges: (edge: Edge | Edge[]) => void;
+    getNodeEdges: (nodeId: string) => Edge[];
+    changeOrientation: (props: {
+        direction: 'vertical' | 'horizontal';
+        nodeHeight?: number;
+        nodeWidth?: number;
+    }) => {
+        nodes: Node[];
+        edges: Edge[];
+    };
+};
+export {};

package/dist/components/dag/model/index.d.ts

@@ -0,0 +1,3 @@
+import { Position, Connection, DagProps, DefaultNodeDataProps, Edge, EdgePosition, EdgeProps, Node, NodeProps, UseDagProps } from './dag-types';
+export { Position };
+export type { Connection, DagProps, DefaultNodeDataProps, Edge, EdgePosition, EdgeProps, Node, NodeProps, UseDagProps };

package/dist/components/dag/ui/adjacent-nodes/adjacent-nodes.d.ts

@@ -0,0 +1,10 @@
+import { HandleType, Node } from '@xyflow/react';
+import { PropsWithChildren } from 'react';
+export type AdjacentNodesProps = PropsWithChildren<{
+    title?: string;
+    nodeId: string;
+    type: HandleType;
+    nodeValueKey: string;
+    onFindAdjacentNodes?: (nodes: Node[]) => void;
+}>;
+export declare function AdjacentNodes(props: AdjacentNodesProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/dag/ui/adjacent-nodes/index.d.ts

@@ -0,0 +1,3 @@
+import { AdjacentNodes, AdjacentNodesProps } from './adjacent-nodes';
+export { AdjacentNodes };
+export type { AdjacentNodesProps };

package/dist/components/dag/ui/dag-container.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare function DagContainer(props: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;

package/dist/components/dag/ui/dag.d.ts

@@ -0,0 +1,2 @@
+import { DagProps } from '../model';
+export declare function Dag(props: DagProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dag/ui/defaults/default-edge.d.ts

@@ -0,0 +1,2 @@
+import { DefaultEdgeProps, Edge, EdgeProps } from '../../model/dag-types';
+export declare function DefaultEdge({ sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, markerEnd, source, target, data, }: EdgeProps<Edge<DefaultEdgeProps>>): import("react/jsx-runtime").JSX.Element;

package/dist/components/dag/ui/defaults/default-node.d.ts

@@ -0,0 +1,2 @@
+import { DefaultNodeDataProps, Node, NodeProps } from '../../model';
+export declare function DefaultNode({ id, selected, data, sourcePosition, targetPosition, }: NodeProps<Node<DefaultNodeDataProps>>): import("react/jsx-runtime").JSX.Element;

package/dist/components/dag/ui/defaults/index.d.ts

@@ -0,0 +1,4 @@
+import { DefaultEdge } from './default-edge';
+import { DefaultNode } from './default-node';
+import { SkeletonNode } from './skeleton-node';
+export { DefaultNode, DefaultEdge, SkeletonNode };

package/dist/components/dag/ui/defaults/skeleton-node.d.ts

@@ -0,0 +1 @@
+export declare function SkeletonNode(): import("react/jsx-runtime").JSX.Element;

package/dist/components/dag/ui/float-menu/default-float-buttons/button-change-orientation.d.ts

@@ -0,0 +1,12 @@
+import { Edge, Node } from '../../../model';
+export type ButtonChangeOrientationProps = {
+    orientation: 'vertical' | 'horizontal';
+    onClick?: (event: React.MouseEvent<HTMLButtonElement>, props: {
+        nodes: Node[];
+        edges: Edge[];
+    }) => void;
+    shouldFitView?: boolean;
+    nodeHeight?: number;
+    nodeWidth?: number;
+};
+export declare const ButtonChangeOrientation: ({ onClick, orientation, shouldFitView, nodeHeight, nodeWidth, }: ButtonChangeOrientationProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/dag/ui/float-menu/default-float-buttons/button-zoom-in.d.ts

@@ -0,0 +1 @@
+export declare const ButtonZoomIn: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/dag/ui/float-menu/default-float-buttons/button-zoom-out.d.ts

@@ -0,0 +1 @@
+export declare const ButtonZoomOut: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/dag/ui/float-menu/default-float-buttons/index.d.ts

@@ -0,0 +1,5 @@
+import { ButtonChangeOrientation, ButtonChangeOrientationProps } from './button-change-orientation';
+import { ButtonZoomIn } from './button-zoom-in';
+import { ButtonZoomOut } from './button-zoom-out';
+export { ButtonChangeOrientation, ButtonZoomIn, ButtonZoomOut };
+export type { ButtonChangeOrientationProps };

package/dist/components/dag/ui/float-menu/float-menu-button-group.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare function FloatMenuButtonGroup(props: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;

package/dist/components/dag/ui/float-menu/float-menu-button.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare function FloatMenuButton(props: React.HTMLAttributes<HTMLButtonElement>): import("react/jsx-runtime").JSX.Element;

package/dist/components/dag/ui/float-menu/float-menu.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export type FloatMenuProps = {
+    isLoading?: boolean;
+} & React.HTMLAttributes<HTMLDivElement>;
+export declare function FloatMenu(props: FloatMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dag/ui/float-menu/index.d.ts

@@ -0,0 +1,5 @@
+import { FloatMenu, FloatMenuProps } from './float-menu';
+import { FloatMenuButton } from './float-menu-button';
+import { FloatMenuButtonGroup } from './float-menu-button-group';
+export { FloatMenu, FloatMenuButton, FloatMenuButtonGroup };
+export type { FloatMenuProps };

package/dist/components/dag/ui/index.d.ts

@@ -0,0 +1,3 @@
+import { Dag } from './dag';
+import { DagContainer } from './dag-container';
+export { Dag, DagContainer };

package/dist/components/dag/ui/search-node/index.d.ts

@@ -0,0 +1,3 @@
+import { SearchNode, SearchNodeProps } from './search-node';
+export { SearchNode };
+export type { SearchNodeProps };

package/dist/components/dag/ui/search-node/search-node.d.ts

@@ -0,0 +1,6 @@
+export type SearchNodeProps = {
+    placeholder?: string;
+    searchKeys: string[];
+    onSearch?: (value: string) => void;
+};
+export declare function SearchNode(props: SearchNodeProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dag/utils/get-layout-elements.d.ts

@@ -0,0 +1,49 @@
+import { Edge, Node, Position } from '@xyflow/react';
+export interface GetLayoutedElementsProps {
+    nodes: Node[];
+    edges: Edge[];
+    direction?: 'vertical' | 'horizontal';
+    nodeWidth?: number;
+    nodeHeight?: number;
+}
+export declare const getLayoutedElements: (props: GetLayoutedElementsProps) => {
+    nodes: {
+        targetPosition: Position;
+        sourcePosition: Position;
+        position: {
+            x: number;
+            y: number;
+        };
+        id: string;
+        data: Record<string, unknown>;
+        type?: string | undefined;
+        hidden?: boolean | undefined;
+        selected?: boolean | undefined;
+        dragging?: boolean | undefined;
+        draggable?: boolean | undefined;
+        selectable?: boolean | undefined;
+        connectable?: boolean | undefined;
+        deletable?: boolean | undefined;
+        dragHandle?: string | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        initialWidth?: number | undefined;
+        initialHeight?: number | undefined;
+        parentId?: string | undefined;
+        zIndex?: number | undefined;
+        extent?: "parent" | import('@xyflow/react').CoordinateExtent | undefined;
+        expandParent?: boolean | undefined;
+        ariaLabel?: string | undefined;
+        origin?: import('@xyflow/react').NodeOrigin | undefined;
+        handles?: import('@xyflow/system').NodeHandle[] | undefined;
+        measured?: {
+            width?: number | undefined;
+            height?: number | undefined;
+        } | undefined;
+        style?: import('react').CSSProperties | undefined;
+        className?: string | undefined;
+        resizing?: boolean | undefined;
+        focusable?: boolean | undefined;
+    }[];
+    edges: Edge[];
+};

package/dist/components/file-uploader/ui/file-uploader.d.ts

@@ -0,0 +1,9 @@
+import { ButtonHTMLAttributes } from 'react';
+export type FileUploaderState = 'Loading' | 'Idle' | 'Disabled' | 'Finished';
+export type FileUploaderProps = {
+    fileName: string;
+    fileSizeInMb: string;
+    onDownload: () => void;
+    state: FileUploaderState;
+} & ButtonHTMLAttributes<HTMLButtonElement>;
+export declare function FileUploader(props: FileUploaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/file-uploader/ui/index.d.ts

@@ -0,0 +1,3 @@
+import { FileUploader, FileUploaderProps } from './file-uploader';
+export { FileUploader };
+export type { FileUploaderProps };

package/dist/components/image-uploader/ui/image-uploader.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes } from 'react';
+export type ImageUploaderState = 'Uploading' | 'Removing' | 'Idle' | 'Disabled' | 'Finished';
+export type ImageUploaderProps = {
+    imageName?: string;
+    imageSize?: string;
+    maxImageSizeInKb?: number;
+    imageUrl?: string;
+    onError?: (errorMessage: string) => void;
+    onRemove?: () => void;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    state: ImageUploaderState;
+    customImagePreview?: React.ReactElement;
+    customImage?: React.ReactElement;
+    errorMessages?: {
+        priorityError?: string;
+        imageTypeError?: string;
+        imageSizeError?: string;
+    };
+} & Omit<HTMLAttributes<HTMLDivElement>, 'onChange'>;
+export declare function ImageUploader(props: ImageUploaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/image-uploader/ui/image-viewer.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export type ImageViewerProps = {
+    imageUrl?: string;
+    customImage?: React.ReactElement;
+    onClose: () => void;
+};
+export declare function ImageViewer(props: ImageViewerProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/image-uploader/ui/index.d.ts

@@ -0,0 +1,3 @@
+import { ImageUploader, ImageUploaderProps } from './image-uploader';
+export { ImageUploader };
+export type { ImageUploaderProps };

package/dist/components/sidebar/ui/content-split.d.ts

@@ -0,0 +1,4 @@
+export type ContentSplitProps = {
+    className?: string;
+};
+export declare function ContentSplit(props: ContentSplitProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/sidebar/ui/index.d.ts

@@ -0,0 +1,5 @@
+import { ContentSplit, ContentSplitProps } from './content-split';
+import { Sidebar, SidebarProps } from './sidebar';
+import { SidebarHeader } from './sidebar-header';
+export { Sidebar, SidebarHeader, ContentSplit };
+export type { SidebarProps, ContentSplitProps };

package/dist/components/sidebar/ui/sidebar-header.d.ts

@@ -0,0 +1,5 @@
+export type SidebarHeaderProps = {
+    title: string;
+    onClose?: () => void;
+};
+export declare function SidebarHeader(props: SidebarHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/sidebar/ui/sidebar.d.ts

@@ -0,0 +1,11 @@
+import { VariantProps } from 'class-variance-authority';
+import { PropsWithChildren } from 'react';
+declare const sidebarVariants: (props?: ({
+    direction?: "left" | "right" | "fixed" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type SidebarProps = PropsWithChildren<{
+    isOpen: boolean;
+    className?: string;
+} & VariantProps<typeof sidebarVariants>>;
+export declare function Sidebar(props: SidebarProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/spreadsheet/lib/cap-value.d.ts

@@ -0,0 +1,5 @@
+export declare function capValue({ value, min, max }: {
+    value?: string;
+    min?: number;
+    max?: number;
+}): number | undefined;

package/dist/components/spreadsheet/lib/date-formatter.d.ts

@@ -0,0 +1 @@
+export declare function dateFormatter(value: string): string | null;

package/dist/components/spreadsheet/lib/get-text-width-by-font.d.ts

@@ -0,0 +1 @@
+export declare function getTextWidthByFont(text: string, font?: string): number;

package/dist/components/spreadsheet/lib/indexed-alphabet.d.ts

@@ -0,0 +1 @@
+export declare function indexedAlphabet(columns: number): string;

package/dist/components/spreadsheet/lib/normalize-value.d.ts

@@ -0,0 +1,5 @@
+import * as Spreadsheet from '../model/spreadsheet';
+export declare function normalizeValue(params: {
+    value: unknown;
+    column: Spreadsheet.Column;
+}): unknown;

package/dist/components/spreadsheet/lib/one-line-string.d.ts

@@ -0,0 +1 @@
+export declare function oneLineString(value: string): boolean;

package/dist/components/spreadsheet/lib/text-overflow.d.ts

@@ -0,0 +1 @@
+export declare function textOverflow(text: string, maxWidth: number): boolean;

package/dist/components/spreadsheet/lib/use-spreadsheet.d.ts

@@ -0,0 +1 @@
+export declare function useSpreadsheet(): import('../model/spreadsheet').Context;

package/dist/components/spreadsheet/lib/with-portal-provider.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export interface IWithPortalProvider {
+    children: React.ReactElement<{
+        ref?: React.RefObject<HTMLElement | null>;
+    }>;
+}
+export declare const WithPortalProvider: ({ children }: IWithPortalProvider) => import("react/jsx-runtime").JSX.Element;
+export declare const useWithPortal: () => {
+    portalRef?: React.RefObject<HTMLElement> | undefined;
+};

package/dist/components/spreadsheet/model/matrix.d.ts

@@ -0,0 +1,59 @@
+/** A cell cordinates in matrix */
+export type Point = {
+    row: number;
+    column: number;
+};
+/** Range between two points. */
+export type PointRange = {
+    /** The top-left point */
+    start: Point;
+    /** The bottom-right point */
+    end: Point;
+};
+/** Counts of the rows and column in a matrix */
+export type Size = {
+    /** Count of the rows in the matrix */
+    rows: number;
+    /** Count of the columns in the matrix */
+    columns: number;
+};
+export type Matrix<T> = Array<Array<T | undefined>>;
+/** Creates an empty matrix with given rows and columns */
+export declare function createEmpty<T>(size: Size, fill?: T): Matrix<T>;
+/** Gets the count of rows of given matrix */
+export declare function getRowsCount(matrix: Matrix<unknown>): number;
+/** Gets the count of columns of given matrix */
+export declare function getColumnsCount(matrix: Matrix<unknown>): number;
+/** Gets the count of rows and columns of given matrix */
+export declare function getSize(matrix: Matrix<unknown>): Size;
+/** Gets the value at row and column of matrix. */
+export declare function getPoint<T>(params: {
+    point: Point;
+    matrix: Matrix<T>;
+}): T | undefined;
+/** Checks if the source and target point are equal */
+export declare function isSamePoint(source: Point, target: Point): boolean;
+/** Returns whether given point exists in given range */
+export declare function hasPointInRange(pointsRange: PointRange[], point: Point): boolean;
+/** Determines whether all columns are selected */
+export declare function hasEntireColumns(params: {
+    matrix: Matrix<unknown>;
+    pointsRange: PointRange[];
+}): true | undefined;
+/** Determines which row is entirely selected in given selection */
+export declare function hasEntireRows(params: {
+    matrix: Matrix<unknown>;
+    pointsRange: PointRange[];
+    row: number;
+}): boolean;
+/** Converts string value into an matrix */
+export declare function parseString(value: string): Matrix<unknown>;
+/**
+ * Overlaps a given Matrix B (mB) starting in a specific point into a given Matrix A (mA)
+ * Matrix B (mB) always has priority when replacing cell values
+ */
+export declare function overlap(params: {
+    mA: Matrix<unknown>;
+    mB: Matrix<unknown>;
+    point: Point;
+}): Matrix<unknown>;