chore: Move everything into package/ (#1745)

* Move everything into package

* Remove .DS_Store

* Move scripts and eslintrc to package

* Create CODE_OF_CONDUCT.md

* fix some links

* Update all links (I think)

* Update generated docs

* Update notice-yarn-changes.yml

* Update validate-android.yml

* Update validate-cpp.yml

* Delete notice-yarn-changes.yml

* Update validate-cpp.yml

* Update validate-cpp.yml

* Update validate-js.yml

* Update validate-cpp.yml

* Update validate-cpp.yml

* wrong c++ style

* Revert "wrong c++ style"

This reverts commit 55a3575589c6f13f8b05134d83384f55e0601ab2.

package/src/hooks/useCameraDevices.ts

@@ -0,0 +1,78 @@
+import { useEffect, useState } from 'react';
+import type { CameraPosition } from '../CameraPosition';
+import { sortDevices } from '../utils/FormatFilter';
+import { Camera } from '../Camera';
+import { CameraDevice, LogicalCameraDeviceType, parsePhysicalDeviceTypes, PhysicalCameraDeviceType } from '../CameraDevice';
+
+export type CameraDevices = {
+  [key in CameraPosition]: CameraDevice | undefined;
+};
+const DefaultCameraDevices: CameraDevices = {
+  back: undefined,
+  external: undefined,
+  front: undefined,
+  unspecified: undefined,
+};
+
+/**
+ * Gets the best available {@linkcode CameraDevice}. Devices with more cameras are preferred.
+ *
+ * @returns The best matching {@linkcode CameraDevice}.
+ * @throws {@linkcode CameraRuntimeError} if no device was found.
+ * @example
+ * ```tsx
+ * const device = useCameraDevice()
+ * // ...
+ * return <Camera device={device} />
+ * ```
+ */
+export function useCameraDevices(): CameraDevices;
+
+/**
+ * Gets a {@linkcode CameraDevice} for the requested device type.
+ *
+ * @param {PhysicalCameraDeviceType | LogicalCameraDeviceType} deviceType Specifies a device type which will be used as a device filter.
+ * @returns A {@linkcode CameraDevice} for the requested device type.
+ * @throws {@linkcode CameraRuntimeError} if no device was found.
+ * @example
+ * ```tsx
+ * const device = useCameraDevice('wide-angle-camera')
+ * // ...
+ * return <Camera device={device} />
+ * ```
+ */
+export function useCameraDevices(deviceType: PhysicalCameraDeviceType | LogicalCameraDeviceType): CameraDevices;
+
+export function useCameraDevices(deviceType?: PhysicalCameraDeviceType | LogicalCameraDeviceType): CameraDevices {
+  const [cameraDevices, setCameraDevices] = useState<CameraDevices>(DefaultCameraDevices);
+
+  useEffect(() => {
+    let isMounted = true;
+
+    const loadDevice = async (): Promise<void> => {
+      let devices = await Camera.getAvailableCameraDevices();
+      if (!isMounted) return;
+
+      devices = devices.sort(sortDevices);
+      if (deviceType != null) {
+        devices = devices.filter((d) => {
+          const parsedType = parsePhysicalDeviceTypes(d.devices);
+          return parsedType === deviceType;
+        });
+      }
+      setCameraDevices({
+        back: devices.find((d) => d.position === 'back'),
+        external: devices.find((d) => d.position === 'external'),
+        front: devices.find((d) => d.position === 'front'),
+        unspecified: devices.find((d) => d.position === 'unspecified'),
+      });
+    };
+    loadDevice();
+
+    return () => {
+      isMounted = false;
+    };
+  }, [deviceType]);
+
+  return cameraDevices;
+}

package/src/hooks/useCameraFormat.ts

@@ -0,0 +1,16 @@
+import { useMemo } from 'react';
+import type { CameraDevice, CameraDeviceFormat } from '../CameraDevice';
+import { sortFormats } from '../utils/FormatFilter';
+
+/**
+ * Returns the best format for the given camera device.
+ *
+ * This function tries to choose a format with the highest possible photo-capture resolution and best matching aspect ratio.
+ *
+ * @param {CameraDevice} device The Camera Device
+ *
+ * @returns The best matching format for the given camera device, or `undefined` if the camera device is `undefined`.
+ */
+export function useCameraFormat(device?: CameraDevice): CameraDeviceFormat | undefined {
+  return useMemo(() => device?.formats.sort(sortFormats)[0], [device?.formats]);
+}

package/src/hooks/useFrameProcessor.ts

@@ -0,0 +1,52 @@
+import { DependencyList, useMemo } from 'react';
+import type { Frame, FrameInternal } from '../Frame';
+import { FrameProcessor } from '../CameraProps';
+
+/**
+ * Create a new Frame Processor function which you can pass to the `<Camera>`.
+ * (See ["Frame Processors"](https://mrousavy.github.io/react-native-vision-camera/docs/guides/frame-processors))
+ *
+ * Make sure to add the `'worklet'` directive to the top of the Frame Processor function, otherwise it will not get compiled into a worklet.
+ *
+ * Also make sure to memoize the returned object, so that the Camera doesn't reset the Frame Processor Context each time.
+ */
+export function createFrameProcessor(frameProcessor: FrameProcessor['frameProcessor'], type: FrameProcessor['type']): FrameProcessor {
+  return {
+    frameProcessor: (frame: Frame) => {
+      'worklet';
+      // Increment ref-count by one
+      (frame as FrameInternal).incrementRefCount();
+      try {
+        // Call sync frame processor
+        frameProcessor(frame);
+      } finally {
+        // Potentially delete Frame if we were the last ref (no runAsync)
+        (frame as FrameInternal).decrementRefCount();
+      }
+    },
+    type: type,
+  };
+}
+
+/**
+ * Returns a memoized Frame Processor function wich you can pass to the `<Camera>`.
+ * (See ["Frame Processors"](https://mrousavy.github.io/react-native-vision-camera/docs/guides/frame-processors))
+ *
+ * Make sure to add the `'worklet'` directive to the top of the Frame Processor function, otherwise it will not get compiled into a worklet.
+ *
+ * @param frameProcessor The Frame Processor
+ * @param dependencies The React dependencies which will be copied into the VisionCamera JS-Runtime.
+ * @returns The memoized Frame Processor.
+ * @example
+ * ```ts
+ * const frameProcessor = useFrameProcessor((frame) => {
+ *   'worklet'
+ *   const qrCodes = scanQRCodes(frame)
+ *   console.log(`QR Codes: ${qrCodes}`)
+ * }, [])
+ * ```
+ */
+export function useFrameProcessor(frameProcessor: (frame: Frame) => void, dependencies: DependencyList): FrameProcessor {
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  return useMemo(() => createFrameProcessor(frameProcessor, 'frame-processor'), dependencies);
+}