skyflow-js 2.5.0-beta.4 → 2.5.0-beta.6

package/package.json

@@ -2,7 +2,7 @@
   "name": "skyflow-js",
   "preferGlobal": true,
   "analyze": false,
-  "version": "2.5.0-beta.4",
+  "version": "2.5.0-beta.6",
   "author": "Skyflow",
   "description": "Skyflow JavaScript SDK",
   "homepage": "https://github.com/skyflowapi/skyflow-js",

package/types/core/constants.d.ts

@@ -9,10 +9,12 @@ export declare const SDK_IFRAME_EVENT = "SDK IFRAME EVENT";
 export declare const DOMAIN = "US2";
 export declare const CORALOGIX_DOMAIN = "https://cdn.rum-ingress-coralogix.com/coralogix/browser/latest/coralogix-browser-sdk.js";
 export declare const FRAME_ELEMENT = "element";
+export declare const COMPOSABLE_REVEAL = "reveal-composable";
 export declare const ELEMENT_TYPES: {
     COLLECT: string;
     REVEAL: string;
     COMPOSE: string;
+    REVEAL_COMPOSE: string;
 };
 export declare const EVENT_TYPES: {
     MOUNTED: string;
@@ -30,6 +32,7 @@ export declare const METRIC_TYPES: {
         COLLECT: string;
         REVEAL: string;
         COMPOSE: string;
+        REVEAL_COMPOSE: string;
     };
     ELEMENT_TYPE_KEY: string;
     DIV_ID: string;
@@ -86,10 +89,17 @@ export declare const ELEMENT_EVENTS_TO_CLIENT: {
     HEIGHT: string;
 };
 export declare const ELEMENT_EVENTS_TO_IFRAME: {
-    COLLECT_INVOKE_REQUEST: string;
-    COLLECT_DATA_REQUEST: string;
+    RENDER_MOUNTED: string;
+    HEIGHT_CALLBACK: string;
+    HEIGHT_CALLBACK_COMPOSABLE: string;
+    COMPOSABLE_REVEAL: string;
     COLLECT_CALL_REQUESTS: string;
+    COMPOSABLE_CALL_REQUESTS: string;
+    COMPOSABLE_CALL_RESPONSE: string;
+    COMPOSABLE_FILE_CALL_RESPONSE: string;
+    COMPOSABLE_CONTAINER: string;
     REVEAL_CALL_REQUESTS: string;
+    REVEAL_CALL_RESPONSE: string;
     FRAME_READY: string;
     READY_FOR_CLIENT: string;
     TOKENIZATION_REQUEST: string;

package/types/core/external/collect/collect-container.d.ts

@@ -8,6 +8,5 @@ declare class CollectContainer extends Container {
     create: (input: CollectElementInput, options?: CollectElementOptions) => CollectElement;
     collect: (options?: ICollectOptions) => Promise<CollectResponse>;
     uploadFiles: (options: ICollectOptions) => Promise<UploadFilesResponse>;
-    checkIfFrameExistsInShadowRoot: (shadowRoot: ShadowRoot | null, frameName: string) => boolean;
 }
 export default CollectContainer;

package/types/core/external/collect/collect-element.d.ts

@@ -10,8 +10,6 @@ declare class CollectElement extends SkyflowElement {
     constructor(elementId: string, elementGroup: any, metaData: any, container: any, isSingleElementAPI: boolean | undefined, destroyCallback: Function, updateCallback: Function, context: Context, groupEventEmitter?: EventEmitter);
     getID: () => string;
     mount: (domElement: HTMLElement | string) => void;
-    getShadowRoot: () => ShadowRoot | null;
-    emitEventFromShadowRoot: (eventName: string, options?: Record<string, any>, callback?: any) => void;
     unmount: () => void;
     updateElementGroup: (group: any) => void;
     updateElement: (elementOptions: any) => void;

package/types/core/external/collect/compose-collect-container.d.ts

@@ -1,4 +1,4 @@
-import { CollectElementInput, CollectElementOptions, ICollectOptions, CollectResponse } from '../../../utils/common';
+import { CollectElementInput, CollectElementOptions, ICollectOptions, CollectResponse, UploadFilesResponse } from '../../../utils/common';
 import Container from '../common/container';
 import ComposableElement from './compose-collect-element';
 declare class ComposableContainer extends Container {
@@ -10,5 +10,6 @@ declare class ComposableContainer extends Container {
     mount: (domElement: HTMLElement | string) => void;
     unmount: () => void;
     collect: (options?: ICollectOptions) => Promise<CollectResponse>;
+    uploadFiles: (options: ICollectOptions) => Promise<UploadFilesResponse>;
 }
 export default ComposableContainer;

package/types/core/external/reveal/composable-reveal-container.d.ts

@@ -0,0 +1,14 @@
+import Container from '../common/container';
+import ComposableRevealElement from './composable-reveal-element';
+import { RevealElementInput, RevealResponse } from '../../../index-node';
+import { IRevealElementOptions } from './reveal-container';
+declare class ComposableRevealContainer extends Container {
+    #private;
+    type: string;
+    constructor(options: any, metaData: any, skyflowElements: any, context: any);
+    create: (input: RevealElementInput, options?: IRevealElementOptions) => ComposableRevealElement;
+    mount: (domElement: HTMLElement | string) => void;
+    unmount: () => void;
+    reveal(): Promise<RevealResponse>;
+}
+export default ComposableRevealContainer;

package/types/core/external/reveal/composable-reveal-element.d.ts

@@ -0,0 +1,10 @@
+import { RenderFileResponse } from '../../../utils/common';
+declare class ComposableRevealElement {
+    #private;
+    type: string;
+    constructor(name: any, eventEmitter: any, iframeName: any);
+    iframeName(): string;
+    getID(): string;
+    renderFile(): Promise<RenderFileResponse>;
+}
+export default ComposableRevealElement;

package/types/core/external/reveal/composable-reveal-internal.d.ts

@@ -0,0 +1,29 @@
+import { Context, RenderFileResponse } from '../../../utils/common';
+import SkyflowElement from '../common/skyflow-element';
+import { IRevealElementInput, IRevealElementOptions } from './reveal-container';
+export interface RevealComposableGroup {
+    record: IRevealElementInput;
+    options: IRevealElementOptions;
+}
+declare class ComposableRevealInternalElement extends SkyflowElement {
+    #private;
+    constructor(elementId: string, recordGroup: RevealComposableGroup[], metaData: any, container: any, isSingleElementAPI: boolean | undefined, context: Context);
+    private setupRenderFileEventListener;
+    getID(): string;
+    mount(domElementSelector: HTMLElement | string): void;
+    renderFile(recordData: any): Promise<RenderFileResponse>;
+    iframeName(): string;
+    isMounted(): boolean;
+    hasToken(): boolean;
+    isClientSetError(): boolean;
+    getRecordData(): any;
+    setErrorOverride(clientErrorText: string): void;
+    setError(clientErrorText: string): void;
+    resetError(): void;
+    setAltText(altText: string): void;
+    clearAltText(): void;
+    setToken(token: string): void;
+    unmount(): void;
+    update(options: IRevealElementInput): void;
+}
+export default ComposableRevealInternalElement;

package/types/core/external/reveal/reveal-element.d.ts

@@ -5,8 +5,6 @@ declare class RevealElement extends SkyflowElement {
     #private;
     constructor(record: IRevealElementInput, options: IRevealElementOptions | undefined, metaData: any, container: any, elementId: string, context: Context);
     getID(): string;
-    getShadowRoot: () => ShadowRoot | null;
-    emitEventFromShadowRoot: (eventName: string, options?: Record<string, any>) => void;
     mount(domElementSelector: HTMLElement | string): void;
     renderFile(): Promise<RenderFileResponse>;
     iframeName(): string;

package/types/core/internal/composable-frame-element-init.d.ts

@@ -0,0 +1,21 @@
+import { IRevealRecordComposable } from '../../utils/common';
+import IFrameFormElement from './iframe-form';
+import FrameElement from '.';
+export default class RevealComposableFrameElementInit {
+    #private;
+    iframeFormElement: IFrameFormElement | undefined;
+    clientMetaData: any;
+    frameElement: FrameElement;
+    private static frameEle?;
+    containerId: string;
+    group: any;
+    frameList: FrameElement[];
+    iframeFormList: IFrameFormElement[];
+    revealFrameList: any[];
+    rootDiv: HTMLDivElement;
+    constructor();
+    updateGroupData: () => void;
+    static startFrameElement: () => void;
+    revealData(revealRecords: IRevealRecordComposable[], containerId: any, authToken: any): Promise<unknown>;
+    createContainerDiv: (newGroup: any) => void;
+}

package/types/core/internal/frame-element-init.d.ts

@@ -10,7 +10,13 @@ export default class FrameElementInit {
     private static frameEle?;
     containerId: string;
     group: any;
+    frameList: FrameElement[];
+    iframeFormList: IFrameFormElement[];
     constructor();
+    private handleCollectCall;
+    private parallelUploadFiles;
+    uploadFiles: (fileElement: any, clientConfig: any) => Promise<unknown>;
+    private tokenize;
     updateGroupData: () => void;
     createIframeElement: (frameName: any, label: any, skyflowID: any, isRequired: any) => IFrameFormElement;
     static startFrameElement: () => void;

package/types/core/internal/iframe-form/index.d.ts

@@ -35,34 +35,7 @@ export default class IFrameFormElement extends EventEmitter {
     preserveFileName: boolean;
     allowedFileType: any;
     blockEmptyFiles: boolean;
-    containerId: string;
-    clientId: string;
     constructor(name: string, label: string, metaData: any, context: Context, skyflowID?: string);
-    getProperties: () => {
-        state: {
-            value: any;
-            isFocused: boolean;
-            isValid: boolean;
-            isEmpty: boolean;
-            isComplete: boolean;
-            name: string;
-            isRequired: boolean;
-            isTouched: boolean;
-            selectedCardScheme: string;
-        };
-        value: any;
-        fieldType: string;
-        doesClientHasError: boolean;
-        clientErrorText: string | undefined;
-        errorText: string | undefined;
-        onFocusChange: (focus: boolean) => void;
-        setValue: (value?: any, valid?: boolean, isReset?: boolean) => void;
-        validations: IValidationRule[] | undefined;
-        isMatchEqual: (index: number, value: string, validation: IValidationRule) => boolean;
-        tableName: string | undefined;
-        skyflowID: string | undefined;
-        preserveFileName: boolean;
-    };
     isMatchEqual(index: number, value: string, validation: IValidationRule): boolean;
     checkMatch(index: number, validation: IValidationRule): void;
     listenForMatchRule(): void;

package/types/core/internal/index.d.ts

@@ -20,7 +20,8 @@ export default class FrameElement {
     private selectionStart?;
     private selectionEnd?;
     private selectedData?;
-    constructor(iFrameFormElement: IFrameFormElement, options: any, htmlDivElement: HTMLDivElement);
+    private clientDomain;
+    constructor(iFrameFormElement: IFrameFormElement, options: any, htmlDivElement: HTMLDivElement, clientDomain?: string);
     mount: () => void;
     setupInputField(newValue?: boolean): void;
     updateParentDiv: (newDiv: HTMLDivElement) => void;

package/types/core/internal/reveal/reveal-frame.d.ts

@@ -4,7 +4,12 @@ declare class RevealFrame {
     private domCopy?;
     private isRevealCalled?;
     static init(): void;
-    constructor(record: any, context: any, id: any);
+    constructor(record: any, context: any, id: any, rootDiv?: any);
+    responseUpdate: (data: any) => void;
+    getConfig: () => void;
+    getData: () => any;
+    private sub2;
+    private renderFile;
     private getExtension;
     private addFileRender;
     private setRevealError;

package/types/core/internal/skyflow-frame/skyflow-frame-controller.d.ts

@@ -5,8 +5,7 @@ declare class SkyflowFrameController {
     static init(clientId: any): SkyflowFrameController;
     revealData(revealRecords: IRevealRecord[], containerId: any): Promise<unknown>;
     insertData(records: any, options: any): Promise<unknown>;
-    renderFile(data: any, iframeName: any, shadowRoot?: boolean): Promise<unknown>;
-    getProperties(element: any, containerId: string): any;
+    renderFile(data: any, iframeName: any): Promise<unknown>;
     tokenize: (options: any) => Promise<unknown>;
     parallelUploadFiles: (options: any) => Promise<unknown>;
     uploadFiles: (fileElement: any) => Promise<unknown>;

package/types/core-utils/collect.d.ts

@@ -28,5 +28,7 @@ export declare const constructElementsInsertReq: (req: any, update: any, options
     records?: undefined;
 })[];
 export declare const updateRecordsBySkyflowID: (skyflowIdRecords: any, client: Client, options: any) => Promise<unknown>;
+export declare const updateRecordsBySkyflowIDComposable: (skyflowIdRecords: any, client: Client, options: any, authToken: string) => Promise<unknown>;
+export declare const insertDataInCollect: (records: any, client: Client, options: any, finalInsertRecords: any, authToken: string) => Promise<unknown>;
 export declare const checkForElementMatchRule: (validations: IValidationRule[]) => boolean;
 export declare const checkForValueMatch: (validations: IValidationRule[], element: IFrameFormElement) => boolean;

package/types/core-utils/reveal.d.ts

@@ -1,8 +1,10 @@
 import Client from '../client';
-import { IRevealRecord, IRevealResponseType, IGetRecord, ISkyflowIdRecord, IRenderResponseType, IGetOptions, RenderFileResponse } from '../utils/common';
+import { IRevealRecord, IRevealResponseType, IGetRecord, ISkyflowIdRecord, IRenderResponseType, IGetOptions, RenderFileResponse, IRevealRecordComposable } from '../utils/common';
 export declare const getFileURLForRender: (skyflowIdRecord: IRevealRecord, client: Client, authToken: string) => Promise<any>;
 export declare const getFileURLFromVaultBySkyflowID: (skyflowIdRecord: IRevealRecord, client: Client) => Promise<IRenderResponseType>;
+export declare const getFileURLFromVaultBySkyflowIDComposable: (skyflowIdRecord: IRevealRecord, client: Client, authToken: string) => Promise<IRenderResponseType>;
 export declare const fetchRecordsByTokenId: (tokenIdRecords: IRevealRecord[], client: Client) => Promise<IRevealResponseType>;
+export declare const fetchRecordsByTokenIdComposable: (tokenIdRecords: IRevealRecordComposable[], client: Client, authToken: string) => Promise<IRevealResponseType>;
 export declare const formatRecordsForIframe: (response: IRevealResponseType) => Record<string, string>;
 export declare const formatRecordsForRender: (response: IRenderResponseType, column: any, skyflowID: any) => {
     column: any;
@@ -26,5 +28,15 @@ export declare const formatRecordsForClient: (response: IRevealResponseType) =>
     errors: Record<string, any>[] | undefined;
     success?: undefined;
 };
+export declare const formatRecordsForClientComposable: (response: any) => {
+    success: never[];
+    errors: never[];
+} | {
+    success: never[];
+    errors?: undefined;
+} | {
+    errors: never[];
+    success?: undefined;
+};
 export declare const fetchRecordsGET: (skyflowIdRecords: IGetRecord[], client: Client, options?: IGetOptions) => Promise<unknown>;
 export declare const fetchRecordsBySkyflowID: (skyflowIdRecords: ISkyflowIdRecord[], client: Client) => Promise<unknown>;

package/types/skyflow.d.ts

@@ -5,10 +5,12 @@ import SkyflowError from './libs/skyflow-error';
 import { RequestMethod, IInsertRecordInput, IDetokenizeInput, IGetInput, RedactionType, EventName, Env, LogLevel, ValidationRuleType, IGetByIdInput, IInsertOptions, IDeleteRecordInput, IDeleteOptions, IGetOptions, InsertResponse, GetResponse, GetByIdResponse, DeleteResponse, ContainerOptions, DetokenizeResponse } from './utils/common';
 import ComposableContainer from './core/external/collect/compose-collect-container';
 import ThreeDS from './core/external/threeds/threeds';
+import ComposableRevealContainer from './core/external/reveal/composable-reveal-container';
 export declare enum ContainerType {
     COLLECT = "COLLECT",
     REVEAL = "REVEAL",
-    COMPOSABLE = "COMPOSABLE"
+    COMPOSABLE = "COMPOSABLE",
+    COMPOSE_REVEAL = "COMPOSABLE_REVEAL"
 }
 export interface ISkyflow {
     vaultID?: string;
@@ -23,6 +25,7 @@ declare class Skyflow {
     container(type: ContainerType.COLLECT, options?: ContainerOptions): CollectContainer;
     container(type: ContainerType.COMPOSABLE, options?: ContainerOptions): ComposableContainer;
     container(type: ContainerType.REVEAL, options?: ContainerOptions): RevealContainer;
+    container(type: ContainerType.COMPOSE_REVEAL, options?: ContainerOptions): ComposableRevealContainer;
     insert(records: IInsertRecordInput, options?: IInsertOptions): Promise<InsertResponse>;
     detokenize(detokenizeInput: IDetokenizeInput): Promise<DetokenizeResponse>;
     getById(getByIdInput: IGetByIdInput): Promise<GetByIdResponse>;

package/types/utils/common/index.d.ts

@@ -60,6 +60,14 @@ export interface IRevealRecord {
     skyflowID?: string;
     table?: string;
 }
+export interface IRevealRecordComposable {
+    token?: string;
+    redaction?: RedactionType;
+    column?: string;
+    skyflowID?: string;
+    table?: string;
+    iframeName?: string;
+}
 export interface IInsertResponse {
     records: IInsertResponseReocrds[];
 }

package/types/utils/constants.d.ts

@@ -1,4 +1,8 @@
 declare const SKYFLOW_ERROR_CODE: {
+    INVALID_REVEAL_COMPOSABLE_INPUT: {
+        code: number;
+        description: string;
+    };
     INVALID_FILE_NAME: {
         code: number;
         description: string;

package/types/utils/logs.d.ts

@@ -1,12 +1,10 @@
 declare const logs: {
     infoLogs: {
-        TOKENIZE_REQUEST: string;
-        TOKENIZE_REQUEST_INSERT: string;
-        TOKENIZE_REQUEST_CREATED: string;
         INITIALIZE_CLIENT: string;
         CLIENT_INITIALIZED: string;
         CREATE_COLLECT_CONTAINER: string;
         COLLECT_CONTAINER_CREATED: string;
+        INITIALIZE_COMPOSABLE_CLIENT: string;
         CREATE_REVEAL_CONTAINER: string;
         REVEAL_CONTAINER_CREATED: string;
         VALIDATE_RECORDS: string;
@@ -77,7 +75,7 @@ declare const logs: {
         VALIDATE_GET_BY_ID_INPUT: string;
     };
     errorLogs: {
-        FRAME_COLLECT_EMIT_TIMEOUT: string;
+        INVALID_REVEAL_COMPOSABLE_INPUT: string;
         NO_ELEMENTS_IN_COLLECT: string;
         NO_ELEMENTS_IN_COMPOSABLE: string;
         NO_ELEMENTS_IN_REVEAL: string;