@privyid/persona 1.2.0 → 1.2.1

package/dist/components/pdf-object/utils/overlap.bench.mjs

@@ -1,241 +0,0 @@
-import { bench } from "vitest";
-import {
-  times,
-  random,
-  round,
-  has,
-  set,
-  memoize
-} from "lodash-es";
-import {
-  getEmptyPosition
-} from "./overlap.mjs";
-function hashPosition(position) {
-  return BigInt(position.x) << 64n | BigInt(position.y);
-}
-function useLoop() {
-  return (object, objects) => {
-    for (const other of objects) {
-      if (round(object.x, -1) === round(other.x, -1) && round(object.y, -1) === round(other.y, -1))
-        return true;
-    }
-    return false;
-  };
-}
-function useLodashSet(objects) {
-  const cache = {};
-  for (const object of objects) {
-    const x = round(object.x, -1);
-    const y = round(object.y, -1);
-    set(cache, [x, y], object);
-  }
-  return (object) => {
-    const x = round(object.x, -1);
-    const y = round(object.y, -1);
-    return has(object, [x, y]);
-  };
-}
-function useLoopMemoize() {
-  return memoize(useLoop(), (object) => {
-    return object.x << 32 | object.y;
-  });
-}
-function useMap(objects) {
-  const xMap = /* @__PURE__ */ new Map();
-  for (const object of objects) {
-    const x = round(object.x, -1);
-    const y = round(object.y, -1);
-    const yMap = xMap.get(x) ?? /* @__PURE__ */ new Map();
-    yMap.set(y, object);
-    xMap.set(x, yMap);
-  }
-  return (object) => {
-    const x = round(object.x, -1);
-    const y = round(object.y, -1);
-    return xMap.get(x)?.get(y) !== void 0;
-  };
-}
-function useMapMemoize(objects) {
-  const xMap = /* @__PURE__ */ new Map();
-  const mRound = memoize(round);
-  for (const object of objects) {
-    const x = mRound(object.x, -1);
-    const y = mRound(object.y, -1);
-    const yMap = xMap.get(x) ?? /* @__PURE__ */ new Map();
-    yMap.set(y, object);
-    xMap.set(x, yMap);
-  }
-  return (object) => {
-    const x = mRound(object.x, -1);
-    const y = mRound(object.y, -1);
-    return xMap.get(x)?.get(y) !== void 0;
-  };
-}
-function useHash(objects) {
-  const hashes = /* @__PURE__ */ new Set();
-  const mRound = memoize(round);
-  for (const object of objects) {
-    const hash = hashPosition({
-      x: mRound(object.x, -1),
-      y: mRound(object.y, -1)
-    });
-    hashes.add(hash);
-  }
-  return (object) => {
-    const hash = hashPosition({
-      x: mRound(object.x, -1),
-      y: mRound(object.y, -1)
-    });
-    return hashes.has(hash);
-  };
-}
-function useObject(objects) {
-  const xMap = {};
-  const mRound = memoize(round);
-  for (const object of objects) {
-    const x = mRound(object.x, -1);
-    const y = mRound(object.y, -1);
-    const yMap = xMap[x] ?? {};
-    yMap[y] = object;
-    xMap[x] = yMap;
-  }
-  return (object) => {
-    const x = mRound(object.x, -1);
-    const y = mRound(object.y, -1);
-    return xMap[x]?.[y] !== void 0;
-  };
-}
-function useMapMemoizeNoLodash(objects) {
-  const xMap = /* @__PURE__ */ new Map();
-  const mRound = memoize((value) => Math.round(value / 10) * 10);
-  for (const object of objects) {
-    const x = mRound(object.x);
-    const y = mRound(object.y);
-    const yMap = xMap.get(x) ?? /* @__PURE__ */ new Map();
-    yMap.set(y, object);
-    xMap.set(x, yMap);
-  }
-  return (object) => {
-    const x = mRound(object.x);
-    const y = mRound(object.y);
-    return xMap.get(x)?.get(y) !== void 0;
-  };
-}
-describe("checkOverlap", () => {
-  const object = {
-    x: random(0, 1500, false),
-    y: random(0, 1500, false)
-  };
-  const objects = times(100, () => {
-    return {
-      x: random(0, 1500, false),
-      y: random(0, 1500, false)
-    };
-  });
-  bench("using loop", () => {
-    const checkOverlap = useLoop();
-    checkOverlap(object, objects);
-  });
-  bench("using map", () => {
-    const checkOverlap = useMap(objects);
-    checkOverlap(object, objects);
-  });
-  bench("using lodash/set", () => {
-    const checkOverlap = useLodashSet(objects);
-    checkOverlap(object, objects);
-  });
-  bench("using loop + memoize", () => {
-    const checkOverlap = useLoopMemoize();
-    checkOverlap(object, objects);
-  });
-  bench("using map + memoize round", () => {
-    const checkOverlap = useMapMemoize(objects);
-    checkOverlap(object, objects);
-  });
-  bench("using object + memoize round", () => {
-    const checkOverlap = useObject(objects);
-    checkOverlap(object, objects);
-  });
-});
-describe("getEmptyPosition", () => {
-  const offside = {
-    width: 793,
-    height: 1122
-  };
-  const size = {
-    width: 198,
-    height: 106
-  };
-  const objects = [];
-  times(300, () => {
-    objects.push(getEmptyPosition({
-      offside,
-      size,
-      objects
-    }));
-  });
-  bench("using loop", () => {
-    getEmptyPosition({
-      offside,
-      size,
-      objects,
-      checkOverlap: useLoop()
-    });
-  });
-  bench("using map", () => {
-    getEmptyPosition({
-      offside,
-      size,
-      objects,
-      checkOverlap: useMap(objects)
-    });
-  });
-  bench("using lodash/set", () => {
-    getEmptyPosition({
-      offside,
-      size,
-      objects,
-      checkOverlap: useLodashSet(objects)
-    });
-  });
-  bench("using loop + memoize", () => {
-    getEmptyPosition({
-      offside,
-      size,
-      objects,
-      checkOverlap: useLoopMemoize()
-    });
-  });
-  bench("using map + memoize round", () => {
-    getEmptyPosition({
-      offside,
-      size,
-      objects,
-      checkOverlap: useMapMemoize(objects)
-    });
-  });
-  bench("using hash + memoize round", () => {
-    getEmptyPosition({
-      offside,
-      size,
-      objects,
-      checkOverlap: useHash(objects)
-    });
-  });
-  bench("using object + memoize round", () => {
-    getEmptyPosition({
-      offside,
-      size,
-      objects,
-      checkOverlap: useObject(objects)
-    });
-  });
-  bench("using map + memoize round native", () => {
-    getEmptyPosition({
-      offside,
-      size,
-      objects,
-      checkOverlap: useMapMemoizeNoLodash(objects)
-    });
-  });
-});

package/dist/components/pdf-object/utils/overlap.d.ts

@@ -1,51 +0,0 @@
-export interface ObjectSize {
-    width: number;
-    height: number;
-}
-export interface ObjectPosition {
-    x: number;
-    y: number;
-}
-export type CheckOverlapFn = (object: ObjectPosition, objects: Iterable<ObjectPosition>) => boolean;
-export interface GetEmptyPositionOptions {
-    /**
-     * Other objects position
-     */
-    objects: Iterable<ObjectPosition>;
-    /**
-     * Object size
-     */
-    size: ObjectSize;
-    /**
-     * Offside size
-     */
-    offside: ObjectSize;
-    /**
-     * Function to check overlap
-     */
-    checkOverlap?: CheckOverlapFn;
-}
-/**
- * Check center position of reference
- * @param object Object which want to place
- * @param reference Reference place
- */
-export declare function getCenter(object: ObjectSize, reference: ObjectSize): {
-    x: number;
-    y: number;
-};
-/**
- * Check object is outside from reference
- * @param object
- * @param reference
- */
-export declare function isOffside(object: ObjectSize & ObjectPosition, reference: ObjectSize): boolean;
-/**
- * Check Overlap Fn using Map as Cache Keys
- * @param objects
- */
-export declare function useMapSnapshot(objects: Iterable<ObjectPosition>): CheckOverlapFn;
-/**
- * Get empty position which not colide with other objects and not outside the reference place
- */
-export declare function getEmptyPosition(options: GetEmptyPositionOptions): ObjectPosition;

package/dist/components/pdf-object/utils/overlap.mjs

@@ -1,54 +0,0 @@
-import { memoize } from "lodash-es";
-export function getCenter(object, reference) {
-  return {
-    x: (reference.width - object.width) / 2,
-    y: (reference.height - object.height) / 2
-  };
-}
-export function isOffside(object, reference) {
-  return object.x + object.width > reference.width || object.y + object.height > reference.height;
-}
-export function useMapSnapshot(objects) {
-  const xMap = /* @__PURE__ */ new Map();
-  const round = memoize((value) => Math.round(value / 15) * 15);
-  for (const object of objects) {
-    const x = round(object.x);
-    const y = round(object.y);
-    const yMap = xMap.get(x) ?? /* @__PURE__ */ new Map();
-    yMap.set(y, object);
-    xMap.set(x, yMap);
-  }
-  return (object) => {
-    const x = round(object.x);
-    const y = round(object.y);
-    return xMap.get(x)?.get(y) !== void 0;
-  };
-}
-export function getEmptyPosition(options) {
-  const checkOverlap = options.checkOverlap ?? useMapSnapshot(options.objects);
-  const center = getCenter(options.size, options.offside);
-  const position = {
-    ...options.size,
-    ...center
-  };
-  let found = true;
-  let loop = 0;
-  let deltaY = 0;
-  do {
-    found = true;
-    if (isOffside(position, options.offside)) {
-      position.y = center.y + deltaY;
-      position.x = center.x;
-      deltaY += 15;
-      found = false;
-    }
-    if (checkOverlap(position, options.objects)) {
-      position.x += 15;
-      position.y += 15;
-      found = false;
-    }
-  } while (!found && ++loop <= 500);
-  if (!found)
-    console.warn("Cannot find empty position, max iteration reach");
-  return position;
-}

package/dist/components/pdf-object/utils/overlap.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/components/pdf-object/utils/overlap.spec.mjs

@@ -1,125 +0,0 @@
-import {
-  getCenter,
-  getEmptyPosition,
-  isOffside,
-  useMapSnapshot
-} from "./overlap.mjs";
-describe("getCenter", () => {
-  it("should return center position", () => {
-    const result = getCenter({ width: 100, height: 100 }, { width: 500, height: 500 });
-    expect(result.x).toBe(200);
-    expect(result.y).toBe(200);
-  });
-});
-describe("isOffside", () => {
-  it("should able to detect is object offside from boundary", () => {
-    const a = isOffside({
-      x: 100,
-      y: 100,
-      width: 150,
-      height: 50
-    }, { width: 200, height: 200 });
-    const b = isOffside({
-      x: 175,
-      y: 100,
-      width: 150,
-      height: 50
-    }, { width: 200, height: 200 });
-    const c = isOffside({
-      x: 100,
-      y: 100,
-      width: 50,
-      height: 50
-    }, { width: 200, height: 200 });
-    expect(a).toBe(true);
-    expect(b).toBe(true);
-    expect(c).toBe(false);
-  });
-});
-describe("useMapSnapshot", () => {
-  it("should able detect is object overlaping (collision)", () => {
-    const objects = [
-      { x: 100, y: 100 },
-      { x: 115, y: 115 },
-      { x: 130, y: 130 },
-      { x: 145, y: 145 },
-      { x: 160, y: 160 },
-      { x: 175, y: 175 },
-      { x: 190, y: 190 }
-    ];
-    const checkOverlap = useMapSnapshot(objects);
-    const a = checkOverlap({ x: 130, y: 130 }, []);
-    const b = checkOverlap({ x: 135, y: 130 }, []);
-    const c = checkOverlap({ x: 50, y: 50 }, []);
-    expect(a).toBe(true);
-    expect(b).toBe(true);
-    expect(c).toBe(false);
-  });
-});
-describe("getEmptyPosition", () => {
-  it("should return center of offside reference size", () => {
-    const offside = {
-      width: 793,
-      height: 1122
-    };
-    const size = {
-      width: 198,
-      height: 106
-    };
-    const result = getEmptyPosition({
-      offside,
-      size,
-      objects: []
-    });
-    expect(result.x).toBe(297.5);
-    expect(result.y).toBe(508);
-  });
-  it("should return other position if current center position is already taken", () => {
-    const offside = {
-      width: 793,
-      height: 1122
-    };
-    const size = {
-      width: 198,
-      height: 106
-    };
-    const result = getEmptyPosition({
-      offside,
-      size,
-      objects: [
-        {
-          x: 297.5,
-          y: 508
-        }
-      ]
-    });
-    expect(result.x).toBe(297.5 + 15);
-    expect(result.y).toBe(508 + 15);
-  });
-  it("should return no offside position", () => {
-    const offside = {
-      width: 300,
-      height: 300
-    };
-    const size = {
-      width: 100,
-      height: 100
-    };
-    const objects = [
-      { x: 100, y: 100 },
-      { x: 115, y: 115 },
-      { x: 130, y: 130 },
-      { x: 145, y: 145 },
-      { x: 160, y: 160 },
-      { x: 175, y: 175 },
-      { x: 190, y: 190 }
-    ];
-    const result = getEmptyPosition({
-      offside,
-      size,
-      objects
-    });
-    expect(result.x).toBe(100);
-    expect(result.y).toBe(115);
-  });
-});

package/dist/components/pdf-object/utils/position.d.ts

@@ -1,64 +0,0 @@
-interface ComputePosition {
-    /**
-     * Root container element
-     */
-    container: HTMLElement;
-    /**
-     * Reference element where the object should be placed
-     */
-    reference: HTMLElement;
-    /**
-     * Zoom scale
-     */
-    scale: number;
-    /**
-     * X Position
-     */
-    x: number;
-    /**
-     * Y Position
-     */
-    y: number;
-}
-interface GetPosition {
-    /**
-     * Root container element
-     */
-    container?: HTMLElement;
-    /**
-     * Reference element where the object should be placed
-     */
-    reference: HTMLElement;
-    /**
-     * Object element
-     */
-    object: HTMLElement;
-    /**
-     * Zoom scale
-     */
-    scale: number;
-}
-/**
- * Find nearest relative parent element
- * @param element Element to search
- * @param container Maximum search element
- */
-export declare function findRelativeParent(element: HTMLElement, container?: HTMLElement): HTMLElement | null;
-/**
- * Computed X, Y position to Top, Left position
- * @param context
- */
-export declare function computePosition(context: ComputePosition): {
-    top: number;
-    left: number;
-};
-/**
- * Get X, Y position from object
- * @param context
- */
-export declare function getPosition(context: GetPosition): {
-    x: number;
-    y: number;
-    page: number;
-};
-export {};

package/dist/components/pdf-object/utils/position.mjs

@@ -1,48 +0,0 @@
-import { clamp } from "lodash-es";
-export function findRelativeParent(element, container = document.body) {
-  let parent = element.parentElement;
-  do {
-    const { position } = window.getComputedStyle(parent);
-    if (position === "relative" || position === "absolute")
-      return parent;
-    parent = parent.parentElement;
-  } while (parent && parent !== container);
-  return container;
-}
-export function computePosition(context) {
-  const {
-    container,
-    reference,
-    x,
-    y,
-    scale
-  } = context;
-  const refBounding = reference.getBoundingClientRect();
-  const parent = findRelativeParent(reference, container);
-  const parentBounding = parent.getBoundingClientRect();
-  const zeroTop = refBounding.top - parentBounding.top + parent.scrollTop;
-  const zeroLeft = refBounding.left - parentBounding.left + parent.scrollLeft;
-  return {
-    top: zeroTop + y * scale,
-    left: zeroLeft + x * scale
-  };
-}
-export function getPosition(context) {
-  const {
-    reference,
-    object,
-    scale
-  } = context;
-  const objectBounding = object.getBoundingClientRect();
-  const refBounding = reference.getBoundingClientRect();
-  const maxX = Math.floor((refBounding.width - objectBounding.width) / scale);
-  const maxY = Math.floor((refBounding.height - objectBounding.height) / scale);
-  const x = (objectBounding.left - refBounding.left) / scale;
-  const y = (objectBounding.top - refBounding.top) / scale;
-  const page = Number.parseInt(reference.dataset.pageNumber);
-  return {
-    x: clamp(x, 1, maxX - 1),
-    y: clamp(y, 1, maxY - 1),
-    page
-  };
-}

package/dist/components/pdf-object/utils/position.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/components/pdf-object/utils/position.spec.mjs

@@ -1,112 +0,0 @@
-import { queryByTestId } from "@testing-library/dom";
-import { vi } from "vitest";
-import {
-  findRelativeParent,
-  computePosition,
-  getPosition
-} from "./position.mjs";
-beforeEach(() => {
-  document.body.innerHTML = `
-    <div data-testid="container" style="position:relative;">
-      <div data-testid="viewer" style="position:absolute;top:0;left:0;width:500px;height:500px;overflow-y:auto;">
-        <div data-testid="page-1" data-page-number="1" style="width:300px;height:400px;"></div>
-        <div data-testid="page-2" data-page-number="2" style="width:300px;height:400px;"></div>
-      </div>
-      <div data-testid="object"></div>
-    </div>
-  `;
-});
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-describe("findRelativeParent", () => {
-  it("should return nearest relative parent", () => {
-    const container = queryByTestId(document.body, "container");
-    const viewer = queryByTestId(document.body, "viewer");
-    const reference = queryByTestId(document.body, "page-2");
-    const parent = findRelativeParent(reference, container);
-    expect(parent).toBe(viewer);
-  });
-  it("should return the container if cannot be found", () => {
-    const div = document.createElement("div");
-    document.body.append(div);
-    const reference = div;
-    const parent = findRelativeParent(reference, document.body);
-    expect(parent).toBe(document.body);
-  });
-});
-describe("computePosition", () => {
-  it("should render x, y position to top, left position", () => {
-    const container = queryByTestId(document.body, "container");
-    const viewer = queryByTestId(document.body, "viewer");
-    const reference = queryByTestId(document.body, "page-2");
-    vi.spyOn(viewer, "getBoundingClientRect").mockReturnValue({
-      top: 400,
-      y: 400,
-      x: 0,
-      left: 0,
-      width: 500,
-      height: 500,
-      bottom: 0,
-      right: 0,
-      toJSON: vi.fn()
-    });
-    vi.spyOn(reference, "getBoundingClientRect").mockReturnValue({
-      top: 800,
-      y: 800,
-      x: 100,
-      left: 100,
-      width: 791,
-      height: 1122,
-      bottom: 0,
-      right: 0,
-      toJSON: vi.fn()
-    });
-    const { top, left } = computePosition({
-      container,
-      reference,
-      x: 50,
-      y: 50,
-      scale: 1
-    });
-    expect(top).toBe(450);
-    expect(left).toBe(150);
-  });
-});
-describe("getPosition", () => {
-  it("should able to return x, y position of current object", () => {
-    const object = queryByTestId(document.body, "object");
-    const reference = queryByTestId(document.body, "page-2");
-    vi.spyOn(object, "getBoundingClientRect").mockReturnValue({
-      top: 500,
-      y: 500,
-      x: 150,
-      left: 150,
-      width: 500,
-      height: 500,
-      bottom: 0,
-      right: 0,
-      toJSON: vi.fn()
-    });
-    vi.spyOn(reference, "getBoundingClientRect").mockReturnValue({
-      top: 400,
-      y: 400,
-      x: 100,
-      left: 100,
-      width: 791,
-      height: 1122,
-      bottom: 0,
-      right: 0,
-      toJSON: vi.fn()
-    });
-    const { x, y, page } = getPosition({
-      reference,
-      object,
-      scale: 1,
-      container: void 0
-    });
-    expect(page).toBe(2);
-    expect(x).toBe(50);
-    expect(y).toBe(100);
-  });
-});

package/dist/components/pdf-object/utils/use-drag.d.ts

@@ -1,9 +0,0 @@
-import type { InteractEvent } from '@interactjs/types';
-import type { Ref } from 'vue-demi';
-export interface DragHooks {
-    onstart?: (event: InteractEvent) => void;
-    onmove?: (event: InteractEvent) => void;
-    onend?: (event: InteractEvent) => void;
-    ontap?: (event: InteractEvent) => void;
-}
-export default function useDrag(target: Ref<HTMLElement>, hooks?: DragHooks): import("vue-demi").ShallowRef<boolean, boolean>;