@ericbutera/kaleido 0.1.12 → 0.2.0

package/dist/kaleido.d.ts

@@ -0,0 +1,44 @@
+import { AuthApiClient, User } from './auth';
+type OpenApiClientLike = {
+    useQuery: (...args: any[]) => any;
+    useMutation: (...args: any[]) => any;
+};
+type QueryClientLike = {
+    invalidateQueries: (args: {
+        queryKey: any[];
+    }) => unknown;
+    refetchQueries: (args: {
+        queryKey: any[];
+    }) => unknown;
+    clear: () => unknown;
+};
+export type KaleidoToggleConfig = {
+    auth?: boolean;
+    featureFlags?: boolean;
+    tasks?: boolean;
+    adminUsers?: boolean;
+};
+export type KaleidoRuntimeConfig = {
+    api: OpenApiClientLike;
+    useQueryClient: () => QueryClientLike;
+    toast?: {
+        success?: (message: string) => unknown;
+    };
+    mapCurrentUser?: (rawUser: any) => User | null;
+};
+export type KaleidoAppConfig = KaleidoRuntimeConfig & KaleidoToggleConfig;
+declare class KaleidoApp {
+    private authClient;
+    configure(config: KaleidoAppConfig): void;
+    createAuthApiClient(): AuthApiClient;
+    useAuth(): {
+        readonly user: User | null;
+        readonly isLoading: boolean;
+        readonly signIn: (email: string, password: string) => Promise<void>;
+        readonly signUp: (email: string, password: string, name?: string) => Promise<void>;
+        readonly signOut: () => Promise<void>;
+        readonly completeOAuthLogin: (_userData?: unknown) => Promise<boolean>;
+    };
+}
+declare const kaleido: KaleidoApp;
+export default kaleido;

package/dist/lib/apiHelpers.d.ts

@@ -0,0 +1,15 @@
+import { QueryClient } from '@tanstack/react-query';
+import { default as createFetchClientOrig } from 'openapi-fetch';
+export type ApiError = {
+    status: "error";
+    message?: string;
+    errors?: Record<string, string[]>;
+};
+export declare function handleApiError(err: any): ApiError;
+export declare function newQueryClient(): QueryClient;
+export declare const fetchWithCredentials: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export declare function createFetchClient(opts: {
+    baseUrl: string;
+    fetch?: typeof fetch;
+}): import('openapi-fetch').Client<{}, `${string}/${string}`>;
+export declare function createClient<T extends {}>(fetchClient: ReturnType<typeof createFetchClientOrig>): import('openapi-react-query').OpenapiQueryClient<T, `${string}/${string}`>;

package/dist/openapi/createKaleidoOpenApiAdapters.d.ts

@@ -0,0 +1,44 @@
+import { KaleidoFeatureAdapters } from '../configureKaleido';
+import { User } from '../users/useUsers';
+type OpenApiClientLike = {
+    useQuery: (...args: any[]) => any;
+    useMutation: (...args: any[]) => any;
+};
+type QueryClientLike = {
+    invalidateQueries: (args: {
+        queryKey: any[];
+    }) => unknown;
+};
+export interface FeatureFlagsOpenApiMapping {
+    listPath: string;
+    adminListPath: string;
+    updatePath: string;
+    extractListData?: (responseData: any) => any[];
+}
+export interface TasksOpenApiMapping {
+    listPath: string;
+    detailPath: string;
+}
+export interface UsersOpenApiMapping {
+    listPath: string;
+    detailPath: string;
+    createPath: string;
+    updatePath: string;
+    resendForgotPasswordPath: string;
+    resendConfirmationPath: string;
+    disablePath: string;
+    extractListData?: (responseData: any) => User[];
+    extractDetailData?: (responseData: any) => User | null;
+}
+export interface CreateKaleidoOpenApiAdaptersOptions {
+    api: OpenApiClientLike;
+    useQueryClient: () => QueryClientLike;
+    toast?: {
+        success?: (message: string) => unknown;
+    };
+    featureFlags?: Partial<FeatureFlagsOpenApiMapping>;
+    tasks?: Partial<TasksOpenApiMapping>;
+    users?: Partial<UsersOpenApiMapping>;
+}
+export declare function createKaleidoOpenApiAdapters(options: CreateKaleidoOpenApiAdaptersOptions): Pick<KaleidoFeatureAdapters, "tasks" | "featureFlags" | "users">;
+export {};

package/dist/openapi/createKaleidoOpenApiAuthClient.d.ts

@@ -0,0 +1,35 @@
+import { AuthApiClient, User } from '../auth/lib/types';
+type OpenApiClientLike = {
+    useQuery: (...args: any[]) => any;
+    useMutation: (...args: any[]) => any;
+};
+type QueryClientLike = {
+    invalidateQueries: (args: {
+        queryKey: any[];
+    }) => unknown;
+    refetchQueries: (args: {
+        queryKey: any[];
+    }) => unknown;
+    clear: () => unknown;
+};
+export interface AuthOpenApiMapping {
+    currentPath: string;
+    loginPath: string;
+    registerPath: string;
+    forgotPath: string;
+    resetPath: string;
+    verifyPath: string;
+    resendConfirmationPath: string;
+    logoutPath: string;
+    refreshPath: string;
+}
+export interface CreateKaleidoOpenApiAuthClientOptions {
+    api: OpenApiClientLike;
+    useQueryClient: () => QueryClientLike;
+    paths?: Partial<AuthOpenApiMapping>;
+    currentUserQueryKey?: any[];
+    sellerMeQueryKey?: any[];
+    mapCurrentUser?: (rawUser: any) => User | null;
+}
+export declare function createKaleidoOpenApiAuthClient(options: CreateKaleidoOpenApiAuthClientOptions): AuthApiClient;
+export {};

package/dist/openapi/index.d.ts

@@ -0,0 +1,2 @@
+export { createKaleidoOpenApiAdapters, type CreateKaleidoOpenApiAdaptersOptions, type FeatureFlagsOpenApiMapping, type TasksOpenApiMapping, } from './createKaleidoOpenApiAdapters';
+export { createKaleidoOpenApiAuthClient, type AuthOpenApiMapping, type CreateKaleidoOpenApiAuthClientOptions, } from './createKaleidoOpenApiAuthClient';

package/dist/tasks/index.d.ts

@@ -0,0 +1,2 @@
+export { configureTasks, useTask, useTasks } from './useTasks';
+export type { Task, TasksConfig, UseTasksResult } from './useTasks';

package/dist/tasks/useTasks.d.ts

@@ -0,0 +1,27 @@
+import { PaginatedQueryResult } from '../lib/paginatedQuery';
+export interface Task {
+    id: string | number;
+    task_type?: string;
+    status?: "pending" | "running" | "completed" | "failed" | string;
+    attempts?: number;
+    max_attempts?: number;
+    error?: string | null;
+    created_at?: string;
+    [key: string]: any;
+}
+export interface UseTasksResult extends PaginatedQueryResult<Task> {
+    refetch?: () => void;
+}
+export interface TasksConfig {
+    useTasks: (params?: any) => UseTasksResult;
+    useTask?: (id: string | null) => {
+        data: Task | null;
+        isLoading: boolean;
+    };
+}
+export declare function configureTasks(cfg: TasksConfig): void;
+export declare function useTasks(params?: any): UseTasksResult;
+export declare function useTask(id: string | null): {
+    data: Task | null;
+    isLoading: boolean;
+};

package/dist/users/index.d.ts

@@ -0,0 +1,2 @@
+export { configureUsers, useCreateUser, useDisableUserAccount, useResendConfirmationEmail, useResendForgotPassword, useUpdateUser, useUser, useUsers, } from './useUsers';
+export type { CreateUserInput, DisableUserInput, UpdateUserInput, User, UserActionInput, UserFormData, UsersConfig, UsersMutation, UseUsersResult, } from './useUsers';

package/dist/users/useUsers.d.ts

@@ -0,0 +1,74 @@
+import { PaginatedQueryResult } from '../lib/paginatedQuery';
+export interface User {
+    id: string | number;
+    email?: string;
+    name?: string;
+    is_admin?: boolean;
+    verified?: boolean;
+    email_verified_at?: string | null;
+    disabled?: boolean;
+    is_disabled?: boolean;
+    active?: boolean;
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: any;
+}
+export interface UseUsersResult extends PaginatedQueryResult<User> {
+    refetch?: () => void;
+}
+export type UsersMutation<TInput = any, TResult = any> = {
+    mutateAsync: (input: TInput) => Promise<TResult>;
+    isPending: boolean;
+};
+export interface CreateUserInput {
+    email: string;
+    name?: string;
+    password?: string;
+    is_admin?: boolean;
+    [key: string]: any;
+}
+export type UserFormData = Omit<CreateUserInput, "is_admin"> & {
+    is_admin: boolean;
+};
+export interface UpdateUserInput {
+    email?: string;
+    name?: string;
+    is_admin?: boolean;
+    [key: string]: any;
+}
+export interface UserActionInput {
+    id: string;
+    [key: string]: any;
+}
+export interface DisableUserInput extends UserActionInput {
+    disabled?: boolean;
+}
+export interface UsersConfig {
+    useUsers: (params?: any) => UseUsersResult;
+    useUser?: (id: string | null) => {
+        data: User | null;
+        isLoading: boolean;
+    };
+    useCreateUser: () => UsersMutation<CreateUserInput, any>;
+    useUpdateUser: () => UsersMutation<{
+        id: string;
+        data: UpdateUserInput;
+    }, any>;
+    useResendForgotPassword: () => UsersMutation<UserActionInput, any>;
+    useResendConfirmationEmail: () => UsersMutation<UserActionInput, any>;
+    useDisableUserAccount: () => UsersMutation<DisableUserInput, any>;
+}
+export declare function configureUsers(cfg: UsersConfig): void;
+export declare function useUsers(params?: any): UseUsersResult;
+export declare function useUser(id: string | null): {
+    data: User | null;
+    isLoading: boolean;
+};
+export declare function useCreateUser(): UsersMutation<CreateUserInput, any>;
+export declare function useUpdateUser(): UsersMutation<{
+    id: string;
+    data: UpdateUserInput;
+}, any>;
+export declare function useResendForgotPassword(): UsersMutation<UserActionInput, any>;
+export declare function useResendConfirmationEmail(): UsersMutation<UserActionInput, any>;
+export declare function useDisableUserAccount(): UsersMutation<DisableUserInput, any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericbutera/kaleido",
-  "version": "0.1.12",
+  "version": "0.2.0",
   "description": "Shared UI components and framework utilities for Kaleido",
   "type": "module",
   "main": "./dist/index.js",
@@ -28,6 +28,8 @@
   },
   "dependencies": {
     "@fortawesome/free-brands-svg-icons": "^7.2.0",
+    "openapi-fetch": "^0.17.0",
+    "openapi-react-query": "^0.5.4",
     "@types/lodash-es": "^4.17.12",
     "lodash-es": "^4.17.23",
     "qrcode.react": "^4.2.0",

package/dist/components/admin/tasks/List.d.ts

@@ -1 +0,0 @@
-export { default } from '../../tasks/List';

package/dist/components/admin/tasks/Modal.d.ts

@@ -1 +0,0 @@
-export { default } from '../../tasks/Modal';

package/dist/components/tasks/Modal.d.ts

@@ -1,7 +0,0 @@
-import { components } from '../../lib/openapi/react-query/api';
-interface ModalProps {
-    selectedTask: components["schemas"]["AdminTaskResponse"] | null;
-    setSelectedTask: (task: components["schemas"]["AdminTaskResponse"] | null) => void;
-}
-export default function Modal({ selectedTask, setSelectedTask }: ModalProps): import("react/jsx-runtime").JSX.Element | null;
-export {};

package/dist/lib/openapi/react-query/api.d.ts

@@ -1 +0,0 @@
-export type components = Record<string, any>;

package/dist/lib/queries.d.ts

@@ -1,6 +0,0 @@
-import { PaginatedQueryResult } from './paginatedQuery';
-export declare function useAdminTasks(_params: any): PaginatedQueryResult<any>;
-export declare function useAdminTask(_id: string | null): {
-    data: null;
-    isLoading: boolean;
-};

package/dist/lib/tasksApi.d.ts

@@ -1,13 +0,0 @@
-import { PaginatedQueryResult } from './paginatedQuery';
-export interface Task {
-    id: string | number;
-    [key: string]: any;
-}
-export interface TasksApiClient {
-    useList: (params: any) => PaginatedQueryResult<Task>;
-    useGet: (id: string | null) => {
-        data: Task | null;
-        isLoading: boolean;
-    };
-}
-export declare function useTasksApi(): TasksApiClient;

package/dist/pages/index.d.ts

@@ -1,2 +0,0 @@
-export { default as AdminFeatureFlags } from './admin/FeatureFlags';
-export { default as AdminTasks } from './admin/Tasks';