@r2digisolutions/components 0.1.7 → 0.2.0

package/dist/utils/mediaTracks.d.ts

@@ -0,0 +1,61 @@
+/** Shared track/clip types and helpers for Video / Audio editors. */
+export type MediaAssetKind = 'image' | 'video' | 'audio' | 'text';
+export interface MediaAsset {
+    id: string;
+    kind: MediaAssetKind;
+    name: string;
+    /** Object URL or remote URL */
+    src?: string;
+    durationMs?: number;
+    width?: number;
+    height?: number;
+}
+export interface MediaClip {
+    id: string;
+    trackId: string;
+    assetId?: string;
+    name: string;
+    kind: MediaAssetKind;
+    src?: string;
+    /** Timeline start */
+    startMs: number;
+    /** Timeline end */
+    endMs: number;
+    /** Source trim in */
+    trimInMs?: number;
+    /** Source trim out (absolute in source) */
+    trimOutMs?: number;
+    color?: string;
+}
+export type MediaTrackKind = 'video' | 'audio' | 'image';
+export interface MediaTrack {
+    id: string;
+    name: string;
+    kind: MediaTrackKind;
+    muted?: boolean;
+    solo?: boolean;
+    locked?: boolean;
+    armed?: boolean;
+    color?: string;
+    clips: MediaClip[];
+}
+export declare function uid(prefix?: string): string;
+export declare function createMediaClip(partial: Omit<MediaClip, 'id'> & {
+    id?: string;
+}): MediaClip;
+export declare function createMediaTrack(partial: Omit<MediaTrack, 'id' | 'clips'> & {
+    id?: string;
+    clips?: MediaClip[];
+}): MediaTrack;
+export declare function clipDurationMs(clip: MediaClip): number;
+export declare function moveClip(clip: MediaClip, newStartMs: number, durationMs?: number): MediaClip;
+export declare function trimClipStart(clip: MediaClip, newStartMs: number, minDur?: number): MediaClip;
+export declare function trimClipEnd(clip: MediaClip, newEndMs: number, minDur?: number): MediaClip;
+export declare function isClipActiveAt(clip: MediaClip, timeMs: number): boolean;
+export declare function findClipAt(tracks: MediaTrack[], timeMs: number, kind?: MediaTrackKind): MediaClip | null;
+export declare function updateClipInTracks(tracks: MediaTrack[], clipId: string, updater: (c: MediaClip) => MediaClip): MediaTrack[];
+export declare function removeClipFromTracks(tracks: MediaTrack[], clipId: string): MediaTrack[];
+export declare function createMediaAsset(partial: Omit<MediaAsset, 'id'> & {
+    id?: string;
+}): MediaAsset;
+export declare function kindFromFile(file: File): MediaAssetKind;

package/dist/utils/mediaTracks.js

@@ -0,0 +1,102 @@
+/** Shared track/clip types and helpers for Video / Audio editors. */
+export function uid(prefix = 'id') {
+    return `${prefix}_${Math.random().toString(36).slice(2, 10)}`;
+}
+export function createMediaClip(partial) {
+    return {
+        id: partial.id ?? uid('clip'),
+        trackId: partial.trackId,
+        assetId: partial.assetId,
+        name: partial.name,
+        kind: partial.kind,
+        src: partial.src,
+        startMs: partial.startMs,
+        endMs: Math.max(partial.startMs + 1, partial.endMs),
+        trimInMs: partial.trimInMs,
+        trimOutMs: partial.trimOutMs,
+        color: partial.color
+    };
+}
+export function createMediaTrack(partial) {
+    return {
+        id: partial.id ?? uid('track'),
+        name: partial.name,
+        kind: partial.kind,
+        muted: partial.muted ?? false,
+        solo: partial.solo ?? false,
+        locked: partial.locked ?? false,
+        armed: partial.armed ?? false,
+        color: partial.color,
+        clips: partial.clips ?? []
+    };
+}
+export function clipDurationMs(clip) {
+    return Math.max(0, clip.endMs - clip.startMs);
+}
+export function moveClip(clip, newStartMs, durationMs) {
+    const dur = durationMs ?? clipDurationMs(clip);
+    const startMs = Math.max(0, newStartMs);
+    return { ...clip, startMs, endMs: startMs + dur };
+}
+export function trimClipStart(clip, newStartMs, minDur = 50) {
+    const endMs = clip.endMs;
+    const startMs = Math.min(Math.max(0, newStartMs), endMs - minDur);
+    const delta = startMs - clip.startMs;
+    return {
+        ...clip,
+        startMs,
+        trimInMs: (clip.trimInMs ?? 0) + delta
+    };
+}
+export function trimClipEnd(clip, newEndMs, minDur = 50) {
+    const startMs = clip.startMs;
+    const endMs = Math.max(startMs + minDur, newEndMs);
+    return { ...clip, endMs };
+}
+export function isClipActiveAt(clip, timeMs) {
+    return timeMs >= clip.startMs && timeMs < clip.endMs;
+}
+export function findClipAt(tracks, timeMs, kind) {
+    const list = kind ? tracks.filter((t) => t.kind === kind) : tracks;
+    for (const track of [...list].reverse()) {
+        if (track.muted && !track.solo)
+            continue;
+        for (const clip of track.clips) {
+            if (isClipActiveAt(clip, timeMs))
+                return clip;
+        }
+    }
+    return null;
+}
+export function updateClipInTracks(tracks, clipId, updater) {
+    return tracks.map((t) => ({
+        ...t,
+        clips: t.clips.map((c) => (c.id === clipId ? updater(c) : c))
+    }));
+}
+export function removeClipFromTracks(tracks, clipId) {
+    return tracks.map((t) => ({
+        ...t,
+        clips: t.clips.filter((c) => c.id !== clipId)
+    }));
+}
+export function createMediaAsset(partial) {
+    return {
+        id: partial.id ?? uid('asset'),
+        kind: partial.kind,
+        name: partial.name,
+        src: partial.src,
+        durationMs: partial.durationMs,
+        width: partial.width,
+        height: partial.height
+    };
+}
+export function kindFromFile(file) {
+    if (file.type.startsWith('image/'))
+        return 'image';
+    if (file.type.startsWith('video/'))
+        return 'video';
+    if (file.type.startsWith('audio/'))
+        return 'audio';
+    return 'text';
+}

package/dist/utils/nodeGraph.d.ts

@@ -0,0 +1,354 @@
+/**
+ * Node graph helpers — Blueprint-style typed pins, edges, validation.
+ */
+export type GraphPortSide = 'left' | 'right' | 'top' | 'bottom';
+export type PinKind = 'exec' | 'data';
+export type PinDataType = 'bool' | 'int' | 'float' | 'string' | 'object' | 'exec' | 'any';
+export interface GraphPort {
+    id: string;
+    label?: string;
+    side?: GraphPortSide;
+    /** 0–1 along the side (0.5 = center). */
+    offset?: number;
+    kind?: PinKind;
+    dataType?: PinDataType;
+    /** Inline literal when the pin is not wired (Blueprint-style). */
+    value?: unknown;
+}
+export interface GraphNodeData {
+    label?: string;
+    description?: string;
+    color?: string;
+    /** Comment box fill */
+    commentColor?: string;
+    [key: string]: unknown;
+}
+export interface GraphNode {
+    id: string;
+    type: string;
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    data?: GraphNodeData;
+    inputs?: GraphPort[];
+    outputs?: GraphPort[];
+}
+export interface GraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    sourceHandle?: string;
+    targetHandle?: string;
+    label?: string;
+}
+export interface GraphDocument {
+    version: 1;
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+/**
+ * Graph kind / “class context” — like Unreal Blueprint graphs.
+ * Nodes without `contexts` are available in every graph.
+ */
+export type GraphNodeContext = 'event_graph' | 'function_graph' | 'macro_graph' | 'construction_script';
+export interface GraphNodeTypeDef {
+    type: string;
+    label: string;
+    description?: string;
+    category?: string;
+    color?: string;
+    inputs?: GraphPort[];
+    outputs?: GraphPort[];
+    defaultData?: GraphNodeData;
+    width?: number;
+    height?: number;
+    /** If set, node only appears in these graph contexts (Unreal-style). */
+    contexts?: GraphNodeContext[];
+    /** Hide from palette (still creatable via API / variable menu). */
+    hidden?: boolean;
+}
+export declare const DEFAULT_NODE_WIDTH = 220;
+export declare const DEFAULT_NODE_HEIGHT = 80;
+export declare const PORT_SIZE = 12;
+/** Half of the pin glyph — wire starts/ends at the rim of the circle/play icon. */
+export declare const EDGE_PORT_PAD: number;
+/** SVG marker tip length (viewBox units ≈ user units with markerWidth 8). */
+export declare const EDGE_ARROW_LENGTH = 8;
+export declare const PIN_TYPE_COLORS: Record<PinDataType, string>;
+export declare function pinColor(port: GraphPort): string;
+export declare const DEFAULT_NODE_TYPES: GraphNodeTypeDef[];
+/** Unreal-inspired blueprint catalog */
+export declare const DEFAULT_BLUEPRINT_NODE_TYPES: GraphNodeTypeDef[];
+export declare function emptyGraphDocument(): GraphDocument;
+export declare function resolveNodeType(type: string, catalog?: GraphNodeTypeDef[]): GraphNodeTypeDef | undefined;
+export declare function defaultPortsForType(type: string, catalog?: GraphNodeTypeDef[]): {
+    inputs: GraphPort[];
+    outputs: GraphPort[];
+};
+export declare function createGraphNode(partial: Partial<GraphNode> & {
+    type: string;
+    x: number;
+    y: number;
+}, catalog?: GraphNodeTypeDef[]): GraphNode;
+/** Duplicate nodes (+ internal edges), like UE Blueprint Ctrl+W / duplicate. */
+export declare function duplicateGraphSelection(doc: GraphDocument, nodeIds: string[], opts?: {
+    offsetX?: number;
+    offsetY?: number;
+}): {
+    doc: GraphDocument;
+    newNodeIds: string[];
+};
+export declare function cloneGraphDocument(doc: GraphDocument): GraphDocument;
+export declare const GRAPH_CLIPBOARD_MIME = "application/x-r2-graph-fragment";
+export type GraphClipboardPayload = {
+    mime: typeof GRAPH_CLIPBOARD_MIME;
+    version: 1;
+    fragment: GraphDocument;
+};
+export declare function extractGraphSelection(doc: GraphDocument, nodeIds: string[]): GraphDocument;
+export declare function encodeGraphClipboard(fragment: GraphDocument): string;
+export declare function decodeGraphClipboard(raw: string): GraphDocument | null;
+export declare function pasteGraphSelection(doc: GraphDocument, fragment: GraphDocument, opts?: {
+    offsetX?: number;
+    offsetY?: number;
+    origin?: {
+        x: number;
+        y: number;
+    };
+}): {
+    doc: GraphDocument;
+    newNodeIds: string[];
+};
+export type AlignAxis = 'left' | 'right' | 'top' | 'bottom' | 'centerX' | 'centerY';
+export type DistributeAxis = 'horizontal' | 'vertical';
+export declare function alignGraphNodes(doc: GraphDocument, nodeIds: string[], align: AlignAxis): GraphDocument;
+export declare function distributeGraphNodes(doc: GraphDocument, nodeIds: string[], axis: DistributeAxis): GraphDocument;
+export declare function selectionBounds(doc: GraphDocument, nodeIds: string[], padding?: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+export declare function createCommentFromSelection(doc: GraphDocument, nodeIds: string[], opts?: {
+    label?: string;
+}): {
+    doc: GraphDocument;
+    commentId: string;
+} | null;
+export declare function createRerouteNode(pos: {
+    x: number;
+    y: number;
+}, port: Pick<GraphPort, 'kind' | 'dataType'>): GraphNode;
+export declare function insertRerouteOnEdge(doc: GraphDocument, edgeId: string, pos: {
+    x: number;
+    y: number;
+}): {
+    doc: GraphDocument;
+    rerouteId: string;
+} | null;
+export declare function breakLinksAtHandle(doc: GraphDocument, nodeId: string, handleId: string | null | undefined, handleType: 'source' | 'target' | null | undefined): GraphDocument;
+export declare function collapseSelectionToFunction(doc: GraphDocument, nodeIds: string[], opts?: {
+    label?: string;
+}): {
+    doc: GraphDocument;
+    collapsedId: string;
+} | null;
+export declare function expandCollapsedGraph(doc: GraphDocument, nodeId: string): {
+    doc: GraphDocument;
+    newNodeIds: string[];
+} | null;
+export declare function createGraphEdge(source: string, target: string, opts?: {
+    label?: string;
+    sourceHandle?: string;
+    targetHandle?: string;
+    id?: string;
+}): GraphEdge;
+export declare function serializeGraphDocument(doc: GraphDocument): string;
+export declare function parseGraphDocument(raw: string | GraphDocument): GraphDocument;
+export declare function removeNode(doc: GraphDocument, nodeId: string): GraphDocument;
+export declare function removeEdge(doc: GraphDocument, edgeId: string): GraphDocument;
+export declare function updateNodePosition(doc: GraphDocument, nodeId: string, x: number, y: number): GraphDocument;
+export declare function nodeSize(node: GraphNode, fallbackW?: number, fallbackH?: number): {
+    w: number;
+    h: number;
+};
+export declare function nodeCenter(node: GraphNode, width?: number, height?: number): {
+    x: number;
+    y: number;
+};
+export declare function portPosition(node: GraphNode, port: GraphPort, kind: 'input' | 'output', index?: number, total?: number, fallbackW?: number, fallbackH?: number): {
+    x: number;
+    y: number;
+};
+export declare function findPort(node: GraphNode, handleId: string | undefined, kind: 'input' | 'output'): {
+    port: GraphPort;
+    index: number;
+    total: number;
+} | null;
+export declare function edgeEndpoints(doc: GraphDocument, edge: GraphEdge, fallbackW?: number, fallbackH?: number): {
+    from: {
+        x: number;
+        y: number;
+    };
+    to: {
+        x: number;
+        y: number;
+    };
+} | null;
+/** Offset a port-center point along its side normal (away from the node). */
+export declare function offsetPortPoint(point: {
+    x: number;
+    y: number;
+}, side: GraphPortSide, distance: number): {
+    x: number;
+    y: number;
+};
+export declare function isExecPort(port: GraphPort): boolean;
+export declare function isDataPort(port: GraphPort): boolean;
+export declare function formatPortLiteral(port: GraphPort): string;
+export declare function parsePortLiteral(port: GraphPort, raw: string): unknown;
+export declare function defaultPortLiteral(port: GraphPort): unknown;
+/** Map nodeId → input handle ids that have an incoming edge. */
+export declare function wiredInputIdsByNode(edges: GraphEdge[]): Map<string, Set<string>>;
+/** Bezier with endpoints on the pin rim along the side normal (not the chord). */
+export declare function edgePathForPorts(from: {
+    x: number;
+    y: number;
+}, to: {
+    x: number;
+    y: number;
+}, opts?: {
+    padStart?: number;
+    padEnd?: number;
+    curvature?: number;
+    fromSide?: GraphPortSide;
+    toSide?: GraphPortSide;
+}): string;
+/** True if the type exposes at least one input pin compatible with `source`. */
+export declare function nodeTypeAcceptsPort(typeDef: GraphNodeTypeDef, source: GraphPort): boolean;
+export declare function firstCompatibleInput(node: GraphNode, source: GraphPort): GraphPort | null;
+export declare function edgePathFromPoints(from: {
+    x: number;
+    y: number;
+}, to: {
+    x: number;
+    y: number;
+}, curvature?: number): string;
+export declare function pinsCompatible(source: GraphPort, target: GraphPort): boolean;
+export type GraphValidationIssue = {
+    id: string;
+    level: 'error' | 'warning';
+    message: string;
+    edgeId?: string;
+    nodeId?: string;
+};
+export declare function validateGraph(doc: GraphDocument): GraphValidationIssue[];
+export declare function snap(value: number, grid: number): number;
+export declare function fitView(nodes: GraphNode[], viewport: {
+    width: number;
+    height: number;
+}, padding?: number, fallbackW?: number, fallbackH?: number): {
+    pan: {
+        x: number;
+        y: number;
+    };
+    scale: number;
+};
+export declare function groupNodeTypesByCategory(types: GraphNodeTypeDef[]): {
+    category: string;
+    types: GraphNodeTypeDef[];
+}[];
+export declare function nodeTypeAllowedInContext(type: GraphNodeTypeDef, context?: GraphNodeContext | null): boolean;
+/** Palette / place-menu catalog: context + hide templates. */
+export declare function filterNodeTypesForGraph(types: GraphNodeTypeDef[], opts?: {
+    context?: GraphNodeContext | null;
+    includeHidden?: boolean;
+}): GraphNodeTypeDef[];
+/** Blueprint document wrapper */
+export interface BlueprintVariable {
+    id: string;
+    name: string;
+    dataType: PinDataType;
+    defaultValue?: unknown;
+}
+export declare function variablePinColor(dataType: PinDataType): string;
+export declare function defaultValueForPinType(dataType: PinDataType): unknown;
+export declare function createVarGetNode(variable: BlueprintVariable, pos: {
+    x: number;
+    y: number;
+}): GraphNode;
+export declare function createVarSetNode(variable: BlueprintVariable, pos: {
+    x: number;
+    y: number;
+}): GraphNode;
+/** Place-menu entries for Get/Set of each blueprint variable. */
+export declare function variablePlaceItems(variables: BlueprintVariable[]): {
+    id: string;
+    kind: 'get' | 'set';
+    variable: BlueprintVariable;
+    label: string;
+    color: string;
+}[];
+export interface BlueprintDocument {
+    version: 1;
+    name?: string;
+    graph: GraphDocument;
+    variables?: BlueprintVariable[];
+}
+export declare function emptyBlueprintDocument(name?: string): BlueprintDocument;
+/** Data payload carried by xyflow custom blueprint nodes. */
+export type BlueprintFlowNodeData = {
+    graphType: string;
+    label?: string;
+    description?: string;
+    color?: string;
+    commentColor?: string;
+    inputs: GraphPort[];
+    outputs: GraphPort[];
+    width?: number;
+    height?: number;
+    /** Input handle ids that currently have a wire. */
+    _wiredInputs?: string[];
+    /** Set a literal on an unwired data input. */
+    _onLiteral?: (portId: string, value: unknown) => void;
+    [key: string]: unknown;
+};
+export type BlueprintFlowNode = {
+    id: string;
+    type: 'blueprint';
+    position: {
+        x: number;
+        y: number;
+    };
+    data: BlueprintFlowNodeData;
+    selected?: boolean;
+    draggable?: boolean;
+    width?: number;
+    height?: number;
+    zIndex?: number;
+    class?: string;
+};
+export type BlueprintFlowEdge = {
+    id: string;
+    source: string;
+    target: string;
+    sourceHandle?: string | null;
+    targetHandle?: string | null;
+    label?: string;
+    selected?: boolean;
+    style?: string;
+    markerEnd?: {
+        type: string;
+        width?: number;
+        height?: number;
+        color?: string;
+    };
+};
+export declare function toFlowNodes(doc: GraphDocument, catalog?: GraphNodeTypeDef[], selectedIds?: string[]): BlueprintFlowNode[];
+export declare function toFlowEdges(doc: GraphDocument, selectedIds?: string[]): BlueprintFlowEdge[];
+export declare function fromFlowNodes(nodes: BlueprintFlowNode[]): GraphNode[];
+export declare function fromFlowEdges(edges: BlueprintFlowEdge[]): GraphEdge[];
+export declare function flowDocumentFromFlow(nodes: BlueprintFlowNode[], edges: BlueprintFlowEdge[]): GraphDocument;
+/** Resolve a port on a flow node by handle id + direction. */
+export declare function flowPortOnNode(node: BlueprintFlowNode | undefined, handleId: string | null | undefined, kind: 'input' | 'output'): GraphPort | null;