@naniteninja/profile-comparison-lib 0.0.1

package/index.d.ts

@@ -0,0 +1,637 @@
+import * as i0 from '@angular/core';
+import { OnInit, AfterViewInit, OnChanges, EventEmitter, ElementRef, Renderer2, SimpleChanges } from '@angular/core';
+import * as i3 from '@angular/common/http';
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i4 from '@angular/forms';
+import { FormGroup, FormControl } from '@angular/forms';
+import * as i2 from '@angular/common';
+import * as i7 from '@angular/router';
+import { Router } from '@angular/router';
+
+interface IProfileConfig {
+    person1Interests: string[];
+    person2Interests: string[];
+    person3Interests: string[];
+    user1Image: string;
+    user2Image: string;
+}
+
+interface IBoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+interface IPoint {
+    x: number;
+    y: number;
+}
+
+interface IFaceLandmarks {
+    [name: string]: IPoint | undefined;
+}
+interface IFaceBoxWithLandmarks extends IBoundingBox {
+    landmarks?: IFaceLandmarks;
+}
+interface IFaceDetectionResult {
+    imageUrl: string;
+    faces: IFaceBoxWithLandmarks[];
+}
+
+interface IWordAlignment {
+    word: string;
+    alignedWith: string | null;
+    score: number;
+    index: number;
+}
+
+interface IWordPair {
+    wordA: string;
+    wordB: string;
+    score: number;
+}
+
+interface ISimilarityThreshold {
+    threshold: number;
+}
+
+interface IAlignmentRow {
+    left: string;
+    right: string;
+    score: number;
+}
+
+interface FileInputEvent {
+    target: HTMLInputElement & EventTarget;
+}
+
+interface FaceDetectionResponse {
+    faces?: IFaceBoxWithLandmarks[];
+    data?: {
+        faces?: IFaceBoxWithLandmarks[];
+    };
+}
+interface FaceDetectionData {
+}
+
+interface IImageCompressionConfig$1 {
+    maxWidth: number;
+    maxHeight: number;
+    format: 'image/jpeg' | 'image/png' | 'image/webp';
+    qualityStart: number;
+    qualityMin: number;
+    qualityStep: number;
+    maxBytes: number;
+    downscaleStep: number;
+    minWidth: number;
+    minHeight: number;
+}
+
+interface IComparisonResult {
+    similarity: number;
+    differences: string[];
+    timestamp: Date;
+}
+
+interface ISimilarityResponse {
+    similarity: number;
+    [key: string]: unknown;
+}
+
+interface IFacePlusPlusFace {
+    face_rectangle?: IFaceRectangle;
+    faceRect?: IFaceRectangle;
+    rect?: IFaceRectangle;
+    landmark?: Record<string, {
+        x: number;
+        y: number;
+    }>;
+    [key: string]: unknown;
+}
+interface IFaceRectangle {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+
+interface IFacePlusPlusResponse {
+    faces?: IFacePlusPlusFace[];
+    error_message?: string;
+    [key: string]: unknown;
+}
+
+interface IOpenAIResponse {
+    choices: Array<{
+        message: {
+            content: string;
+        };
+    }>;
+    data?: Array<{
+        embedding: number[];
+        [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+
+interface IOpenAIEmbeddingItem {
+    embedding: number[];
+    [key: string]: unknown;
+}
+
+interface IEnvironment {
+    production: boolean;
+    apiNinjasKey: string;
+    openaiApiKey: string;
+    apiFaceplusKey?: string;
+    apiFaceplusSecret?: string;
+    [key: string]: unknown;
+}
+
+interface IMatrixLegendItem {
+    abbr: string;
+    full: string;
+}
+interface IMatrixRow {
+    label: string;
+    values: string[];
+}
+interface IMatrixData {
+    legend: IMatrixLegendItem[];
+    headers: string[];
+    rows: IMatrixRow[];
+}
+
+declare class EmbeddingService {
+    private model$;
+    getEmbedding(text: string): Observable<Float32Array>;
+    /**
+     * Group-align two lists based on semantic similarity, allowing one-to-many relationships.
+     *
+     * Design goals:
+     * - Semantic relevance takes priority over original order or spacing.
+     * - Each term in listB is assigned to the single most similar anchor in listA (if above threshold).
+     * - For an anchor in listA with multiple highly related listB terms, they are emitted as consecutive rows:
+     *   [A, B1], ['-', B2], ['-', B3], ... so they render adjacently and remain visually connected.
+     * - Low-similarity/unassigned terms from either side are appended at the end and never break groups.
+     */
+    groupAlignLists(listA: string[], listB: string[], threshold?: number, preserveLeftOrder?: boolean, exclusivityMargin?: number, leftCohesion?: number): Observable<IAlignmentRow[]>;
+    cosineSimilarity(a: Float32Array, b: Float32Array): number;
+    /**
+     * Align words in listA with their most semantically similar words in listB
+     *
+     * Algorithm:
+     * 1. Generate embeddings for all words in both lists using Universal Sentence Encoder
+     * 2. For each word in listA, compare its embedding with all words in listB
+     * 3. Find the word in listB with highest cosine similarity score
+     * 4. Return alignment results with similarity scores
+     *
+     * @param listA - Source list of words to align
+     * @param listB - Target list of words to find matches in
+     * @returns Observable of alignment results with word, alignedWith, score, and index
+     */
+    alignLists(listA: string[], listB: string[]): Observable<IWordAlignment[]>;
+    /**
+     * Find best matching pairs between two lists above a similarity threshold
+     *
+     * @param listA - Source list of words
+     * @param listB - Target list of words to match against
+     * @param threshold - Minimum similarity score (0-1, default: 0.15)
+     * @returns Observable of word pairs with similarity scores
+     */
+    findBestMatchingPairs(listA: string[], listB: string[], threshold?: number): Observable<IWordPair[]>;
+    calculateSimilarity(primaryText: string, comparisonText: string): Observable<number>;
+    testWordSimilarity(word1: string, word2: string): Observable<void>;
+    private domainCompatibilityCap;
+    private computeLexicalBoost;
+    private loadModel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmbeddingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EmbeddingService>;
+}
+
+declare class FileConversionService {
+    private static readonly MIME_TYPE_JPEG;
+    private static readonly MIME_TYPE_PNG;
+    private static readonly MIME_TYPE_WEBP;
+    private static readonly FILE_EXTENSION_JPG;
+    private static readonly FILE_EXTENSION_JPEG;
+    private static readonly FILE_EXTENSION_PNG;
+    private static readonly FILE_EXTENSION_WEBP;
+    urlToFile(url: string, fileName: string, mimeType: string): Observable<File>;
+    isDataUrl(str: string): boolean;
+    dataUrlToFile(dataUrl: string, fileName: string): File;
+    getMimeFromFilename(fileName: string): string;
+    getFileForImageString(imageStr: string, fileBaseName: string): Observable<File>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileConversionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FileConversionService>;
+}
+
+declare class ImageCompressionService {
+    compressImageFile(file: File, config: IImageCompressionConfig$1, overrides?: Partial<IImageCompressionConfig$1>): Observable<{
+        file: File;
+        dataUrl: string;
+    }>;
+    loadImageFromFile(file: File): Observable<HTMLImageElement>;
+    canvasToBlob(canvas: HTMLCanvasElement, type: string, quality: number): Observable<Blob>;
+    blobToDataURL(blob: Blob): Observable<string>;
+    renameFileForFormat(name: string, mime: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageCompressionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImageCompressionService>;
+}
+
+/**
+ * OpenAI Alignment Service
+ * Uses OpenAI Chat Completions API to align two lists of text in a single request.
+ * This replaces the previous embedding-based approach to avoid rate limits and reduce complexity.
+ */
+declare class OpenAIEmbeddingService {
+    private http;
+    private static readonly API_URL;
+    private static readonly MODEL;
+    private static readonly HEADER_CONTENT_TYPE;
+    private static readonly HEADER_AUTHORIZATION;
+    private static readonly CONTENT_TYPE_JSON;
+    private static readonly BEARER_PREFIX;
+    private static readonly SPACER_SMALL;
+    private static readonly SPACER_LARGE;
+    private readonly API_URL;
+    private readonly MODEL;
+    private alignmentCache;
+    private spacerAlignmentCache;
+    constructor(http: HttpClient);
+    /**
+     * Get aligned lists with spacers.
+     * Now uses a direct LLM call with a specific prompt to generate the aligned lists.
+     */
+    getAlignedLists(listA: string[], listB: string[], apiKey: string): Observable<{
+        listA: string[];
+        listB: string[];
+    }>;
+    private sanitizeResponse;
+    /**
+     * Get alignment between two lists using a single OpenAI Chat Completion request.
+     * Uses canonical caching to ensure A->B and B->A use the same API response.
+     */
+    groupAlignLists(listA: string[], listB: string[], threshold: number | undefined, preserveLeftOrder: boolean | undefined, exclusivityMargin: number | undefined, leftCohesion: number | undefined, apiKey: string): Observable<IAlignmentRow[]>;
+    /**
+     * Calculate semantic similarity between two texts using OpenAI Embeddings API.
+     * Returns a cosine similarity score in [0, 1] (0 for empty/invalid inputs).
+     */
+    calculateSimilarity(textA: string, textB: string, apiKey: string): Observable<number>;
+    /**
+     * Fetch embeddings for multiple texts in a single request.
+     */
+    getEmbeddings(texts: string[], apiKey: string): Observable<number[][]>;
+    private cosineSimilarityVectors;
+    clearCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenAIEmbeddingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OpenAIEmbeddingService>;
+}
+
+declare class ProfileComparisonLibService {
+    constructor();
+    /**
+     * Main service for profile comparison functionality
+     */
+    compareProfiles(profile1: IProfileConfig, profile2: IProfileConfig): IComparisonResult;
+    /**
+     * Get library version
+     */
+    getVersion(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileComparisonLibService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProfileComparisonLibService>;
+}
+
+declare class ProfileService {
+    private http;
+    private static readonly BASE_URL;
+    private static readonly FACE_PLUS_PLUS_URL;
+    private baseUrl;
+    private baseUrlf;
+    constructor(http: HttpClient);
+    compareInterests(text_1: string, text_2: string, apiKey: string): Observable<ISimilarityResponse>;
+    detectFace(image: File | string, creds?: {
+        apiKey?: string;
+        apiSecret?: string;
+    }): Observable<IFaceDetectionResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProfileService>;
+}
+
+declare class ProfileComparisonLibComponent implements OnInit, AfterViewInit, OnChanges {
+    private profileService;
+    private openaiEmbeddingService;
+    private renderer;
+    private fileConversionService;
+    private imageCompressionService;
+    private static readonly DEFAULT_OBJECT_POSITION;
+    private static readonly DEFAULT_EYE_ALIGNMENT_BIAS_PX;
+    private static readonly DEFAULT_IMAGE_FORMAT;
+    private static readonly DEFAULT_IMAGE_QUALITY_START;
+    private static readonly DEFAULT_IMAGE_QUALITY_MIN;
+    private static readonly DEFAULT_IMAGE_QUALITY_STEP;
+    private static readonly DEFAULT_MAX_BYTES;
+    private static readonly DEFAULT_DOWNSCALE_STEP;
+    private static readonly DEFAULT_MIN_WIDTH;
+    private static readonly DEFAULT_MIN_HEIGHT;
+    private static readonly DEFAULT_MAX_WIDTH;
+    private static readonly DEFAULT_MAX_HEIGHT;
+    private static readonly SPACER_SMALL;
+    private static readonly SPACER_LARGE;
+    private static readonly CONSOLIDATION_SEPARATOR_X;
+    private static readonly CONSOLIDATION_SEPARATOR_SLASH;
+    private static readonly FACEPP_RATE_LIMIT_DELAY_MS;
+    private static readonly DEFAULT_PROFILE_IMAGE_NAME;
+    config: IProfileConfig;
+    apiNinjasKey: string;
+    faceplusKey: string;
+    faceplusSecret: string;
+    openaiApiKey: string;
+    fadeAllEdges: boolean;
+    matrixDataChange: EventEmitter<IMatrixData>;
+    selectedFile: File | null;
+    result: unknown;
+    firstImageData: FaceDetectionData | null;
+    secondImageData: FaceDetectionData | null;
+    user1Transform: string;
+    user2Transform: string;
+    alignmentCalculated: boolean;
+    isAligning: boolean;
+    user1ObjectPosition: string;
+    user2ObjectPosition: string;
+    private user1NaturalWidth;
+    private user1NaturalHeight;
+    private user2NaturalWidth;
+    private user2NaturalHeight;
+    private user1FaceRaw;
+    private user2FaceRaw;
+    private eyeAlignmentBiasPx;
+    firstPersonInterests: string[];
+    secondPersonInterests: string[];
+    thirdPersonInterests: string[];
+    centerItem: string[];
+    person1Interests: string[];
+    person2Interests: string[];
+    person3Interests: string[];
+    user1Image: string;
+    user2Image: string;
+    private baseConfig;
+    displayPerson1Interests: string[];
+    displayPerson2Interests: string[];
+    alignedPerson1Interests: string[];
+    alignedPerson2Interests: string[];
+    leftProfileClicked: boolean;
+    rightProfileClicked: boolean;
+    sortedA: {
+        item: string;
+        score: number;
+    }[];
+    sortedB: {
+        item: string;
+        score: number;
+    }[];
+    sortedC: {
+        item: string;
+        score: number;
+    }[];
+    similarity: number;
+    similarityMatrixCsv: string;
+    matrixData: IMatrixData | null;
+    customApiKey: string;
+    showApiKeyModal: boolean;
+    apiKeyInputValue: string;
+    quotaExhausted: boolean;
+    customFaceppKey: string;
+    customFaceppSecret: string;
+    showFaceppKeyModal: boolean;
+    faceppKeyInputValue: string;
+    faceppSecretInputValue: string;
+    faceppQuotaExhausted: boolean;
+    customOpenAIKey: string;
+    showOpenAIKeyModal: boolean;
+    openaiKeyInputValue: string;
+    openaiQuotaExhausted: boolean;
+    compressionConfig: IImageCompressionConfig$1;
+    private computeSub?;
+    private detectFaceSub1?;
+    private detectFaceSub2?;
+    private activeRequestEpoch;
+    form: FormGroup<{
+        interest1: FormControl<string | null>;
+        interest2: FormControl<string | null>;
+    }>;
+    leftContainer: ElementRef;
+    rightContainer: ElementRef;
+    constructor(profileService: ProfileService, openaiEmbeddingService: OpenAIEmbeddingService, renderer: Renderer2, fileConversionService: FileConversionService, imageCompressionService: ImageCompressionService);
+    anchorSide: 'left' | 'right';
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateConfigProperties;
+    private buildConfigWithDefaults;
+    onUserImageLoad(which: 1 | 2, event: Event): void;
+    private updateObjectPositionForFace;
+    private getProfileContainerSize;
+    private getOverlapSizeCssPx;
+    private setOverlapSizeCssPx;
+    waitForImagesAndInitDrag(): void;
+    initDrag(): void;
+    compute(): void;
+    createSemanticAlignment(person1Results: {
+        item: string;
+        score: number;
+    }[], person2Results: {
+        item: string;
+        score: number;
+    }[]): Promise<void>;
+    createEmbeddingBasedAlignment(person1Results: {
+        item: string;
+        score: number;
+    }[], person2Results: {
+        item: string;
+        score: number;
+    }[]): Promise<void>;
+    sortByMaxSimilarity(personList: string[], otherLists: string[][]): Observable<{
+        item: string;
+        score: number;
+    }[]>;
+    onViewProfile(): void;
+    getActiveApiKey(): string;
+    updateApiKey(): void;
+    closeApiKeyModal(): void;
+    handleApiQuotaError(error: HttpErrorResponse | {
+        status?: number;
+        error?: {
+            message?: string;
+        };
+    }): void;
+    private saveApiKeyToStorage;
+    private loadApiKeyFromStorage;
+    onFileInputChange(event: FileInputEvent): void;
+    private compressConfigImagesIfNeeded;
+    private compressImageStringToDataUrl;
+    private loadCustomConfig;
+    getEyeCoordinatesFromBBox(bbox: IBoundingBox): {
+        leftEye: IPoint;
+        rightEye: IPoint;
+    };
+    getEyeCoordinatesFromFace(face: IFaceBoxWithLandmarks): {
+        leftEye: IPoint;
+        rightEye: IPoint;
+    };
+    getNoseCoordinateFromFace(face: IFaceBoxWithLandmarks): IPoint;
+    private clampPointToFaceRect;
+    getNoseCoordinateFromBBox(bbox: IBoundingBox): IPoint;
+    getFaceCoordinatesFromBBox(bbox: IBoundingBox): {
+        faceCenter: IPoint;
+        faceTop: IPoint;
+        faceBottom: IPoint;
+        faceLeft: IPoint;
+        faceRight: IPoint;
+    };
+    initializeFaceDetection(): void;
+    calculateFaceAlignment(user1Data: FaceDetectionData, user2Data: FaceDetectionData): void;
+    applyDefaultAlignment(): void;
+    isValidFaceData(face: IBoundingBox): boolean;
+    getActiveFaceppKey(): string;
+    getActiveFaceppSecret(): string;
+    updateFaceppCredentials(): void;
+    closeFaceppKeyModal(): void;
+    handleFaceppError(error: HttpErrorResponse | {
+        status?: number;
+        error?: {
+            message?: string;
+        };
+    }): void;
+    private saveFaceppCredsToStorage;
+    private loadFaceppCredsFromStorage;
+    private getActiveOpenAIKey;
+    updateOpenAIKey(): void;
+    closeOpenAIKeyModal(): void;
+    private saveOpenAIKeyToStorage;
+    private loadOpenAIKeyFromStorage;
+    private generateSimilarityMatrix;
+    private cosineSimilarity;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileComparisonLibComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProfileComparisonLibComponent, "lib-profile-comparison", never, { "config": { "alias": "config"; "required": false; }; "apiNinjasKey": { "alias": "apiNinjasKey"; "required": false; }; "faceplusKey": { "alias": "faceplusKey"; "required": false; }; "faceplusSecret": { "alias": "faceplusSecret"; "required": false; }; "openaiApiKey": { "alias": "openaiApiKey"; "required": false; }; "fadeAllEdges": { "alias": "fadeAllEdges"; "required": false; }; }, { "matrixDataChange": "matrixDataChange"; }, never, never, false, never>;
+}
+
+interface IImageCompressionConfig {
+    maxWidth: number;
+    maxHeight: number;
+    format: 'image/jpeg' | 'image/png' | 'image/webp';
+    qualityStart: number;
+    qualityMin: number;
+    qualityStep: number;
+    maxBytes: number;
+    downscaleStep: number;
+    minWidth: number;
+    minHeight: number;
+}
+declare class CustomInputComponent {
+    private router;
+    person1Text: string;
+    person2Text: string;
+    person3Text: string;
+    user1File: File | null;
+    user2File: File | null;
+    user1Preview: string | null;
+    user2Preview: string | null;
+    saving: boolean;
+    error: string | null;
+    private static readonly MAX_WIDTH;
+    private static readonly MAX_HEIGHT;
+    private static readonly COMPRESSION_FORMAT;
+    private static readonly QUALITY_START;
+    private static readonly QUALITY_MIN;
+    private static readonly QUALITY_STEP;
+    private static readonly MAX_BYTES;
+    private static readonly DOWNSCALE_STEP;
+    private static readonly MIN_WIDTH;
+    private static readonly MIN_HEIGHT;
+    compressionConfig: IImageCompressionConfig;
+    constructor(router: Router);
+    onUser1FileChange(event: Event): Promise<void>;
+    onUser2FileChange(event: Event): Promise<void>;
+    saveAndView(): Promise<void>;
+    clearAll(): void;
+    close(): void;
+    private toList;
+    private fileToDataURL;
+    private previewFile;
+    private compressImageFile;
+    private loadImageFromFile;
+    private canvasToBlob;
+    private blobToDataURL;
+    private renameFileForFormat;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CustomInputComponent, "lib-custom-input", never, {}, {}, never, never, true, never>;
+}
+
+declare class DocumentationComponent implements OnInit {
+    private openaiEmbeddingService;
+    private profileService;
+    private router;
+    apiKeyInput: string;
+    textA: string;
+    textB: string;
+    embeddingScore: number | null;
+    embeddingLoading: boolean;
+    embeddingError: string | null;
+    listAInput: string;
+    listBInput: string;
+    matchingPairs: Array<{
+        wordA: string;
+        wordB: string;
+        score: number;
+    }>;
+    pairsLoading: boolean;
+    pairsError: string | null;
+    faceFile: File | null;
+    faceResult: unknown;
+    faceLoading: boolean;
+    faceError: string | null;
+    compareA: string;
+    compareB: string;
+    apiSimilarity: number | null;
+    apiLoading: boolean;
+    apiError: string | null;
+    openaiKeyInput: string;
+    defaultApiNinjasKey: string;
+    defaultOpenaiApiKey: string;
+    constructor(openaiEmbeddingService: OpenAIEmbeddingService, profileService: ProfileService, router: Router);
+    ngOnInit(): void;
+    getActiveApiKey(): string;
+    saveKey(): void;
+    getStoredKey(): string | null;
+    getActiveOpenAIKey(): string;
+    saveOpenAIKey(): void;
+    runEmbeddingSimilarity(): void;
+    runBestPairs(): void;
+    onFaceFileChange(event: Event): void;
+    runFaceDetect(): void;
+    runApiSimilarity(): void;
+    similarityLabel(): string;
+    apiSimilarityLabel(): string;
+    pairLabel(p: {
+        wordA: string;
+        wordB: string;
+        score: number;
+    }): string;
+    faceResultJson(): string;
+    private formatNumber;
+    goHome(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DocumentationComponent, "lib-documentation", never, { "defaultApiNinjasKey": { "alias": "defaultApiNinjasKey"; "required": false; }; "defaultOpenaiApiKey": { "alias": "defaultOpenaiApiKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ProfileComparisonLibModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileComparisonLibModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProfileComparisonLibModule, [typeof ProfileComparisonLibComponent], [typeof i2.CommonModule, typeof i3.HttpClientModule, typeof i4.FormsModule, typeof i4.ReactiveFormsModule, typeof CustomInputComponent, typeof DocumentationComponent, typeof i7.RouterModule], [typeof ProfileComparisonLibComponent, typeof CustomInputComponent, typeof DocumentationComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProfileComparisonLibModule>;
+}
+
+export { CustomInputComponent, DocumentationComponent, EmbeddingService, FileConversionService, ImageCompressionService, OpenAIEmbeddingService, ProfileComparisonLibComponent, ProfileComparisonLibModule, ProfileComparisonLibService, ProfileService };
+export type { FaceDetectionData, FaceDetectionResponse, FileInputEvent, IAlignmentRow, IBoundingBox, IComparisonResult, IEnvironment, IFaceBoxWithLandmarks, IFaceDetectionResult, IFaceLandmarks, IFacePlusPlusFace, IFacePlusPlusResponse, IFaceRectangle, IImageCompressionConfig$1 as IImageCompressionConfig, IMatrixData, IMatrixLegendItem, IMatrixRow, IOpenAIEmbeddingItem, IOpenAIResponse, IPoint, IProfileConfig, ISimilarityResponse, ISimilarityThreshold, IWordAlignment, IWordPair };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@naniteninja/profile-comparison-lib",
+  "version": "0.0.1",
+  "description": "Angular library for profile comparison functionality",
+  "keywords": [
+    "angular",
+    "profile",
+    "comparison",
+    "library"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "peerDependencies": {
+    "@angular/common": "^14.2.0",
+    "@angular/core": "^14.2.0",
+    "axios": "1.13.2",
+    "socket.io": "4.8.1",
+    "socket.io-client": "4.8.1"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "module": "fesm2022/naniteninja-profile-comparison-lib.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/naniteninja-profile-comparison-lib.mjs"
+    }
+  },
+  "sideEffects": false
+}