@giteeteam/apps-team-components 0.4.1 → 0.4.3

package/dist/lib/hooks/index.d.ts

@@ -0,0 +1,13 @@
+declare type UseSwitchType = (initialValue: boolean) => [boolean, () => void, () => void];
+declare type UseActiveDataReturnType<T> = [boolean, T, (record: T) => void, () => void];
+export { default as useCurrentUser } from './useCurrentUser';
+export { useCustomFields } from './useCustomFields';
+export { useFieldTypes } from './useFieldTypes';
+export { useTenants } from './useTenants';
+export { useToken } from './useToken';
+export { default as useUsers } from './useUsers';
+export { useWorkspaces } from './useWorkspaces';
+export declare const useSwitch: UseSwitchType;
+export declare const useActiveData: <T>(initialValue: T, defaultActive: boolean) => UseActiveDataReturnType<T>;
+export declare const useAllWorkspace: () => any[];
+export declare const useAllWorkspaceScheme: () => any[];

package/dist/lib/hooks/useCurrentUser.d.ts

@@ -0,0 +1,3 @@
+import { currentUserContext } from '../contexts/currentUserAndRoles';
+declare const useCurrentUser: () => currentUserContext;
+export default useCurrentUser;

package/dist/lib/hooks/useCustomFields.d.ts

@@ -0,0 +1,9 @@
+import { CustomField as CustomFieldProps } from '@/lib/types/models';
+export declare type customFieldsType = {
+    getById: (id: string) => [customField: CustomFieldProps | any, loading: boolean];
+    getByKey: (key: string) => [customField: CustomFieldProps | any, loading: boolean];
+    getMap: () => [customFieldsMap: any, loading: boolean];
+    getAll: () => [customFields: (CustomFieldProps | any)[], loading: boolean];
+};
+declare const useCustomFields: () => customFieldsType;
+export { useCustomFields };

package/dist/lib/hooks/useDataQuoteStore.d.ts

@@ -0,0 +1,7 @@
+import { Item } from '@/lib/types/models';
+import { CustomArray } from './useItemsInfinite';
+interface ItemProps extends Item {
+    values: any;
+}
+export declare const useDataQuoteStore: (dataSources: CustomArray<ItemProps>) => void;
+export {};

package/dist/lib/hooks/useFieldTypes.d.ts

@@ -0,0 +1,9 @@
+export declare type fieldTypesType = {
+    getById: (id: any) => Record<string, any>;
+    map: {
+        [key: string]: Record<string, any>;
+    };
+    all: Record<string, any>[];
+};
+declare const useFieldTypes: () => fieldTypesType;
+export { useFieldTypes };

package/dist/lib/hooks/useFields.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export declare const initComponentName: (fieldName: string) => string;
+declare type UseFieldsType = (fieldTypes?: string[]) => {
+    components: {
+        [fieldType: string]: {
+            [componentName: string]: React.FC<any> | React.ForwardRefRenderFunction<any, any>;
+        };
+    };
+    loading: boolean;
+};
+declare const useFields: UseFieldsType;
+export default useFields;

package/dist/lib/hooks/useI18n.d.ts

@@ -0,0 +1 @@
+export default function useI18n(): import("../i18n").i18nContext;

package/dist/lib/hooks/useItemsInfinite.d.ts

@@ -0,0 +1,48 @@
+import { Dispatch, SetStateAction } from 'react';
+import { Item } from '@/lib/models';
+import { ForestChangeItem, ForestItem, ForestParams } from '@/lib/types/item-forest';
+import { ObjectId } from '@/lib/types/models';
+declare type Item = ForestItem;
+export interface CustomArray<T> extends Array<T> {
+    __hash?: any;
+}
+declare type UseItemReturn = {
+    offset: number;
+    setOffset: Dispatch<SetStateAction<number>>;
+    limit: number;
+    data: CustomArray<any>;
+    list: CustomArray<any>;
+    setLimit: Dispatch<SetStateAction<number>>;
+    total: number;
+    isValidating: boolean;
+    handleForestChange: (itemId: ObjectId, original: ForestChangeItem, target: ForestChangeItem) => void;
+    mutate: any;
+    itemsMutate: any;
+    hitIds?: ObjectId[];
+    rows?: ObjectId[];
+    loadingEnd: boolean;
+};
+declare type UseItem = (params: ForestParams) => UseItemReturn;
+declare class ItemCache {
+    private __array;
+    private __total;
+    private __useCache;
+    private __mapIndex;
+    private __mapIds;
+    constructor();
+    getAncestorsByDepths(depths: number[], cacheIndex: number): string[];
+    getHash(): any;
+    setNewHash(): void;
+    set(cursor: number, data: any[]): void;
+    setItems(data: Item[], depths: number[]): void;
+    setTotal(total: number): void;
+    filterNeedLoadItems(keys: string[]): string[];
+    setKeys(keys: string[]): void;
+    useCache(enable: any): void;
+    resetIndexRefMap(): void;
+    sort(currentIndex: any, nextIndex: any, moveLength: any): void;
+    data(): CustomArray<any>;
+}
+export declare const cache: ItemCache;
+declare const useItems: UseItem;
+export default useItems;

package/dist/lib/hooks/useRemoteComponents.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+export declare type UseRemoteComponents = (remoteUrls: string[]) => {
+    componentModule: {
+        [componentName: string]: React.FC<any> | React.ForwardRefRenderFunction<any, any>;
+    };
+    loading: boolean;
+};
+export declare const loadRemote: any;
+declare type AppModule = any;
+export declare const getModule: (moduleName: string) => AppModule;
+export declare const useRemoteComponents: UseRemoteComponents;
+declare type UseEnhanceRemoteComponents = (componentMap: Record<string, string>) => {
+    loading: boolean;
+    componentEntity: Record<string, {
+        Cell?: any;
+        CellConfig?: any;
+        Field: any;
+        FieldConfig?: any;
+        ScreenConfig?: any;
+        __status: 'rejected' | 'fulfilled';
+        __reason: any;
+    }>;
+};
+export declare const useEnhanceRemoteComponents: UseEnhanceRemoteComponents;
+export {};

package/dist/lib/hooks/useTenants.d.ts

@@ -0,0 +1,7 @@
+import { Tenant as TenantProps } from '@/lib/types/models';
+export declare type tenantsType = {
+    getById: (id: string) => [fieldType: TenantProps | any, loading: boolean];
+    getAll: () => [fieldTypes: (TenantProps | any)[], loading: boolean];
+};
+declare const useTenants: () => tenantsType;
+export { useTenants };

package/dist/lib/hooks/useToken.d.ts

@@ -0,0 +1,3 @@
+import { tokenContext } from '../contexts/token';
+export declare const useToken: () => tokenContext;
+export default useToken;

package/dist/lib/hooks/useUsers.d.ts

@@ -0,0 +1,8 @@
+import { usersContext } from '@/lib/contexts';
+import { ObjectId, User } from '@/lib/types/models';
+declare const useUsers: () => usersContext;
+export default useUsers;
+export declare const useRecoilUsers: (userIds: ObjectId[]) => {
+    data: User[];
+    loading: boolean;
+};

package/dist/lib/hooks/useWatchItemUpdate.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="parse" />
+import { KeyedMutator } from 'swr';
+import { Item, ViewType } from '@/lib/types/models';
+import { SearchResult } from '../types/common';
+export declare const enum ConnectionType {
+    CONNECTING = "connecting",
+    OPEN = "open",
+    CREATE = "create",
+    UPDATE = "update",
+    DELETE = "delete",
+    CLOSE = "close"
+}
+export declare const enum DispatchType {
+    CREATE = "create",
+    UPDATE = "update",
+    DELETE = "delete"
+}
+interface IItemUpdateProps {
+    items?: Item[];
+    refreshData?: KeyedMutator<SearchResult>;
+    type?: ViewType;
+    dispatch?: (...rest: any[]) => void;
+}
+interface IItemUpdateReturn {
+    loading: boolean;
+    recordItemIds: string[];
+    status: ConnectionType;
+}
+export declare function requestDelay(): void;
+export declare function useWatchItemUpdate<T extends Parse.Object = Parse.Object>(props: IItemUpdateProps): Promise<IItemUpdateReturn | void>;
+export declare function closeWatchItemUpdate(): void;
+export {};

package/dist/lib/hooks/useWorkspaces.d.ts

@@ -0,0 +1,8 @@
+import { Workspace as WorkspaceProps } from '@/lib/types/models';
+export declare type workspacesTypes = {
+    getById: (id: string) => [workspace: WorkspaceProps | any, loading: boolean];
+    getByKey: (key: string) => [workspace: WorkspaceProps | any, loading: boolean];
+    getAll: () => [workspaces: (WorkspaceProps | any)[], loading: boolean];
+};
+declare const useWorkspaces: () => workspacesTypes;
+export { useWorkspaces };

package/dist/lib/i18n.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import rosetta from 'rosetta';
+declare type LocalLng = string;
+declare type LngDict = any;
+export declare type i18nContext = {
+    activeLocale: LocalLng;
+    t: typeof i18n.t;
+    locale: (l: LocalLng, dict?: LngDict) => void;
+};
+declare type I18nProvider = (params: {
+    children: React.ReactNode;
+    locale: LocalLng;
+    lngDict: LngDict;
+}) => JSX.Element;
+export declare const i18n: rosetta.Rosetta<unknown>;
+export declare const defaultLanguage = "en";
+export declare const languages: string[];
+export declare const contentLanguageMap: {
+    zh: string;
+    en: string;
+};
+export declare const I18nContext: React.Context<i18nContext>;
+declare const I18n: I18nProvider;
+export default I18n;

package/dist/lib/iql.d.ts

@@ -0,0 +1,31 @@
+import { IQL, OrderBy } from './types/iql';
+import { SelectCase, Selectors, Workspace } from './types/models';
+export declare const replaceSingleQuote: (val: string) => string;
+export declare const mergeNameToSelectors: (name: string, selectors: Selectors) => Selectors;
+export declare const getNameBySectors: (selectors: Selectors) => string;
+export declare const makeNameSelectorCase: (name: string) => SelectCase;
+export declare const selectorToIql: (selectors: Selectors) => IQL;
+/**
+ * 排除IQL函数体里面的内容
+ * @param iql IQL
+ * @returns 排除后的IQL
+ */
+export declare const excludeIqlFunctionContext: (iql: IQL) => IQL;
+export declare const buildOrderBy: (orderBys: OrderBy[]) => IQL;
+export declare const hasOrderBy: (iql: IQL) => boolean;
+export declare const withOrderBy: (iql: IQL, orderBys?: OrderBy[]) => IQL;
+export declare const hasWorksapce: (iql: IQL) => boolean;
+export declare const hasItemType: (iql: IQL) => boolean;
+export declare const withWorkspace: (iql: IQL, workspace: Workspace) => IQL;
+export declare const withItemType: (iql: IQL, itemType: string) => IQL;
+/**
+ * 合并IQL语句
+ *
+ * 如果 源IQL 带有排序信息 就用原来的排序
+ * 如果没有就用 目标IQL 的排序
+ *
+ * @param sourceIQL 源IQL
+ * @param targetIQL 目标IQL
+ * @returns 合并后的IQL
+ */
+export declare const mergeIQL: (sourceIQL: IQL, targetIQL: IQL) => IQL;

package/dist/lib/item/hooks.d.ts

@@ -0,0 +1,31 @@
+import { CancelTokenStatic } from 'axios';
+import Parse from '@/lib/parse';
+import { LabelStyleProps, UserProps } from '@/lib/types/item';
+import { Item as ItemProps, Workspace as WorkspaceProps } from '@/lib/types/models';
+export declare const useItem: (itemId: string) => any;
+export declare const useSecurityLevel: (securityLevel: string, user: UserProps) => any;
+export declare const useLabelStyle: (props: LabelStyleProps) => any;
+export declare const useCustomFields: ({ itemId, screen, itemTypeId, keys, transition, workspaceId, itemLinkTypeId, inwardItemId, parentId, CancelToken, }: {
+    itemId: string;
+    screen: string;
+    itemTypeId: string;
+    keys: string[];
+    transition?: string;
+    workspaceId?: string;
+    itemLinkTypeId?: string;
+    inwardItemId?: string;
+    parentId?: string;
+    CancelToken?: CancelTokenStatic;
+}) => any;
+export declare const useItemTypes: (workspaceValue?: string, itemLinkTypeValue?: string) => any;
+export declare const useWorkspace: (id?: string) => string;
+export declare const useItemWorkspace: (itemId?: string | number) => string;
+export declare const useGetCurrentWorkspaceId: (id?: string) => string;
+export declare const useGetCurrentWorkspaceDetail: (workspaceId: any) => Parse.Attributes;
+export declare const useCurrentWorkspaceId: (workspaceName?: string) => {
+    workspaceId: string;
+};
+export declare const getNewlyCreatedItem: (currentUser?: Parse.User<Parse.Attributes>, workspaceKey?: string) => Promise<ItemProps | {
+    workspace: WorkspaceProps;
+} | void>;
+export declare const useDateTimeConfiguration: () => string;

package/dist/lib/item/utils.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @file 通用工具函数
+ */
+import { FormikProps, ItemResultProps, ItemTypeScreenSchemeResultProps, SessionTokenType } from '@/lib/types/item';
+export declare const getUser: (objectId: string) => Promise<any>;
+export declare const getKey: (keyword: string) => string;
+export declare const getItemData: (itemId: string, sesseionOption?: SessionTokenType) => Promise<any>;
+export declare const getScreenFromId: (id: string, sesseionOption?: SessionTokenType) => Promise<any>;
+export declare const getItemTypeScreenScheme: (id: string, sesseionOption?: SessionTokenType) => Promise<any>;
+export declare const getworkspaceScheme: (id: string, sesseionOption?: SessionTokenType) => Promise<any>;
+export declare const getScreenScheme: (objectId: string, sesseionOption?: SessionTokenType) => Promise<any>;
+export declare const getWorkspace: (value: string, type: string, sesseionOption?: SessionTokenType) => Promise<any>;
+export declare const getItemTypeFromId: (id: string) => Promise<any>;
+export declare const getItemTypeScreenSchemeMapping: (objectIds: string[], sesseionOption?: SessionTokenType) => Promise<any>;
+export declare const getScreenSchemeObjectId: (itemTypeScreenSchemeResult: ItemTypeScreenSchemeResultProps, itemType: string, sesseionOption?: SessionTokenType) => Promise<any>;
+export declare const getScreen: any;
+export declare const getCustomFields: (keys?: any[]) => Promise<any>;
+export declare const getItemSecurityLevelAgroup: (objectId: string) => Promise<any>;
+export declare const getRoleAgroup: (objectIdArr: any[]) => Promise<any>;
+export declare const updateFieldsDataValue: (fieldsData: unknown, itemResult: ItemResultProps) => any;
+export declare const generateFieldsData: any;
+export declare const getErrorClassName: (formikProps: FormikProps, fieldKey: string) => string;
+export declare const getCustumFieldType: (fieldTypeId: string, fieldsType: any[]) => string;
+export declare const getScreenFieldKeys: (screenSetFieldKeys?: any[]) => any;
+export declare const handleFormikValuesToDatabase: (data?: Record<string, any>) => unknown;
+export declare const handleDatabaseValuesToFormik: (data?: Record<string, any>) => unknown;
+export declare const updateItemDetail: ({ values, touched, mode, itemId, success, fail, }: {
+    values: any;
+    touched: any;
+    mode: string;
+    itemId: string;
+    success: () => void;
+    fail: (error: any) => void;
+}) => Promise<void>;

package/dist/lib/kanban/hooks.d.ts

@@ -0,0 +1,8 @@
+import { CustomField as CustomFieldType } from '@/lib/types/models';
+declare type UseBusinessFields = (fields: CustomFieldType[]) => Record<'cardLayout' | 'swimlane', {
+    fields: CustomFieldType[];
+    labelKey: Record<'label' | 'value', string>[];
+}>;
+/** 获取配置弹窗依赖项 */
+export declare const useBusinessFields: UseBusinessFields;
+export {};

package/dist/lib/locales.d.ts

@@ -0,0 +1,4 @@
+export declare function objectPath2Str(obj: {
+    [key: string]: any;
+}, path?: string, target?: {}): any;
+export declare function getMessages(locales?: string | string[]): [locale: string, langBundle: any, antdLang: any];

package/dist/lib/models.d.ts

@@ -0,0 +1,59 @@
+declare const Config: any;
+declare const Attachment: any;
+declare const Tenant: any;
+declare const Workspace: any;
+declare const Version: any;
+declare const Item: any;
+declare const ItemType: any;
+declare const ItemForest: any;
+declare const ItemGroup: any;
+declare const FieldType: any;
+declare const CustomField: any;
+declare const Screen: any;
+declare const Sprint: any;
+declare const ItemLinkType: any;
+declare const Group: any;
+declare const ItemChange: any;
+declare const Gantt: any;
+declare const ProcessBar: any;
+declare const Board: any;
+declare const View: any;
+declare const Privilege: any;
+declare const Permission: any;
+declare const SecurityLevel: any;
+declare const ViewConfiguration: any;
+declare const User: any;
+declare const Role: any;
+declare const ItemSecurityLevel: any;
+declare const FieldBehavior: any;
+declare const DataSource: any;
+declare const DataSourceClassify: any;
+declare const Workflow: any;
+declare const Status: any;
+declare const WorkflowScheme: any;
+declare const WorkflowSchemeConfig: any;
+declare const ItemTypeScheme: any;
+declare const ItemTypeScreenScheme: any;
+declare const Menu: any;
+declare const AppInstallation: any;
+declare const App: any;
+declare const AppVersion: any;
+declare const GanttBaseline: any;
+declare const GanttBaselineItemLog: any;
+declare const WorkspaceScheme: any;
+declare const WorkspaceTemplate: any;
+declare const WorkspaceType: any;
+declare const Comment: any;
+declare const ItemLink: any;
+declare const ScreenScheme: any;
+declare const ItemTypeScreenSchemeMapping: any;
+declare const Filter: any;
+declare const Automation: any;
+declare const AutomationLog: any;
+declare const Kanban: any;
+declare const WorkDay: any;
+declare const Holiday: any;
+declare const DateTimeConfiguration: any;
+declare const Chart: any;
+declare const ChartGroup: any;
+export { App, AppInstallation, AppVersion, Attachment, Automation, AutomationLog, Board, Chart, ChartGroup, Comment, Config, CustomField, DataSource, DataSourceClassify, DateTimeConfiguration, FieldBehavior, FieldType, Filter, Gantt, GanttBaseline, GanttBaselineItemLog, Group, Holiday, Item, ItemChange, ItemForest, ItemGroup, ItemLink, ItemLinkType, ItemSecurityLevel, ItemType, ItemTypeScheme, ItemTypeScreenScheme, ItemTypeScreenSchemeMapping, Kanban, Menu, Permission, Privilege, ProcessBar, Role, Screen, ScreenScheme, SecurityLevel, Sprint, Status, Tenant, User, Version, View, ViewConfiguration, WorkDay, Workflow, WorkflowScheme, WorkflowSchemeConfig, Workspace, WorkspaceScheme, WorkspaceTemplate, WorkspaceType, };

package/dist/lib/parse.d.ts

@@ -0,0 +1,3 @@
+export declare const escapeMatchesQueryArg: (_str: unknown) => RegExp;
+declare const Parse: any;
+export default Parse;

package/dist/lib/path.d.ts

@@ -0,0 +1,4 @@
+export declare const iconBasePath = "/icons";
+export declare const getBasePath: () => string;
+export declare const patchIconUrl: (iconUrl: string) => string;
+export declare const getSourcePath: (path: string) => string;

package/dist/lib/proxima-sdk/components/index.d.ts

@@ -0,0 +1,2 @@
+import * as Components from '@/common';
+export { Components };

package/dist/lib/proxima-sdk/hooks/index.d.ts

@@ -0,0 +1,4 @@
+import * as Hooks from '@/lib/hooks';
+import { default as useFields } from '@/lib/hooks/useFields';
+import * as useParseQuery from '@/lib/useParseQuery';
+export { Hooks, useFields, useParseQuery };

package/dist/lib/proxima-sdk/index.d.ts

@@ -0,0 +1,5 @@
+import * as components from './components';
+import * as hooks from './hooks';
+import * as lib from './lib';
+import * as schema from './schema';
+export { components, hooks, lib, schema };

package/dist/lib/proxima-sdk/lib/index.d.ts

@@ -0,0 +1,9 @@
+import * as Date from '@/lib/date';
+import * as Dayjs from '@/lib/dayjs';
+import * as Fetch from '@/lib/fetch';
+import * as Global from '@/lib/global';
+import * as Iql from '@/lib/iql';
+import * as Parse from '@/lib/parse';
+import * as Path from '@/lib/path';
+import * as Storage from '@/lib/storage';
+export { Date, Dayjs, Fetch, Global, Iql, Parse, Path, Storage };

package/dist/lib/proxima-sdk/schema/index.d.ts

@@ -0,0 +1,2 @@
+import * as models from '../../models';
+export { models };

package/dist/lib/regExp.d.ts

@@ -0,0 +1,11 @@
+export declare const roleNameReg: RegExp;
+export declare const imageTypeReg: RegExp;
+export declare const spaceReg: RegExp;
+export declare const keyCheck: RegExp;
+export declare const RE_WILDCARDS: RegExp;
+export declare const CRON_RE_RANGE: RegExp;
+export declare const AUTOMATE_CRON_REG: RegExp;
+export declare const getNameRegExp: (name?: RegExp | string) => RegExp;
+export declare const ipReg: RegExp;
+export declare const REG_EN: RegExp;
+export declare const REG_NAME: RegExp;

package/dist/lib/storage.d.ts

@@ -0,0 +1,7 @@
+export declare const getLocalStorageItem: (key: string, defalut?: any) => any;
+export declare const setLocalStorageItem: (key: string, value: unknown) => boolean;
+declare const _default: {
+    getItem: (key: string, defalut?: any) => any;
+    setItem: (key: string, value: unknown) => boolean;
+};
+export default _default;

package/dist/lib/store.d.ts

@@ -0,0 +1,14 @@
+import { User } from './types/models';
+export declare const itemGroupStore: import("recoil").RecoilState<{}>;
+export declare const itemGroupStoreSelector: import("recoil").RecoilValueReadOnly<{}>;
+export declare const itemTypeStore: import("recoil").RecoilState<{}>;
+export declare const itemTypeStoreSelector: import("recoil").RecoilValueReadOnly<{}>;
+export declare const fieldTypeStore: import("recoil").RecoilState<{}>;
+export declare const fieldTypeStoreSelector: import("recoil").RecoilValueReadOnly<{}>;
+export declare const workspaceIdStore: import("recoil").RecoilState<string>;
+export declare const workspaceIdStoreSelector: import("recoil").RecoilValueReadOnly<string>;
+export declare const userStore: import("recoil").RecoilState<{}>;
+export declare const userFetchQueue: import("recoil").RecoilState<string[]>;
+export declare const userQueueSelector: import("recoil").RecoilState<string[]>;
+export declare const userMapSelector: import("recoil").RecoilState<{}>;
+export declare const usersSelector: import("recoil").RecoilValueReadOnly<User[]>;

package/dist/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+export * as chart from './chart.d';
+export * as iql from './iql.d';
+export * as models from './models.d';

package/dist/lib/types/parse-models.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="parse" />
+export declare class Workspace extends Parse.Object<{
+    name: string;
+}> {
+    constructor(options?: any);
+}

package/dist/lib/useInitialRecoilState.d.ts

@@ -0,0 +1,3 @@
+export declare const useInitialRecoilState: ({ workspaceKey }: {
+    workspaceKey: any;
+}) => void;

package/dist/lib/useParseQuery.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="parse" />
+import { Dispatch, SetStateAction } from 'react';
+import { SWRConfiguration, SWRResponse } from 'swr';
+import { SearchResult } from './types/common';
+import { IQLParams } from './types/iql';
+import { Item } from './types/models';
+import Parse from './parse';
+export declare enum FetchMethod {
+    Default = "find",
+    All = "findAll",
+    First = "first",
+    Count = "count"
+}
+export declare function fetcher(className: string, query: string, fetchMethod: FetchMethod, options: string): Promise<any>;
+declare const useParseQuery: (query: Parse.Query, fetchMethod?: FetchMethod, config?: SWRConfiguration, options?: {}) => SWRResponse<any, any>;
+export default useParseQuery;
+interface UseFindResult<T extends Parse.Object<Parse.Attributes>> {
+    results?: T[];
+    count?: number;
+    error?: Error;
+    isLoading: boolean;
+    reload: () => void;
+}
+interface UseFirstResult<T extends Parse.Object<Parse.Attributes>> {
+    result?: T;
+    error?: Error;
+    isLoading: boolean;
+    reload: () => Promise<void>;
+}
+export declare const useFind: <T extends Parse.Object<Parse.Attributes>>(query: Parse.Query<T>, config?: SWRConfiguration) => UseFindResult<T>;
+export declare const useFirst: <T extends Parse.Object<Parse.Attributes>>(query: Parse.Query<T>, config?: SWRConfiguration) => UseFirstResult<T>;
+export declare function useCount(query: Parse.Query, config?: SWRConfiguration): SWRResponse<any, any>;
+interface UseQueryGetResult<T> {
+    data: T;
+    loading: boolean;
+    error: Error;
+    reload: () => void;
+}
+export declare const useQueryGet: <T>(query: Parse.Query, id: string, config?: SWRConfiguration) => UseQueryGetResult<T>;
+export interface UseParseSearchResult {
+    items: Item[];
+    loading: boolean;
+    error: Error;
+    reload: (data?: any, shouldRevalidate?: boolean) => Promise<SearchResult>;
+    count: number;
+    depths?: number[];
+    hitIds?: string[];
+    rows?: string[];
+    isValidating?: boolean;
+}
+export declare const cloudSearch: (_queryKey: string, queryString: string) => Promise<SearchResult>;
+export declare const useParseSearch: (queryBody: Record<string, unknown>, config?: SWRConfiguration) => UseParseSearchResult;
+export declare const useIQLSearch: <T extends Parse.Object<Parse.Attributes> = Parse.Object<Parse.Attributes>>(iqlParams: IQLParams | null, config?: SWRConfiguration, dispatch?: Dispatch<SetStateAction<any>>) => UseParseSearchResult;

package/dist/lib/usePluginManifest.d.ts

@@ -0,0 +1,33 @@
+import { PluginLoadType } from '@/common/plugin/PluginLoadComponent';
+export interface PluginManifest {
+    app: {
+        id: string;
+        name: string;
+        key: string;
+        env: Record<string, any>[];
+    };
+    key: string;
+    title: string;
+    originalKey: string;
+    route?: string;
+    resource: {
+        key: string;
+        url: string;
+    };
+    loadType?: PluginLoadType;
+    displayScript?: string;
+    icon?: string;
+    createdAt: string;
+    priority?: number;
+    defaultActive?: boolean;
+}
+export declare type UsePluginManifestType = (props: {
+    module: string;
+    workspaceKey?: string | string[];
+    itemType?: string;
+}) => {
+    loading: boolean;
+    manifest: Array<PluginManifest>;
+};
+export declare const VIEW_ACTION_MAX_NUMBER = 4;
+export declare const usePluginManifest: UsePluginManifestType;