react-native-rectangle-doc-scanner 1.13.0 → 1.14.0

package/ios/RNRDocScannerViewManager.swift

@@ -1,47 +0,0 @@
-import Foundation
-import React
-
-@objc(RNRDocScannerViewManager)
-class RNRDocScannerViewManager: RCTViewManager {
-  override static func requiresMainQueueSetup() -> Bool {
-    true
-  }
-
-  override func view() -> UIView! {
-    RNRDocScannerView()
-  }
-
-  @objc func capture(_ reactTag: NSNumber, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-    bridge.uiManager.addUIBlock { _, viewRegistry in
-      guard let view = viewRegistry?[reactTag] as? RNRDocScannerView else {
-        reject(RNRDocScannerError.viewNotFound.code, RNRDocScannerError.viewNotFound.message, nil)
-        return
-      }
-
-      view.capture { result in
-        switch result {
-        case let .success(payload):
-          resolve([
-            "croppedImage": payload.croppedImage ?? NSNull(),
-            "initialImage": payload.originalImage,
-            "width": payload.width,
-            "height": payload.height,
-          ])
-        case let .failure(error as RNRDocScannerError):
-          reject(error.code, error.message, error)
-        case let .failure(error):
-          reject("capture_failed", error.localizedDescription, error)
-        }
-      }
-    }
-  }
-
-  @objc func reset(_ reactTag: NSNumber) {
-    bridge.uiManager.addUIBlock { _, viewRegistry in
-      guard let view = viewRegistry?[reactTag] as? RNRDocScannerView else {
-        return
-      }
-      view.resetStability()
-    }
-  }
-}

package/react-native-rectangle-doc-scanner.podspec

@@ -1,22 +0,0 @@
-require 'json'
-
-package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
-
-Pod::Spec.new do |s|
-  s.name         = 'react-native-rectangle-doc-scanner'
-  s.version      = package['version']
-  s.summary      = package.fetch('description', 'Document scanner with native camera overlay support for React Native.')
-  s.homepage     = package['homepage'] || 'https://github.com/danchew90/react-native-rectangle-doc-scanner'
-  s.license      = package['license'] || { :type => 'MIT' }
-  s.author       = package['author'] || { 'react-native-rectangle-doc-scanner' => 'opensource@example.com' }
-  s.source       = { :git => package.dig('repository', 'url') || s.homepage, :tag => "v#{s.version}" }
-
-  s.platform     = :ios, '13.0'
-  s.swift_version = '5.0'
-
-  s.source_files = 'ios/**/*.{h,m,mm,swift}'
-  s.public_header_files = 'ios/**/*.h'
-  s.requires_arc = true
-
-  s.dependency 'React-Core'
-end

package/src/utils/overlay.tsx

@@ -1,208 +0,0 @@
-import React, { useMemo } from 'react';
-import { View, StyleSheet, useWindowDimensions } from 'react-native';
-import { Canvas, Path, Skia } from '@shopify/react-native-skia';
-import type { Point } from '../types';
-
-const lerp = (start: Point, end: Point, t: number): Point => ({
-  x: start.x + (end.x - start.x) * t,
-  y: start.y + (end.y - start.y) * t,
-});
-
-const withAlpha = (value: string, alpha: number): string => {
-  const hexMatch = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(value.trim());
-  if (!hexMatch) {
-    return `rgba(231, 166, 73, ${alpha})`;
-  }
-
-  const hex = hexMatch[1];
-  const normalize = hex.length === 3
-    ? hex.split('').map((ch) => ch + ch).join('')
-    : hex;
-
-  const r = parseInt(normalize.slice(0, 2), 16);
-  const g = parseInt(normalize.slice(2, 4), 16);
-  const b = parseInt(normalize.slice(4, 6), 16);
-  return `rgba(${r}, ${g}, ${b}, ${alpha})`;
-};
-
-type OverlayProps = {
-  quad: Point[] | null;
-  color?: string;
-  frameSize: { width: number; height: number } | null;
-  showGrid?: boolean;
-  gridColor?: string;
-  gridLineWidth?: number;
-};
-
-type OverlayGeometry = {
-  outlinePath: ReturnType<typeof Skia.Path.Make> | null;
-  gridPaths: ReturnType<typeof Skia.Path.Make>[];
-};
-
-const buildPath = (points: Point[]) => {
-  const path = Skia.Path.Make();
-  path.moveTo(points[0].x, points[0].y);
-  points.slice(1).forEach((p) => path.lineTo(p.x, p.y));
-  path.close();
-  return path;
-};
-
-const orderQuad = (points: Point[]): Point[] => {
-  if (points.length !== 4) {
-    return points;
-  }
-
-  const center = points.reduce(
-    (acc, point) => ({ x: acc.x + point.x / 4, y: acc.y + point.y / 4 }),
-    { x: 0, y: 0 },
-  );
-
-  const sorted = [...points].sort((a, b) => {
-    const angleA = Math.atan2(a.y - center.y, a.x - center.x);
-    const angleB = Math.atan2(b.y - center.y, b.x - center.x);
-    return angleA - angleB;
-  });
-
-  // Ensure the first point is the top-left (smallest y, then smallest x)
-  let startIndex = 0;
-  for (let i = 1; i < sorted.length; i += 1) {
-    const current = sorted[i];
-    const candidate = sorted[startIndex];
-    if (current.y < candidate.y || (current.y === candidate.y && current.x < candidate.x)) {
-      startIndex = i;
-    }
-  }
-
-  return [
-    sorted[startIndex % 4],
-    sorted[(startIndex + 1) % 4],
-    sorted[(startIndex + 2) % 4],
-    sorted[(startIndex + 3) % 4],
-  ];
-};
-
-export const Overlay: React.FC<OverlayProps> = ({
-  quad,
-  color = '#e7a649',
-  frameSize,
-  showGrid = true,
-  gridColor = 'rgba(231, 166, 73, 0.35)',
-  gridLineWidth = 2,
-}) => {
-  const { width: screenWidth, height: screenHeight } = useWindowDimensions();
-  const fillColor = useMemo(() => withAlpha(color, 0.2), [color]);
-
-  const { outlinePath, gridPaths }: OverlayGeometry = useMemo(() => {
-    let transformedQuad: Point[] | null = null;
-    let sourceQuad: Point[] | null = null;
-    let sourceFrameSize = frameSize;
-
-    if (quad && frameSize) {
-      sourceQuad = quad;
-    } else {
-      // No detection yet – skip drawing
-      return { outlinePath: null, gridPaths: [] };
-    }
-
-    if (sourceQuad && sourceFrameSize) {
-      if (__DEV__) {
-        console.log('[Overlay] drawing quad:', sourceQuad);
-        console.log('[Overlay] color:', color);
-        console.log('[Overlay] screen dimensions:', screenWidth, 'x', screenHeight);
-        console.log('[Overlay] frame dimensions:', sourceFrameSize.width, 'x', sourceFrameSize.height);
-      }
-
-      const isFrameLandscape = sourceFrameSize.width > sourceFrameSize.height;
-      const isScreenPortrait = screenHeight > screenWidth;
-      const needsRotation = isFrameLandscape && isScreenPortrait;
-
-      if (needsRotation) {
-        const scaleX = screenWidth / sourceFrameSize.height;
-        const scaleY = screenHeight / sourceFrameSize.width;
-
-        transformedQuad = sourceQuad.map((p) => ({
-          x: p.y * scaleX,
-          y: (sourceFrameSize.width - p.x) * scaleY,
-        }));
-      } else {
-        const scaleX = screenWidth / sourceFrameSize.width;
-        const scaleY = screenHeight / sourceFrameSize.height;
-
-        transformedQuad = sourceQuad.map((p) => ({
-          x: p.x * scaleX,
-          y: p.y * scaleY,
-        }));
-      }
-    }
-
-    if (!transformedQuad) {
-      return { outlinePath: null, gridPaths: [] };
-    }
-
-    const normalizedQuad = orderQuad(transformedQuad);
-    const skPath = buildPath(normalizedQuad);
-    const grid: ReturnType<typeof Skia.Path.Make>[] = [];
-
-    if (showGrid) {
-      const [topLeft, topRight, bottomRight, bottomLeft] = normalizedQuad;
-      const steps = [1 / 3, 2 / 3];
-
-      steps.forEach((t) => {
-        const start = lerp(topLeft, topRight, t);
-        const end = lerp(bottomLeft, bottomRight, t);
-        const verticalPath = Skia.Path.Make();
-        verticalPath.moveTo(start.x, start.y);
-        verticalPath.lineTo(end.x, end.y);
-        grid.push(verticalPath);
-      });
-
-      steps.forEach((t) => {
-        const start = lerp(topLeft, bottomLeft, t);
-        const end = lerp(topRight, bottomRight, t);
-        const horizontalPath = Skia.Path.Make();
-        horizontalPath.moveTo(start.x, start.y);
-        horizontalPath.lineTo(end.x, end.y);
-        grid.push(horizontalPath);
-      });
-    }
-
-    return { outlinePath: skPath, gridPaths: grid };
-  }, [quad, screenWidth, screenHeight, frameSize, showGrid, color]);
-
-  if (__DEV__) {
-    console.log('[Overlay] rendering Canvas with dimensions:', screenWidth, 'x', screenHeight);
-  }
-
-  return (
-    <View style={styles.container} pointerEvents="none">
-      <Canvas style={{ width: screenWidth, height: screenHeight }}>
-        {outlinePath && (
-          <>
-            <Path path={outlinePath} color={color} style="stroke" strokeWidth={8} />
-            <Path path={outlinePath} color={fillColor} style="fill" />
-            {gridPaths.map((gridPath, index) => (
-              <Path
-                // eslint-disable-next-line react/no-array-index-key
-                key={`grid-${index}`}
-                path={gridPath}
-                color={gridColor}
-                style="stroke"
-                strokeWidth={gridLineWidth}
-              />
-            ))}
-          </>
-        )}
-      </Canvas>
-    </View>
-  );
-};
-
-const styles = StyleSheet.create({
-  container: {
-    position: 'absolute',
-    top: 0,
-    left: 0,
-    right: 0,
-    bottom: 0,
-  },
-});

package/src/utils/quad.ts

@@ -1,181 +0,0 @@
-import type { Point } from '../types';
-
-const POINT_EPSILON = 1e-3;
-
-const isFiniteNumber = (value: number): boolean => Number.isFinite(value) && !Number.isNaN(value);
-
-export const isValidPoint = (point: Point | null | undefined): point is Point => {
-  if (!point) {
-    return false;
-  }
-
-  if (!isFiniteNumber(point.x) || !isFiniteNumber(point.y)) {
-    return false;
-  }
-
-  if (Math.abs(point.x) > 1_000_000 || Math.abs(point.y) > 1_000_000) {
-    return false;
-  }
-
-  return true;
-};
-
-export const isValidQuad = (quad: Point[] | null | undefined): quad is Point[] => {
-  return Array.isArray(quad) && quad.length === 4 && quad.every(isValidPoint);
-};
-
-const clonePoint = (point: Point): Point => ({ x: point.x, y: point.y });
-
-export const orderQuadPoints = (quad: Point[]): Point[] => {
-  const centroid = quad.reduce(
-    (acc, point) => ({ x: acc.x + point.x / quad.length, y: acc.y + point.y / quad.length }),
-    { x: 0, y: 0 },
-  );
-
-  const sorted = quad
-    .slice()
-    .map(clonePoint)
-    .sort((a, b) => {
-      const angleA = Math.atan2(a.y - centroid.y, a.x - centroid.x);
-      const angleB = Math.atan2(b.y - centroid.y, b.x - centroid.x);
-      return angleA - angleB;
-    });
-
-  const topLeftIndex = sorted.reduce((selectedIndex, point, index) => {
-    const currentScore = point.x + point.y;
-    const selectedPoint = sorted[selectedIndex];
-    const selectedScore = selectedPoint.x + selectedPoint.y;
-    if (currentScore < selectedScore - POINT_EPSILON) {
-      return index;
-    }
-    return selectedIndex;
-  }, 0);
-
-  return [...sorted.slice(topLeftIndex), ...sorted.slice(0, topLeftIndex)];
-};
-
-export const quadDistance = (a: Point[], b: Point[]): number => {
-  if (!isValidQuad(a) || !isValidQuad(b)) {
-    return Number.POSITIVE_INFINITY;
-  }
-
-  let total = 0;
-  for (let i = 0; i < 4; i += 1) {
-    total += Math.hypot(a[i].x - b[i].x, a[i].y - b[i].y);
-  }
-
-  return total / 4;
-};
-
-export const averageQuad = (quads: Point[][]): Point[] => {
-  if (!Array.isArray(quads) || quads.length === 0) {
-    throw new Error('Cannot average empty quad array');
-  }
-
-  const accum: Point[] = quads[0].map(() => ({ x: 0, y: 0 }));
-
-  quads.forEach((quad) => {
-    quad.forEach((point, index) => {
-      accum[index].x += point.x;
-      accum[index].y += point.y;
-    });
-  });
-
-  return accum.map((point) => ({ x: point.x / quads.length, y: point.y / quads.length }));
-};
-
-export const blendQuads = (base: Point[], target: Point[], alpha: number): Point[] => {
-  if (alpha <= 0) {
-    return base.map(clonePoint);
-  }
-
-  if (alpha >= 1) {
-    return target.map(clonePoint);
-  }
-
-  return base.map((point, index) => ({
-    x: point.x * (1 - alpha) + target[index].x * alpha,
-    y: point.y * (1 - alpha) + target[index].y * alpha,
-  }));
-};
-
-export const sanitizeQuad = (quad: Point[]): Point[] => {
-  if (!isValidQuad(quad)) {
-    throw new Error('Cannot sanitise invalid quad');
-  }
-
-  return quad.map((point) => ({
-    x: Number.isFinite(point.x) ? point.x : 0,
-    y: Number.isFinite(point.y) ? point.y : 0,
-  }));
-};
-
-export const quadArea = (quad: Point[]): number => {
-  if (!isValidQuad(quad)) {
-    return 0;
-  }
-
-  let area = 0;
-  for (let i = 0; i < 4; i += 1) {
-    const current = quad[i];
-    const next = quad[(i + 1) % 4];
-    area += current.x * next.y - next.x * current.y;
-  }
-
-  return Math.abs(area) / 2;
-};
-
-export const quadCenter = (quad: Point[]): Point => {
-  if (!isValidQuad(quad)) {
-    return { x: 0, y: 0 };
-  }
-
-  const sum = quad.reduce(
-    (acc, point) => ({ x: acc.x + point.x, y: acc.y + point.y }),
-    { x: 0, y: 0 },
-  );
-
-  return {
-    x: sum.x / quad.length,
-    y: sum.y / quad.length,
-  };
-};
-
-export const quadEdgeLengths = (quad: Point[]): number[] => {
-  if (!isValidQuad(quad)) {
-    return [0, 0, 0, 0];
-  }
-
-  const lengths: number[] = [];
-
-  for (let i = 0; i < 4; i += 1) {
-    const current = quad[i];
-    const next = quad[(i + 1) % 4];
-    lengths.push(Math.hypot(next.x - current.x, next.y - current.y));
-  }
-
-  return lengths;
-};
-
-export const weightedAverageQuad = (quads: Point[][]): Point[] => {
-  if (!Array.isArray(quads) || quads.length === 0) {
-    throw new Error('Cannot average empty quad array');
-  }
-
-  const weights = quads.map((_, index) => index + 1);
-  const totalWeight = weights.reduce((acc, weight) => acc + weight, 0);
-
-  const accum: Point[] = quads[0].map(() => ({ x: 0, y: 0 }));
-
-  quads.forEach((quad, quadIndex) => {
-    quad.forEach((point, pointIndex) => {
-      accum[pointIndex].x += point.x * weights[quadIndex];
-      accum[pointIndex].y += point.y * weights[quadIndex];
-    });
-  });
-
-  return accum.map((point) => ({
-    x: point.x / totalWeight,
-    y: point.y / totalWeight,
-  }));
-};

package/src/utils/stability.ts

@@ -1,32 +0,0 @@
-import type { Point } from '../types';
-import { isValidQuad, quadDistance } from './quad';
-
-let last: Point[] | null = null;
-let stable = 0;
-
-const STABILITY_DISTANCE = 8;
-
-export function checkStability(current: Point[] | null): number {
-  if (!isValidQuad(current)) {
-    stable = 0;
-    last = null;
-    return 0;
-  }
-
-  if (!last) {
-    last = current;
-    stable = 1;
-    return stable;
-  }
-
-  const diff = quadDistance(current, last);
-
-  if (diff < STABILITY_DISTANCE) {
-    stable++;
-  } else {
-    stable = 0;
-  }
-
-  last = current;
-  return stable;
-}