@pitcher/js-api 1.22.0-alpha.0 → 1.22.0-alpha.1

package/lib/composables/useBindValidation.d.ts

@@ -0,0 +1,206 @@
+import { Validation } from '@vuelidate/core';
+import { FormValidationStatus } from 'naive-ui/es/form/src/interface';
+import { Ref } from 'vue';
+
+/**
+ * Options for validators.
+ */
+interface ValidatorOptions {
+    /**
+     * Options for the required validator.
+     * Use either `label` or `msg`, but not both.
+     */
+    required?: {
+        label?: never;
+        msg: string;
+        validationStatus?: FormValidationStatus;
+    } | {
+        label: string;
+        msg?: never;
+        validationStatus?: FormValidationStatus;
+    };
+    /**
+     * Options for the maxLength validator.
+     * Use either `label` and `value`, or `msg`, but not both.
+     */
+    maxLength?: {
+        label?: never;
+        value?: never;
+        msg: string;
+        validationStatus?: FormValidationStatus;
+    } | {
+        label: string;
+        value: number;
+        msg?: never;
+        validationStatus?: FormValidationStatus;
+    };
+    /**
+     * Options for the maxLength validator.
+     * Use either `label` and `value`, or `msg`, but not both.
+     */
+    minLength?: {
+        label?: never;
+        value?: never;
+        msg: string;
+        validationStatus?: FormValidationStatus;
+    } | {
+        label: string;
+        value: number;
+        msg?: never;
+        validationStatus?: FormValidationStatus;
+    };
+    /**
+     * Options for the minValue validator.
+     * Use either `label` and `value`, or `msg`, but not both.
+     */
+    minValue?: {
+        label?: never;
+        value?: never;
+        msg: string;
+        validationStatus?: FormValidationStatus;
+    } | {
+        label: string;
+        value: number;
+        msg?: never;
+        validationStatus?: FormValidationStatus;
+    };
+    /**
+     * Options for the maxValue validator.
+     * Use either `label` and `value`, or `msg`, but not both.
+     */
+    maxValue?: {
+        label?: never;
+        value?: never;
+        msg: string;
+        validationStatus?: FormValidationStatus;
+    } | {
+        label: string;
+        value: number;
+        msg?: never;
+        validationStatus?: FormValidationStatus;
+    };
+    /**
+     * Options for the unique validator.
+     * Use either `label` or `msg`, but not both.
+     */
+    unique?: {
+        label?: never;
+        msg: string;
+        validationStatus?: FormValidationStatus;
+    } | {
+        label: string;
+        msg?: never;
+        validationStatus?: FormValidationStatus;
+    };
+}
+interface ValidatorOptions {
+    required?: {
+        label?: never;
+        msg: string;
+        validationStatus?: FormValidationStatus;
+    } | {
+        label: string;
+        msg?: never;
+        validationStatus?: FormValidationStatus;
+    };
+    maxLength?: {
+        label?: never;
+        value?: never;
+        msg: string;
+        validationStatus?: FormValidationStatus;
+    } | {
+        label: string;
+        value: number;
+        msg?: never;
+        validationStatus?: FormValidationStatus;
+    };
+    minLength?: {
+        label?: never;
+        value?: never;
+        msg: string;
+        validationStatus?: FormValidationStatus;
+    } | {
+        label: string;
+        value: number;
+        msg?: never;
+        validationStatus?: FormValidationStatus;
+    };
+    minValue?: {
+        label?: never;
+        value?: never;
+        msg: string;
+        validationStatus?: FormValidationStatus;
+    } | {
+        label: string;
+        value: number;
+        msg?: never;
+        validationStatus?: FormValidationStatus;
+    };
+    maxValue?: {
+        label?: never;
+        value?: never;
+        msg: string;
+        validationStatus?: FormValidationStatus;
+    } | {
+        label: string;
+        value: number;
+        msg?: never;
+        validationStatus?: FormValidationStatus;
+    };
+    unique?: {
+        label?: never;
+        msg: string;
+        validationStatus?: FormValidationStatus;
+    } | {
+        label: string;
+        msg?: never;
+        validationStatus?: FormValidationStatus;
+    };
+}
+type FieldOptions<Form> = {
+    [K in keyof Form]?: ValidatorOptions;
+};
+/**
+ * Bind validation options to a form.
+ *
+ * @template Form - The type of the form.
+ * @param {Ref<Validation>} v - The validation reference.
+ * @param {FieldOptions<Form>} [options] - The field options for validation.
+ * @returns {object} - An object containing the `bindValidation` function.
+ *
+ * @example
+ * Example 1:
+ * Bind validation options for Form with label-based configuration using default validation message
+ *
+ * const { bindValidation } = useBindValidation<Form>(v, {
+ *   name: { required: { label: labels.name } }, // Required validation with label
+ *   account: { required: { label: labels.account } }, // Required validation with label
+ *   status: { required: { label: labels.status } }, // Required validation with label
+ *   tags: { maxLength: { label: labels.tags, value: 5 } }, // MaxLength validation with label and value
+ * });
+
+ * Example 2:
+ * Bind validation options for Form with message-based configuration.
+ *
+ * const { bindValidation } = useBindValidation<Form>(v, {
+ *   name: { required: { msg: requiredMsg('name') } }, // Required validation with message
+ *   account: { required: { msg: requiredMsg('account') } }, // Required validation with message
+ *   status: { required: { msg: requiredMsg('status') } }, // Required validation with message
+ *   tags: {
+ *     maxLength: {
+ *       msg: t('canvasUI.CCreateTemplateModal.form.validation.maxLength', {
+ *         field: labels.tags.toLowerCase(),
+ *         value: TAGS_LIMIT,
+ *       }),
+ *     }, // MaxLength validation with message
+ *   },
+ * });
+ */
+declare const _default: <Form extends Record<string, any>>(v: Ref<Validation>, options?: FieldOptions<Form>) => {
+    bindValidation: <Key extends keyof Form>(key: Key) => {
+        feedback: string;
+        showFeedback: any;
+        validationStatus: FormValidationStatus;
+    };
+};
+export default _default;

package/lib/composables/useConfirmation.d.ts

@@ -0,0 +1,23 @@
+import { DialogOptions } from 'naive-ui/es/dialog/src/DialogProvider';
+
+interface ConfirmationOptions extends DialogOptions {
+    disableCancelWhenLoading?: boolean;
+    disableDenyWhenLoading?: boolean;
+    hasCancel?: boolean;
+    hasExit?: boolean;
+    cancelText?: string;
+    exitText?: string;
+    confirmText?: string;
+    onConfirm?: () => Promise<boolean | void> | boolean | void;
+    onExit?: () => Promise<void> | void;
+    onCancel?: () => Promise<void> | void;
+}
+declare const _default: () => {
+    dialog: import('naive-ui').DialogApi;
+    success: (options: ConfirmationOptions) => import('naive-ui').DialogReactive;
+    create: (options: ConfirmationOptions) => import('naive-ui').DialogReactive;
+    warning: (options: ConfirmationOptions) => import('naive-ui').DialogReactive;
+    error: (options: ConfirmationOptions) => import('naive-ui').DialogReactive;
+    info: (options: ConfirmationOptions) => import('naive-ui').DialogReactive;
+};
+export default _default;

package/lib/composables/useConnectUpload.d.ts

@@ -0,0 +1,5 @@
+interface UploadResponse {
+    url: string;
+}
+export declare function uploadToConnect(formData: FormData): Promise<UploadResponse>;
+export {};

package/lib/composables/useDetailsView.d.ts

@@ -0,0 +1,19 @@
+import { ComputedRef, Ref } from 'vue';
+import { NavigationFailure } from 'vue-router';
+import * as Waypoint from 'vue-waypoint';
+export default function <T extends string>(sectionIdList: T[]): {
+    onScrollToWaypoint: ({ el, going, direction, }: {
+        el: Element;
+        going: Waypoint.Going;
+        direction: Waypoint.Direction;
+    }) => void;
+    onClose: (sectionId: T) => void;
+    onClickMenu: (sectionId: T) => void;
+    selectedSectionId: Ref<string>;
+    sectionsEditStates: import('vue').UnwrapNestedRefs<Record<T, boolean>>;
+    routerGuard: (guard: ComputedRef<boolean>, goBack: () => Promise<void | NavigationFailure | undefined>) => void;
+    waypointOptions: {
+        threshold: number;
+    };
+    MENU_WIDTH: string;
+};

package/lib/composables/useFetchUsers.d.ts

@@ -0,0 +1,18 @@
+import { SelectOption } from 'naive-ui';
+import { PitcherInfo } from '../types/app';
+import { User } from '../../types/openapi';
+
+export type Owner = {
+    value: User['id'];
+    name: string;
+    email: User['email'];
+};
+declare function insertUserSorted(users: Owner[], newUser: Owner): Owner[];
+declare function filterUsers(searchTerm: string | null | undefined, option: SelectOption): boolean;
+declare function fetchUsers(pitcherInfo: PitcherInfo, myUser?: User | null): Promise<Owner[]>;
+export default function useFetchUsers(): {
+    fetchUsers: typeof fetchUsers;
+    filterUsers: typeof filterUsers;
+    insertUserSorted: typeof insertUserSorted;
+};
+export {};

package/lib/composables/useInfiniteScroll.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+import { MaybeRef } from '@vueuse/core';
+
+interface Options {
+    element: MaybeRef<HTMLElement | null>;
+    isLoading: Ref<boolean>;
+    isAllLoaded: Ref<boolean>;
+    isReady: Ref<boolean>;
+    scrollDistance?: number;
+    loadMore: () => void | Promise<void>;
+}
+export default function ({ element, loadMore, isLoading, isReady, isAllLoaded, scrollDistance, }: Options): void;
+export {};

package/lib/composables/useInstalledApps.d.ts

@@ -0,0 +1,3 @@
+import { AppFile } from '../types/app';
+
+export declare const loadCanvasAndDsrApps: () => Promise<AppFile[]>;

package/lib/composables/useLocation.d.ts

@@ -0,0 +1,26 @@
+import { Router } from 'vue-router';
+import { MaybeRef } from '@vueuse/core';
+import { LocationRoutes, UpdateLocationOnUpdate } from '../sdk/interfaces';
+
+export interface UseLocationPayload {
+    router: Router;
+    app: string;
+    isReady?: MaybeRef<boolean>;
+    urlMode?: 'hash' | 'history';
+    isRoot?: boolean;
+    selfRegister?: boolean;
+    isDebug?: boolean;
+}
+export declare const ROOT_APP = "root";
+export default function useLocation({ app, router, isReady, isRoot, selfRegister, isDebug, urlMode, }: UseLocationPayload): {
+    registerApp: ({ child_app, parent_app, path }: import('./useLocationManipulation').RegisterLocation) => Promise<any>;
+    unregisterApp: (appName: string) => Promise<any>;
+    routes: LocationRoutes;
+    relations: Record<string, string>;
+    unmount: () => Promise<void>;
+    update: (newRoutes: UpdateLocationOnUpdate['routes']) => Promise<void>;
+    isPathRestored: import('vue').Ref<boolean>;
+    isAppMounted: import('vue').ComputedRef<boolean>;
+    isAppRestored: import('vue').ComputedRef<boolean>;
+    app: string;
+};

package/lib/composables/useLocationAPI.d.ts

@@ -0,0 +1,39 @@
+import { RouteLocationRaw, Router } from 'vue-router';
+import { LocationRoutes, UpdateLocationOnRestore, UpdateLocationOnUpdate, UpdateLocationPitcherEvent } from '../sdk/interfaces';
+import { RegisterLocation } from './useLocationManipulation';
+
+export interface UseLocationAPI {
+    app: string;
+    isRoot: boolean;
+    router: Router;
+    urlMode: 'hash' | 'history';
+    sendToRoot: (body: UpdateLocationPitcherEvent) => Promise<any>;
+}
+export default function useLocationAPI(params: UseLocationAPI): {
+    broadcast: {
+        unregister: (appName: string) => Promise<any>;
+        register: ({ child_app, parent_app, path }: RegisterLocation) => Promise<any>;
+        update: (routes: UpdateLocationOnUpdate['routes']) => Promise<any>;
+        mount: () => Promise<any>;
+        mounted: () => Promise<any>;
+        restore: (routes: UpdateLocationOnRestore['routes']) => Promise<any>;
+        restoreCompleted: (path: string, query: Record<string, any>) => Promise<any>;
+        getRoutesRequest: () => Promise<any>;
+        getRoutesResponse: (app: string, routes: LocationRoutes) => Promise<any>;
+    };
+    internalRouter: {
+        path: import('vue').ComputedRef<string>;
+        query: import('vue').ComputedRef<import('vue-router').LocationQuery>;
+        push: (to: RouteLocationRaw) => Promise<void | import('vue-router').NavigationFailure | undefined>;
+        replace: (to: RouteLocationRaw) => Promise<void | import('vue-router').NavigationFailure | undefined>;
+    };
+    globalRouter: {
+        getPath: () => string;
+        getSearch: () => string;
+        getPathWithSearch: () => string;
+        getSearchAsObject: () => {
+            [k: string]: string;
+        };
+    };
+    buildUrl: (url: string, query: Record<string, any>) => string;
+};

package/lib/composables/useLocationListeners.d.ts

@@ -0,0 +1,8 @@
+import { UpdateLocationPitcherEvent } from '../sdk/interfaces';
+
+export default function (executeLocationChange: (body: UpdateLocationPitcherEvent) => Promise<void>, isRoot: boolean): {
+    subscribers: MessageEventSource[];
+    initListeners: () => Promise<void>;
+    removeListeners: () => Promise<void>;
+    sendToRoot: (body: UpdateLocationPitcherEvent) => Promise<any>;
+};

package/lib/composables/useLocationManipulation.d.ts

@@ -0,0 +1,37 @@
+import { Ref } from 'vue';
+import { LocationRoute, LocationRoutes, UpdateLocationPitcherEvent } from '../sdk/interfaces';
+import { default as useLocationAPI } from './useLocationAPI';
+
+interface UseLocationManipulation {
+    routes: LocationRoutes;
+    relations: {
+        [key: string]: string;
+    };
+    app: string;
+    actionsQueue: Ref<UpdateLocationPitcherEvent[]>;
+}
+type LocationQuery = Record<string, any>;
+export interface RegisterLocation {
+    child_app: string;
+    parent_app?: string;
+    path?: string;
+    query?: LocationQuery;
+}
+interface Route {
+    path: string;
+    query: LocationQuery;
+}
+export default function useLocationManipulation({ routes, relations, app, actionsQueue }: UseLocationManipulation): {
+    isPathRestored: Ref<boolean>;
+    isAppMounted: import('vue').ComputedRef<boolean>;
+    isAppRestored: import('vue').ComputedRef<boolean>;
+    recoverRouteFromLocations: (rootApp: string) => Route;
+    isSameRoute: (route1?: Route, route2?: Route) => boolean;
+    isSameRouteAsStored: (internalRouter: ReturnType<typeof useLocationAPI>['internalRouter']) => boolean;
+    deleteRelation: (appName: string) => string[];
+    addActionToQueue: (body: UpdateLocationPitcherEvent) => void;
+    registerLocation: ({ child_app, parent_app, path, query }: RegisterLocation) => void;
+    createRoute: (params?: Partial<LocationRoute>) => LocationRoute;
+    unregisterLocation: (appName: string) => void;
+};
+export {};

package/lib/composables/usePdfInterpolation.d.ts

@@ -0,0 +1,9 @@
+import { default as PSPDFKitType, ServerConfiguration } from 'pspdfkit';
+
+declare function annotationsInterpolation({ PSPDFKit, config, data, }: {
+    PSPDFKit: typeof PSPDFKitType;
+    config: ServerConfiguration;
+    data: Record<string, string>;
+}): Promise<void>;
+export default function usePdfInterpolation(strategy?: 'annotations' | 'text'): typeof annotationsInterpolation;
+export {};

package/lib/composables/useTheme.d.ts

@@ -0,0 +1,9 @@
+import { BasicPalette } from '@theme/theme.types';
+
+export default function useTheme(): {
+    applyEnvironmentTheme: (themeFetcher?: () => Promise<{
+        primary: string | null | undefined;
+    }>) => Promise<void>;
+    updateTheme: (updatedTheme: Partial<BasicPalette>) => void;
+    updatePrimaryColor: (color?: string) => void;
+};

package/lib/composables/useThemeVars.d.ts

@@ -0,0 +1,30 @@
+declare const _default: () => import('vue').Ref<{
+    base: string;
+    primary: string;
+    primary2: string;
+    primary3: string;
+    primary4: string;
+    primary5: string;
+    primary6: string;
+    primary6_1: string;
+    accent: string;
+    text: string;
+    text2: string;
+    text3: string;
+    error: string;
+    error2: string;
+    error3: string;
+    warning: string;
+    warning2: string;
+    warning3: string;
+    success: string;
+    success2: string;
+    success3: string;
+    info: string;
+    info2: string;
+    info3: string;
+    boxShadow: string;
+    boxShadow2: string;
+    boxShadow3: string;
+}>;
+export default _default;

package/lib/composables/useToast.d.ts

@@ -0,0 +1,14 @@
+import { MessageApiInjection } from 'naive-ui/es/message/src/MessageProvider';
+import { UiToastPayload } from '../sdk/api/modules/ui/types.ui';
+
+export default function useToast(): {
+    initMessageProvider: () => void;
+    getMessageProvider: () => MessageApiInjection | null;
+    toast: ((data: UiToastPayload) => void) & {
+        info: (message: string) => import('naive-ui').MessageReactive | undefined;
+        error: (message: string) => import('naive-ui').MessageReactive | undefined;
+        warning: (message: string) => import('naive-ui').MessageReactive | undefined;
+        success: (message: string) => import('naive-ui').MessageReactive | undefined;
+        loading: (message: string) => import('naive-ui').MessageReactive | undefined;
+    };
+};

package/lib/composables/useWindowEvents.d.ts

@@ -0,0 +1,20 @@
+import { PLATFORM_TYPE, CLIENT_TYPE, CDP_EVENT_TYPE } from '../constants/cdp.const';
+import { usePitcherApi } from '../sdk/main';
+
+type EventType = 'active' | 'passive';
+export type InactiveEventPayload = {
+    platform?: (typeof PLATFORM_TYPE)[keyof typeof PLATFORM_TYPE];
+    client?: (typeof CLIENT_TYPE)[keyof typeof CLIENT_TYPE];
+    [key: string]: any;
+};
+export default function (track: (eventName: string, payload: any) => void, pitcherApi?: ReturnType<typeof usePitcherApi>): {
+    registerInactiveEvent: ({ id, payload, enterEvent, exitEvent, type, }: {
+        id: string;
+        payload: InactiveEventPayload;
+        enterEvent: (typeof CDP_EVENT_TYPE)[keyof typeof CDP_EVENT_TYPE];
+        exitEvent: (typeof CDP_EVENT_TYPE)[keyof typeof CDP_EVENT_TYPE];
+        type?: EventType;
+    }) => void;
+    unregisterInactiveEvent: (id: string) => void;
+};
+export {};

package/lib/constants/cdp.const.d.ts

@@ -0,0 +1,41 @@
+export declare const CDP_EVENT_TYPE: {
+    readonly instanceEntered: "Instance Entered";
+    readonly instanceExited: "Instance Exited";
+    readonly fileEntered: "File Entered";
+    readonly fileExited: "File Exited";
+    readonly webFileEntered: "Web File Entered";
+    readonly webFileExited: "Web File Exited";
+    readonly pageEntered: "Page Entered";
+    readonly pageExited: "Page Exited";
+    readonly pageViewed: "Page Viewed";
+    readonly canvasEntered: "Canvas Entered";
+    readonly canvasExited: "Canvas Exited";
+    readonly canvasShared: "Canvas Shared";
+    readonly canvasComponentEntered: "Canvas Component Entered";
+    readonly canvasComponentExited: "Canvas Component Exited";
+    readonly canvasFileDownloaded: "Canvas File Downloaded";
+    readonly canvasDownloaded: "Canvas Downloaded";
+    readonly userFeedbackCaptured: "User Feedback Captured";
+    readonly userBugReported: "User Bug Reported";
+};
+export declare const CLIENT_TYPE: {
+    readonly admin: "admin";
+    readonly impact: "impact";
+    readonly dsr: "dsr";
+};
+export declare const DSR_TYPE: {
+    readonly file: "file";
+    readonly canvas: "canvas";
+};
+export declare const PLATFORM_TYPE: {
+    readonly web: "web";
+    readonly ios: "ios";
+    readonly android: "android";
+    readonly windows: "windows";
+};
+export declare const EMBED_TYPE: {
+    readonly standalone: "standalone";
+    readonly iframe: "iframe";
+    readonly sfdc: "sfdc";
+    readonly pwa: "pwa";
+};

package/lib/constants/config.const.d.ts

@@ -0,0 +1 @@
+export declare const PRINT_SCALE_FACTOR = 0.8;

package/lib/constants/conventions.const.d.ts

@@ -0,0 +1,3 @@
+export declare const HIDE_TAGS_WITH_PREFIX: readonly ["ID:"];
+export declare const HIDE_IF_EMPTY_COMPONENT_ID_TAG_PREFIX = "hide-if-empty-id:";
+export declare const HIDE_IF_EMPTY_COMPONENT_TRACKING_ID_TAG_PREFIX = "hide-if-empty-tracking-id:";

package/lib/constants/i18n.const.d.ts

@@ -0,0 +1,13 @@
+import { SupportedLocale } from '../types/i18n.types';
+
+export declare const supportedLocales: ["en", "de", "pl", "tr", "el"];
+export declare const fallbackLocale: "en";
+export declare const locales: Record<SupportedLocale, {
+    locale: any;
+    dateLocale: any;
+}>;
+export declare const localeNames: Record<SupportedLocale, string>;
+export declare const localeDropdownOptions: {
+    key: "tr" | "el" | "en" | "de" | "pl";
+    name: string;
+}[];

package/lib/constants/modal.const.d.ts

@@ -0,0 +1,9 @@
+export declare const MODAL_WIDTH: {
+    Default: number;
+    'X-Small': number;
+    Small: number;
+    Dense: number;
+    Medium: number;
+    Large: number;
+    'X-Large': number;
+};

package/lib/constants/more.const.d.ts

@@ -0,0 +1 @@
+export declare const moreCountBuffer = 1;

package/lib/constants/recentFiles.const.d.ts

@@ -0,0 +1,4 @@
+export declare const MAX_RECENT_FILES = 20;
+export declare const MAX_RECENT_FILES_TO_SHOW = 6;
+export declare const RECENT_FILES_STORAGE_KEY_ADMIN = "ciq_admin_recent_files";
+export declare const RECENT_FILES_STORAGE_KEY_IMPACT = "ciq_recent_files";

package/lib/constants/tables.const.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_ADMIN_TABLE_HEIGHT = "calc(100vh - 308px)";
+export declare const DEFAULT_ADMIN_TABLE_WITH_PAGINATION_HEIGHT = "calc(100vh - 352px)";
+export declare const DEFAULT_PAGE_SIZE = 100;
+export declare const DEFAULT_PAGE_SIZE_OPTIONS: number[];

package/lib/constants/timers.const.d.ts

@@ -0,0 +1 @@
+export declare const SEARCH_DEBOUNCE_TIME = 850;

package/lib/constants/uploads.const.d.ts

@@ -0,0 +1,8 @@
+export declare const MAX_UPLOAD_SIZE: number;
+export declare const SUPPORTED_IMAGE_TYPES: string[];
+export declare const SUPPORTED_VIDEO_TYPES: string[];
+export declare const SUPPORTED_IMAGE_EXTENSIONS: string[];
+export declare const SUPPORTED_VIDEO_EXTENSIONS: string[];
+export declare const SUPPORTED_UPLOAD_FILE_EXTENSIONS: string[];
+export declare const SUPPORTED_FONT_TYPES: string[];
+export declare const SUPPORTED_FONT_EXTENSIONS: string[];

package/lib/constants/url.const.d.ts

@@ -0,0 +1,2 @@
+export declare const IS_DEV_ORG: boolean;
+export declare const IS_LOCALHOST: boolean;