@nice2dev/ui-graphics 1.3.12 → 1.3.14

package/dist/types/game/isometricTiles.d.ts

@@ -1,250 +0,0 @@
-/**
- * Isometric Tile System
- * Support for 2.5D isometric/dimetric tile rendering and editing
- */
-export type IsometricProjection = 'isometric' | 'dimetric' | 'trimetric' | 'military' | 'cavalier';
-export interface IsometricConfig {
-    /** Projection type */
-    projection: IsometricProjection;
-    /** Tile width in pixels */
-    tileWidth: number;
-    /** Tile height in pixels (visible portion) */
-    tileHeight: number;
-    /** Tile depth (for 3D tiles) */
-    tileDepth: number;
-    /** Angle in degrees (for custom projections) */
-    angle: number;
-    /** Scale factor */
-    scale: number;
-    /** Origin offset */
-    origin: {
-        x: number;
-        y: number;
-    };
-    /** Grid size (columns x rows) */
-    gridSize: {
-        cols: number;
-        rows: number;
-    };
-    /** Stacking layers */
-    layers: number;
-}
-export interface IsometricTile {
-    /** Unique ID */
-    id: string;
-    /** Grid position */
-    gridX: number;
-    gridY: number;
-    /** Layer (z-level) */
-    layer: number;
-    /** Tile type/sprite index */
-    tileType: number;
-    /** Rotation (0, 90, 180, 270) */
-    rotation: 0 | 90 | 180 | 270;
-    /** Flip horizontally */
-    flipX: boolean;
-    /** Flip vertically */
-    flipY: boolean;
-    /** Custom height offset */
-    heightOffset: number;
-    /** Tile metadata */
-    metadata?: Record<string, unknown>;
-}
-export interface IsometricTileset {
-    /** Tileset name */
-    name: string;
-    /** Source image path */
-    imagePath: string;
-    /** Tile definitions */
-    tiles: IsometricTileDefinition[];
-    /** Tileset dimensions */
-    imageWidth: number;
-    imageHeight: number;
-}
-export interface IsometricTileDefinition {
-    /** Tile ID */
-    id: number;
-    /** Name */
-    name: string;
-    /** Region in source image */
-    region: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    /** Tile footprint (for larger tiles) */
-    footprint: {
-        cols: number;
-        rows: number;
-    };
-    /** Height in layers */
-    height: number;
-    /** Anchor point (for positioning) */
-    anchor: {
-        x: number;
-        y: number;
-    };
-    /** Collision type */
-    collision: 'none' | 'solid' | 'half' | 'ramp-n' | 'ramp-s' | 'ramp-e' | 'ramp-w';
-    /** Tags for filtering */
-    tags: string[];
-}
-export interface IsometricMap {
-    /** Map name */
-    name: string;
-    /** Grid dimensions */
-    width: number;
-    height: number;
-    /** Number of layers */
-    layers: number;
-    /** Tile data */
-    tiles: IsometricTile[];
-    /** Tileset references */
-    tilesets: string[];
-    /** Map properties */
-    properties: Record<string, unknown>;
-}
-export interface ScreenPosition {
-    x: number;
-    y: number;
-}
-export interface GridPosition {
-    col: number;
-    row: number;
-    layer: number;
-}
-/**
- * Get projection angles for different isometric types
- */
-export declare function getProjectionAngles(projection: IsometricProjection): {
-    x: number;
-    y: number;
-};
-/**
- * Convert grid coordinates to screen coordinates
- */
-export declare function gridToScreen(gridX: number, gridY: number, layer: number, config: IsometricConfig): ScreenPosition;
-/**
- * Convert screen coordinates to grid coordinates
- */
-export declare function screenToGrid(screenX: number, screenY: number, layer: number, config: IsometricConfig): GridPosition;
-/**
- * Get tile corners in screen space
- */
-export declare function getTileCorners(gridX: number, gridY: number, layer: number, config: IsometricConfig): ScreenPosition[];
-/**
- * Get 3D tile vertices (for cubes/blocks)
- */
-export declare function getTile3DVertices(gridX: number, gridY: number, layer: number, height: number, config: IsometricConfig): {
-    top: ScreenPosition[];
-    left: ScreenPosition[];
-    right: ScreenPosition[];
-};
-/**
- * Sort tiles for correct rendering order (painter's algorithm)
- */
-export declare function sortTilesForRendering(tiles: IsometricTile[]): IsometricTile[];
-/**
- * Get visible tiles within viewport
- */
-export declare function getVisibleTiles(tiles: IsometricTile[], viewport: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}, config: IsometricConfig): IsometricTile[];
-/**
- * Render isometric grid to canvas
- */
-export declare function renderIsometricGrid(ctx: CanvasRenderingContext2D, config: IsometricConfig, options?: {
-    gridColor?: string;
-    gridOpacity?: number;
-    showCoordinates?: boolean;
-}): void;
-/**
- * Render a single isometric tile
- */
-export declare function renderIsometricTile(ctx: CanvasRenderingContext2D, tile: IsometricTile, tileset: IsometricTileset, tileImage: HTMLImageElement, config: IsometricConfig): void;
-/**
- * Render 3D block (cube) at position
- */
-export declare function renderIsometricBlock(ctx: CanvasRenderingContext2D, gridX: number, gridY: number, layer: number, height: number, colors: {
-    top: string;
-    left: string;
-    right: string;
-}, config: IsometricConfig): void;
-/**
- * Create a new isometric map
- */
-export declare function createIsometricMap(name: string, width: number, height: number, layers?: number): IsometricMap;
-/**
- * Add a tile to the map
- */
-export declare function addTile(map: IsometricMap, tile: Omit<IsometricTile, 'id'>): IsometricMap;
-/**
- * Remove a tile from the map
- */
-export declare function removeTile(map: IsometricMap, tileId: string): IsometricMap;
-/**
- * Get tile at position
- */
-export declare function getTileAt(map: IsometricMap, gridX: number, gridY: number, layer: number): IsometricTile | undefined;
-/**
- * Get all tiles at position (all layers)
- */
-export declare function getTilesAt(map: IsometricMap, gridX: number, gridY: number): IsometricTile[];
-/**
- * Fill a region with tiles
- */
-export declare function fillRegion(map: IsometricMap, startX: number, startY: number, endX: number, endY: number, layer: number, tileType: number): IsometricMap;
-/**
- * Export to Tiled TMX format (isometric)
- */
-export declare function exportToTiledIsometric(map: IsometricMap, configOrTileset?: IsometricConfig | IsometricTileset, configArg?: IsometricConfig): string;
-/**
- * Export to Godot isometric tilemap
- */
-export declare function exportToGodotIsometric(map: IsometricMap, configOrTileset?: IsometricConfig | IsometricTileset, configArg?: IsometricConfig): string;
-export interface UseIsometricEditorOptions {
-    /** Initial configuration */
-    config?: Partial<IsometricConfig>;
-    /** Initial map */
-    initialMap?: IsometricMap;
-}
-export interface UseIsometricEditorReturn {
-    /** Current configuration */
-    config: IsometricConfig;
-    /** Current map */
-    map: IsometricMap;
-    /** Update configuration */
-    setConfig: (config: Partial<IsometricConfig>) => void;
-    /** Set selected tile type */
-    setSelectedTile: (tileType: number) => void;
-    /** Selected tile type */
-    selectedTile: number;
-    /** Current layer */
-    currentLayer: number;
-    /** Set current layer */
-    setCurrentLayer: (layer: number) => void;
-    /** Place tile at grid position */
-    placeTile: (gridX: number, gridY: number) => void;
-    /** Remove tile at grid position */
-    eraseTile: (gridX: number, gridY: number) => void;
-    /** Fill region */
-    fill: (startX: number, startY: number, endX: number, endY: number) => void;
-    /** Convert screen to grid */
-    screenToGrid: (screenX: number, screenY: number) => GridPosition;
-    /** Undo last action */
-    undo: () => void;
-    /** Redo last undone action */
-    redo: () => void;
-    /** Can undo */
-    canUndo: boolean;
-    /** Can redo */
-    canRedo: boolean;
-    /** Clear map */
-    clear: () => void;
-}
-export declare function useIsometricEditor(options?: UseIsometricEditorOptions): UseIsometricEditorReturn;
-export default useIsometricEditor;

package/dist/types/game/useAnimationPreview.d.ts

@@ -1,63 +0,0 @@
-/**
- * useAnimationPreview — Hook for animation playback in GameAsset2dEditor
- *
- * Features:
- * - Real-time frame playback with configurable speed
- * - State machine simulation with parameter control
- * - Transition blending preview
- * - Play/pause/stop/step controls
- * - Loop and ping-pong modes
- * - Timeline scrubbing
- */
-import type { SpriteFrame, SpriteSheet, AnimationStateMachine } from './gameAssetTypes';
-export interface AnimationPreviewState {
-    isPlaying: boolean;
-    currentFrameIndex: number;
-    elapsedTime: number;
-    playbackSpeed: number;
-    currentAnimationId: string | null;
-    animationType: 'single' | 'stateMachine';
-    currentStateId: string | null;
-    targetStateId: string | null;
-    transitionProgress: number;
-    isTransitioning: boolean;
-    parameterValues: Map<string, boolean | number>;
-    currentFrame: SpriteFrame | null;
-    frameImageData: ImageData | null;
-    onionSkinEnabled: boolean;
-    onionSkinFrames: number;
-    onionSkinOpacity: number;
-}
-export interface AnimationPreviewOptions {
-    spriteSheets: SpriteSheet[];
-    stateMachines: AnimationStateMachine[];
-    onFrameChange?: (frameIndex: number) => void;
-    onStateChange?: (stateId: string) => void;
-    onTransitionStart?: (fromId: string, toId: string) => void;
-    onTransitionEnd?: (toId: string) => void;
-}
-export interface AnimationPreviewApi {
-    state: AnimationPreviewState;
-    play: () => void;
-    pause: () => void;
-    stop: () => void;
-    stepForward: () => void;
-    stepBackward: () => void;
-    setPlaybackSpeed: (speed: number) => void;
-    toggleLoop: () => void;
-    seekToFrame: (frameIndex: number) => void;
-    seekToTime: (timeMs: number) => void;
-    playAnimation: (animationId: string) => void;
-    playStateMachine: (stateMachineId: string) => void;
-    setParameter: (name: string, value: boolean | number) => void;
-    triggerParameter: (name: string) => void;
-    forceState: (stateId: string) => void;
-    resetStateMachine: () => void;
-    toggleOnionSkin: () => void;
-    setOnionSkinFrames: (count: number) => void;
-    setOnionSkinOpacity: (opacity: number) => void;
-    getAnimationDuration: (animationId: string) => number;
-    getFrameAt: (animationId: string, timeMs: number) => SpriteFrame | null;
-    getCurrentFrameImage: () => HTMLCanvasElement | null;
-}
-export declare function useAnimationPreview(options: AnimationPreviewOptions): AnimationPreviewApi;

package/dist/types/game/useCollisionEditor.d.ts

@@ -1,96 +0,0 @@
-/**
- * useCollisionEditor — Hook for collision editing state management
- *
- * Features:
- * - Collision body management (CRUD)
- * - Undo/redo history
- * - Collision shape operations
- * - Per-frame collision support
- * - Collision testing/preview
- * - Export to physics engine formats
- */
-import type { CollisionBody, CollisionShape, CollisionShapeType } from './CollisionEditor';
-export interface FrameCollision {
-    frameIndex: number;
-    body: CollisionBody;
-}
-export interface CollisionEditorState {
-    /** Current body being edited */
-    currentBody: CollisionBody | null;
-    /** Per-frame collision data */
-    frameCollisions: FrameCollision[];
-    /** Currently selected frame index (for animations) */
-    currentFrameIndex: number;
-    /** Whether to use per-frame collisions */
-    usePerFrameCollisions: boolean;
-    /** Undo history */
-    undoStack: CollisionBody[];
-    /** Redo history */
-    redoStack: CollisionBody[];
-    /** Selected shape ID */
-    selectedShapeId: string | null;
-    /** Preview mode enabled */
-    previewMode: boolean;
-}
-export interface UseCollisionEditorOptions {
-    /** Initial body */
-    initialBody?: CollisionBody | null;
-    /** Initial frame collisions */
-    initialFrameCollisions?: FrameCollision[];
-    /** Max undo history size */
-    maxHistory?: number;
-    /** Called when body changes */
-    onChange?: (body: CollisionBody | null, frameCollisions: FrameCollision[]) => void;
-}
-export interface UseCollisionEditorReturn {
-    /** Current state */
-    state: CollisionEditorState;
-    /** Current body (auto-switches based on frame) */
-    currentBody: CollisionBody | null;
-    /** Update the current body */
-    setBody: (body: CollisionBody) => void;
-    /** Create a new body */
-    createBody: () => void;
-    /** Delete the current body */
-    deleteBody: () => void;
-    /** Clone the current body */
-    cloneBody: () => void;
-    /** Add a shape to current body */
-    addShape: (type: CollisionShapeType) => void;
-    /** Update a shape */
-    updateShape: (shape: CollisionShape) => void;
-    /** Delete a shape */
-    deleteShape: (shapeId: string) => void;
-    /** Duplicate a shape */
-    duplicateShape: (shapeId: string) => void;
-    /** Select a shape */
-    selectShape: (shapeId: string | null) => void;
-    /** Move shape in layer order */
-    moveShape: (shapeId: string, direction: 'up' | 'down') => void;
-    /** Undo last action */
-    undo: () => void;
-    /** Redo last undone action */
-    redo: () => void;
-    /** Can undo */
-    canUndo: boolean;
-    /** Can redo */
-    canRedo: boolean;
-    /** Toggle per-frame collisions */
-    setUsePerFrameCollisions: (use: boolean) => void;
-    /** Set current frame */
-    setCurrentFrame: (frameIndex: number) => void;
-    /** Copy collision to frame */
-    copyToFrame: (targetFrameIndex: number) => void;
-    /** Copy collision to all frames */
-    copyToAllFrames: () => void;
-    /** Toggle preview mode */
-    setPreviewMode: (enabled: boolean) => void;
-    /** Export to physics engine format */
-    exportToFormat: (format: 'box2d' | 'matter' | 'rapier' | 'json') => string;
-    /** Import from JSON */
-    importFromJson: (json: string) => void;
-    /** Reset to defaults */
-    reset: () => void;
-}
-export declare function useCollisionEditor(options?: UseCollisionEditorOptions): UseCollisionEditorReturn;
-export default useCollisionEditor;

package/dist/types/game/useGameAssetExport.d.ts

@@ -1,82 +0,0 @@
-/**
- * useGameAssetExport
- * Hook for exporting game assets from editor contexts
- */
-import type { CollisionShape } from './CollisionEditor';
-import type { ExportFormat, ExportResult, ExportManagerOptions } from './gameAssetExport';
-export interface UseGameAssetExportOptions {
-    /** Asset name */
-    name: string;
-    /** Asset dimensions */
-    width: number;
-    height: number;
-    /** Image data (canvas, blob, or path) */
-    image: HTMLCanvasElement | Blob | string;
-    /** Collision shapes */
-    collisions?: CollisionShape[];
-    /** Animation frames data */
-    frames?: FrameData[];
-    /** Default export format */
-    defaultFormat?: ExportFormat;
-}
-export interface FrameData {
-    /** Frame index */
-    index: number;
-    /** Frame duration in ms */
-    duration: number;
-    /** Frame region in source image */
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Anchor point (0-1) */
-    anchorX?: number;
-    anchorY?: number;
-    /** Per-frame collisions */
-    collisions?: CollisionShape[];
-}
-export interface ExportState {
-    /** Whether export is in progress */
-    isExporting: boolean;
-    /** Export progress (0-1) */
-    progress: number;
-    /** Current export step */
-    step: string;
-    /** Last export results */
-    results: ExportResult[] | null;
-    /** Last export error */
-    error: Error | null;
-}
-export interface UseGameAssetExportReturn {
-    /** Export state */
-    state: ExportState;
-    /** Export to specific format */
-    exportTo: (format: ExportFormat, options?: Partial<ExportManagerOptions['formatOptions']>) => Promise<ExportResult[]>;
-    /** Export and download */
-    exportAndDownload: (format: ExportFormat, options?: Partial<ExportManagerOptions['formatOptions']>) => Promise<void>;
-    /** Export and download as ZIP */
-    exportAndZip: (format: ExportFormat, options?: Partial<ExportManagerOptions['formatOptions']>) => Promise<void>;
-    /** Export to all formats */
-    exportAll: () => Promise<Map<ExportFormat, ExportResult[]>>;
-    /** Clear last results/error */
-    reset: () => void;
-    /** Available formats */
-    availableFormats: ExportFormat[];
-}
-export declare function useGameAssetExport(options: UseGameAssetExportOptions): UseGameAssetExportReturn;
-export interface ExportWithImageOptions extends UseGameAssetExportOptions {
-    /** Include image in export */
-    includeImage?: boolean;
-    /** Image format */
-    imageFormat?: 'png' | 'webp' | 'jpg';
-    /** Image quality (0-1, for jpg/webp) */
-    imageQuality?: number;
-}
-/**
- * Export asset data along with image file
- */
-export declare function exportWithImage(format: ExportFormat, options: ExportWithImageOptions): Promise<{
-    data: ExportResult[];
-    image?: Blob;
-}>;
-export default useGameAssetExport;

package/dist/types/photo/BatchProcessingPanel.d.ts

@@ -1,13 +0,0 @@
-/**
- * BatchProcessingPanel
- * UI panel for batch processing in PhotoEditor
- */
-import React from 'react';
-export interface BatchProcessingPanelProps {
-    /** Called when processing complete */
-    onComplete?: () => void;
-    /** Custom class name */
-    className?: string;
-}
-export declare const BatchProcessingPanel: React.FC<BatchProcessingPanelProps>;
-export default BatchProcessingPanel;

package/dist/types/photo/FaceDetectionPanel.d.ts

@@ -1,19 +0,0 @@
-/**
- * FaceDetectionPanel — UI for face detection and auto-crop
- */
-import React from 'react';
-import { FaceRegion } from './faceDetection';
-export interface FaceDetectionPanelProps {
-    /** Source image data */
-    imageData: ImageData | null;
-    /** Callback when crop is applied */
-    onCrop: (x: number, y: number, width: number, height: number) => void;
-    /** Callback when face regions are detected */
-    onFacesDetected?: (faces: FaceRegion[]) => void;
-    /** Optional class name */
-    className?: string;
-    /** Panel title */
-    title?: string;
-}
-export declare function FaceDetectionPanel({ imageData, onCrop, onFacesDetected, className, title, }: FaceDetectionPanelProps): React.JSX.Element;
-export default FaceDetectionPanel;

package/dist/types/photo/PerspectiveCorrectionPanel.d.ts

@@ -1,17 +0,0 @@
-/**
- * PerspectiveCorrectionPanel
- * UI panel for perspective correction in PhotoEditor
- */
-import React from 'react';
-export interface PerspectiveCorrectionPanelProps {
-    /** Source image data */
-    imageData: ImageData;
-    /** Called when correction is applied */
-    onApply: (result: ImageData) => void;
-    /** Called when cancelled */
-    onCancel?: () => void;
-    /** Custom class name */
-    className?: string;
-}
-export declare const PerspectiveCorrectionPanel: React.FC<PerspectiveCorrectionPanelProps>;
-export default PerspectiveCorrectionPanel;

package/dist/types/photo/RawFilePanel.d.ts

@@ -1,15 +0,0 @@
-/**
- * RawFilePanel — UI for RAW file loading and processing
- */
-import React from 'react';
-import { RawMetadata } from './rawFileSupport';
-export interface RawFilePanelProps {
-    /** Callback when RAW file is processed */
-    onLoad: (imageData: ImageData, metadata: RawMetadata) => void;
-    /** Optional class name */
-    className?: string;
-    /** Panel title */
-    title?: string;
-}
-export declare function RawFilePanel({ onLoad, className, title }: RawFilePanelProps): React.JSX.Element;
-export default RawFilePanel;

package/dist/types/photo/StyleTransferPanel.d.ts

@@ -1,16 +0,0 @@
-/**
- * StyleTransferPanel — UI for AI-based style transfer
- */
-import React from 'react';
-export interface StyleTransferPanelProps {
-    /** Source image data */
-    imageData: ImageData | null;
-    /** Callback when style transfer is applied */
-    onApply: (result: ImageData) => void;
-    /** Optional class name */
-    className?: string;
-    /** Panel title */
-    title?: string;
-}
-export declare function StyleTransferPanel({ imageData, onApply, className, title, }: StyleTransferPanelProps): React.JSX.Element;
-export default StyleTransferPanel;

package/dist/types/photo/aiStyleTransfer.d.ts

@@ -1,58 +0,0 @@
-/**
- * aiStyleTransfer — AI-based style transfer filters for PhotoEditor
- *
- * This module implements neural style transfer effects using pure canvas operations
- * for lightweight, dependency-free artistic filters. Also supports optional
- * TensorFlow.js integration for more advanced neural style transfer.
- *
- * Features:
- * - Pre-defined artistic styles (oil painting, watercolor, sketch, etc.)
- * - Real-time preview with downscaled processing
- * - Adjustable style intensity
- * - Optional TF.js for advanced neural transfer
- */
-export type StylePreset = 'oil-painting' | 'watercolor' | 'pencil-sketch' | 'charcoal' | 'impressionist' | 'pop-art' | 'vintage' | 'noir' | 'cyberpunk' | 'anime' | 'pixel-art' | 'mosaic' | 'pointillism' | 'stained-glass' | 'custom';
-export interface StyleTransferOptions {
-    /** Style preset to apply */
-    style: StylePreset;
-    /** Intensity of the effect (0-1) */
-    intensity: number;
-    /** Detail preservation (0-1) */
-    detailPreservation: number;
-    /** Color saturation adjustment (-1 to 1) */
-    saturation: number;
-    /** Custom style image (for 'custom' preset) */
-    customStyleImage?: ImageData;
-    /** Processing quality (affects speed vs quality) */
-    quality: 'fast' | 'balanced' | 'high';
-}
-export interface StyleTransferResult {
-    imageData: ImageData;
-    processingTimeMs: number;
-    style: StylePreset;
-}
-export declare const DEFAULT_STYLE_OPTIONS: StyleTransferOptions;
-export declare const STYLE_PRESETS: Record<StylePreset, {
-    name: string;
-    description: string;
-}>;
-/**
- * Downscale image for faster preview processing
- */
-export declare function downscaleForPreview(imageData: ImageData, quality: 'fast' | 'balanced' | 'high'): {
-    data: ImageData;
-    scale: number;
-};
-/**
- * Upscale processed image back to original size
- */
-export declare function upscaleFromPreview(imageData: ImageData, originalWidth: number, originalHeight: number): ImageData;
-/**
- * Apply style transfer to an image
- */
-export declare function applyStyleTransfer(imageData: ImageData, options?: Partial<StyleTransferOptions>): StyleTransferResult;
-/**
- * Generate preview thumbnails for all styles
- */
-export declare function generateStylePreviews(imageData: ImageData, size?: number): Promise<Map<StylePreset, ImageData>>;
-export default applyStyleTransfer;