@dovetail-v2/refine 0.0.2 → 0.0.3-0.beta-0

package/lib/src/hooks/useEagleForm.js

@@ -0,0 +1,177 @@
+import { useUIKit } from '@cloudtower/eagle';
+import { useForm as useFormCore, useWarnAboutChange, pickNotDeprecated, useResource, } from '@refinedev/core';
+import yaml from 'js-yaml';
+import React, { useRef, useState, useMemo } from 'react';
+import useK8sYamlEditor from 'src/hooks/useK8sYamlEditor';
+import { useSchema } from 'src/hooks/useSchema';
+import { pruneBeforeEdit } from 'src/utils/k8s';
+import { generateYamlBySchema } from 'src/utils/yaml';
+import { useForm as useFormSF } from 'sunflower-antd';
+import { useD2Translation } from '../i18n';
+import { useGlobalStore } from './useGlobalStore';
+const useEagleForm = ({ action, resource, onMutationSuccess: onMutationSuccessProp, onMutationError, submitOnEnter = false, warnWhenUnsavedChanges: warnWhenUnsavedChangesProp, redirect, successNotification, errorNotification, meta, metaData, queryMeta, mutationMeta, liveMode, liveParams, mutationMode, dataProviderName, onLiveEvent, invalidates, undoableTimeout, queryOptions, createMutationOptions, updateMutationOptions, id: idFromProps, overtimeOptions, editorOptions, initialValuesForCreate, } = {}) => {
+    const editor = useRef(null);
+    const isFoldRef = useRef(false);
+    const { t } = useD2Translation();
+    const [enableEditor, setEnableEditor] = useState(false);
+    const [isYamlValid, setIsYamlValid] = useState(true);
+    const [isSchemaValid, setIsSchemaValid] = useState(true);
+    const [editorErrors, setEditorErrors] = useState([]);
+    const [errorResponseBody, setErrorResponseBody] = useState(null);
+    const useResourceResult = useResource();
+    const { globalStore } = useGlobalStore();
+    const kit = useUIKit();
+    const { schema, loading: isLoadingSchema, error: loadSchemaError, fetchSchema, } = useSchema({
+        skip: editorOptions?.isSkipSchema,
+    });
+    const [formAnt] = kit.form.useForm();
+    const formSF = useFormSF({
+        form: formAnt,
+    });
+    const { form } = formSF;
+    const { fold } = useK8sYamlEditor();
+    const useFormCoreResult = useFormCore({
+        onMutationSuccess: onMutationSuccessProp ? onMutationSuccessProp : undefined,
+        onMutationError,
+        redirect,
+        action,
+        resource,
+        successNotification,
+        errorNotification,
+        meta: pickNotDeprecated(meta, metaData),
+        metaData: pickNotDeprecated(meta, metaData),
+        queryMeta,
+        mutationMeta,
+        liveMode,
+        liveParams,
+        mutationMode,
+        dataProviderName,
+        onLiveEvent,
+        invalidates,
+        undoableTimeout,
+        queryOptions,
+        createMutationOptions,
+        updateMutationOptions,
+        id: idFromProps,
+        overtimeOptions,
+    });
+    const { formLoading, onFinish, queryResult, id } = useFormCoreResult;
+    const { warnWhenUnsavedChanges: warnWhenUnsavedChangesRefine, setWarnWhen } = useWarnAboutChange();
+    const warnWhenUnsavedChanges = warnWhenUnsavedChangesProp ?? warnWhenUnsavedChangesRefine;
+    const initialValues = useMemo(() => {
+        const initialValues = queryResult?.data?.data
+            ? globalStore?.restoreItem(queryResult.data.data)
+            : initialValuesForCreate;
+        if (initialValues) {
+            pruneBeforeEdit(initialValues);
+        }
+        return initialValues;
+    }, [queryResult, globalStore, initialValuesForCreate]);
+    // Init the editor after the resource value is fetched
+    React.useEffect(() => {
+        form.resetFields();
+        if (editor.current) {
+            const editorValue = yaml.dump(initialValues);
+            const editorInstance = editor.current.getEditorInstance();
+            editor.current.setEditorValue(editorValue);
+            editor.current.setValue(editorValue);
+            if (queryResult?.data?.data && editorInstance && !isFoldRef.current) {
+                fold(editorInstance);
+                isFoldRef.current = true;
+            }
+        }
+    }, [initialValues, queryResult?.data?.data, id, form, fold]);
+    React.useEffect(() => {
+        const response = useFormCoreResult.mutationResult.error?.response;
+        if (response && !response?.bodyUsed) {
+            response.json?.().then((body) => {
+                setErrorResponseBody(body);
+            });
+        }
+    }, [useFormCoreResult.mutationResult]);
+    const onKeyUp = (event) => {
+        if (submitOnEnter && event.key === 'Enter') {
+            form.submit();
+        }
+    };
+    const onValuesChange = (changeValues) => {
+        if (changeValues && warnWhenUnsavedChanges) {
+            setWarnWhen(true);
+        }
+        return changeValues;
+    };
+    const saveButtonProps = useMemo(() => ({
+        loading: formLoading,
+        onClick: () => {
+            form.submit();
+        },
+    }), [formLoading, form]);
+    const editorProps = useMemo(() => ({
+        ref: editor,
+        defaultValue: schema && editorOptions?.isGenerateAnnotations
+            ? generateYamlBySchema(initialValues || {}, schema)
+            : yaml.dump(initialValues),
+        schema: schema,
+        id: useResourceResult.resource?.name || '',
+        errorMsgs: editorErrors,
+        onValidate(yamlValid, schemaValid) {
+            setIsYamlValid(yamlValid);
+            setIsSchemaValid(schemaValid);
+            if (yamlValid && schemaValid) {
+                setEditorErrors([]);
+            }
+        },
+        onEditorCreate(editor) {
+            if (queryResult?.data?.data && !isFoldRef.current) {
+                fold(editor);
+                isFoldRef.current = true;
+            }
+        },
+    }), [editorErrors, editorOptions, fold, initialValues, queryResult?.data?.data, schema, useResourceResult.resource?.name]);
+    return {
+        form: formSF.form,
+        formProps: {
+            ...formSF.formProps,
+            onFinish: values => {
+                const errors = [
+                    !isYamlValid ? t('dovetail.yaml_format_wrong') : '',
+                    !isSchemaValid ? t('dovetail.yaml_value_wrong') : '',
+                ].filter(error => !!error);
+                if (errors.length) {
+                    setEditorErrors(errors);
+                    return;
+                }
+                const finalValues = editor.current
+                    ? yaml.load(editor.current?.getEditorValue() || '')
+                    : values;
+                return onFinish(finalValues);
+            },
+            onKeyUp,
+            onValuesChange,
+            initialValues,
+        },
+        saveButtonProps,
+        ...useFormCoreResult,
+        editorProps,
+        enableEditor,
+        errorResponseBody,
+        schema,
+        isLoadingSchema,
+        loadSchemaError,
+        fetchSchema,
+        switchEditor() {
+            if (enableEditor && editor.current?.getEditorValue()) {
+                const value = yaml.load(editor.current?.getEditorValue());
+                form?.setFieldsValue(value);
+            }
+            setEnableEditor(!enableEditor);
+        },
+        onFinish: async (values) => {
+            const finalValues = enableEditor
+                ? yaml.load(editor.current?.getEditorValue() || '')
+                : values ?? formSF.form.getFieldsValue(true);
+            return await onFinish(finalValues);
+        },
+    };
+};
+export default useEagleForm;

package/lib/src/hooks/useEagleTable/columns.d.ts

@@ -1,15 +1,19 @@
-import { i18n } from 'i18next';
+import { i18n as I18nType } from 'i18next';
 import { Column } from '../../components/Table';
-import { JobModel, PodModel, ResourceModel } from '../../model';
-import { WorkloadModel } from '../../model/workload-model';
-export declare const CommonSorter: (dataIndex: string[]) => (a: unknown, b: unknown) => 1 | -1 | 0;
-export declare const NameColumnRenderer: <Model extends ResourceModel>(i18n: i18n, resource?: string) => Column<Model>;
-export declare const NameSpaceColumnRenderer: <Model extends ResourceModel>(i18n: i18n) => Column<Model>;
-export declare const PhaseColumnRenderer: <Model extends ResourceModel>(i18n: i18n) => Column<Model>;
-export declare const WorkloadImageColumnRenderer: <Model extends ResourceModel>(i18n: i18n) => Column<Model>;
-export declare const ReplicasColumnRenderer: <Model extends WorkloadModel<import("kubernetes-types/apps/v1").Deployment | import("kubernetes-types/apps/v1").StatefulSet | import("kubernetes-types/batch/v1").Job | import("kubernetes-types/apps/v1").DaemonSet | import("kubernetes-types/batch/v1").CronJob | import("kubernetes-types/core/v1").Pod>>(i18n: i18n) => Column<Model>;
-export declare const AgeColumnRenderer: <Model extends ResourceModel>(i18n: i18n) => Column<Model>;
-export declare const NodeNameColumnRenderer: <Model extends PodModel>(i18n: i18n) => Column<Model>;
-export declare const RestartCountColumnRenderer: <Model extends PodModel>(i18n: i18n) => Column<Model>;
-export declare const CompletionsCountColumnRenderer: <Model extends JobModel>(i18n: i18n) => Column<Model>;
-export declare const DurationColumnRenderer: <Model extends JobModel>(i18n: i18n) => Column<Model>;
+import { JobModel, PodModel, ResourceModel, WorkloadModel, WorkloadBaseModel, CronJobModel, IngressModel } from '../../models';
+export declare const CommonSorter: (dataIndex: string[]) => (a: unknown, b: unknown) => 0 | 1 | -1;
+export declare const NameColumnRenderer: <Model extends ResourceModel<import("k8s-api-provider").Unstructured>>(i18n: I18nType, resource?: string) => Column<Model>;
+export declare const NameSpaceColumnRenderer: <Model extends ResourceModel<import("k8s-api-provider").Unstructured>>(i18n: I18nType) => Column<Model>;
+export declare const StateDisplayColumnRenderer: <Model extends PodModel | WorkloadModel | CronJobModel>(i18n: I18nType) => Column<Model>;
+export declare const WorkloadImageColumnRenderer: <Model extends WorkloadBaseModel>(i18n: I18nType) => Column<Model>;
+export declare const WorkloadRestartsColumnRenderer: <Model extends WorkloadModel>(i18n: I18nType) => Column<Model>;
+export declare const ReplicasColumnRenderer: <Model extends WorkloadModel>(i18n: I18nType) => Column<Model>;
+export declare const AgeColumnRenderer: <Model extends ResourceModel<import("k8s-api-provider").Unstructured>>(i18n: I18nType) => Column<Model>;
+export declare const NodeNameColumnRenderer: <Model extends PodModel>(i18n: I18nType, options?: Partial<Column<Model>> | undefined) => Column<Model>;
+export declare const RestartCountColumnRenderer: <Model extends PodModel>(i18n: I18nType) => Column<Model>;
+export declare const CompletionsCountColumnRenderer: <Model extends JobModel | CronJobModel>(i18n: I18nType) => Column<Model>;
+export declare const DurationColumnRenderer: <Model extends JobModel | CronJobModel>(i18n: I18nType) => Column<Model>;
+export declare const ServiceTypeColumnRenderer: <Model extends ResourceModel<import("k8s-api-provider").Unstructured>>(i18n: I18nType) => Column<Model>;
+export declare const PodWorkloadColumnRenderer: <Model extends PodModel>(i18n: I18nType) => Column<Model>;
+export declare const IngressRulesColumnRenderer: <Model extends IngressModel>(i18n: I18nType) => Column<Model>;
+export declare const IngressDefaultBackendColumnRenderer: <Model extends IngressModel>(i18n: I18nType) => Column<Model>;

package/lib/src/hooks/useEagleTable/columns.js

@@ -0,0 +1,246 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useUIKit } from '@cloudtower/eagle';
+import { useGo, useNavigation, useParsed } from '@refinedev/core';
+import { get } from 'lodash';
+import { ResourceLink } from '../../components';
+import { ImageNames } from '../../components/ImageNames';
+import { IngressRulesComponent } from '../../components/IngressRulesComponent';
+import { ReferenceLink } from '../../components/ReferenceLink';
+import { StateTag } from '../../components/StateTag';
+import Time from '../../components/Time';
+import { elapsedTime } from '../../utils/time';
+const NameLink = props => {
+    const { name, id, resource } = props;
+    const kit = useUIKit();
+    const go = useGo();
+    const navigation = useNavigation();
+    const parsed = useParsed();
+    const resourceName = resource || parsed.resource?.name || '';
+    return (_jsx(kit.button, { type: "link", onClick: () => {
+            go({
+                to: navigation.showUrl(resourceName, ''),
+                query: {
+                    id,
+                },
+                options: {
+                    keepQuery: true,
+                },
+            });
+        }, children: name }));
+};
+export const CommonSorter = (dataIndex) => (a, b) => {
+    const valA = get(a, dataIndex);
+    const valB = get(b, dataIndex);
+    if (valA === valB)
+        return 0;
+    if (valA > valB)
+        return 1;
+    return -1;
+};
+export const NameColumnRenderer = (i18n, resource = '') => {
+    const dataIndex = ['metadata', 'name'];
+    return {
+        key: 'name',
+        display: true,
+        dataIndex,
+        title: i18n.t('dovetail.name'),
+        sortable: true,
+        sorter: CommonSorter(dataIndex),
+        render: (v, record) => {
+            return _jsx(NameLink, { name: v, id: record.id, resource: resource });
+        },
+    };
+};
+export const NameSpaceColumnRenderer = (i18n) => {
+    const dataIndex = ['metadata', 'namespace'];
+    return {
+        key: 'namespace',
+        display: true,
+        dataIndex,
+        title: i18n.t('dovetail.namespace'),
+        sortable: true,
+        sorter: CommonSorter(dataIndex),
+    };
+};
+export const StateDisplayColumnRenderer = (i18n) => {
+    const dataIndex = ['stateDisplay'];
+    return {
+        key: 'stateDisplay',
+        display: true,
+        dataIndex: dataIndex,
+        title: i18n.t('dovetail.state'),
+        sortable: true,
+        sorter: CommonSorter(dataIndex),
+        render: v => _jsx(StateTag, { state: v }),
+    };
+};
+export const WorkloadImageColumnRenderer = (i18n) => {
+    const dataIndex = ['imageNames'];
+    return {
+        key: 'image',
+        display: true,
+        dataIndex,
+        title: i18n.t('dovetail.image'),
+        sortable: true,
+        sorter: CommonSorter(dataIndex),
+        render(value, record) {
+            return _jsx(ImageNames, { value: record.imageNames });
+        },
+    };
+};
+export const WorkloadRestartsColumnRenderer = (i18n) => {
+    const dataIndex = ['restarts'];
+    return {
+        key: 'restarts',
+        display: true,
+        dataIndex,
+        title: i18n.t('dovetail.restarts'),
+        sortable: false,
+    };
+};
+export const ReplicasColumnRenderer = (i18n) => {
+    const dataIndex = ['status', 'replicas'];
+    return {
+        key: 'replicas',
+        display: true,
+        dataIndex,
+        title: i18n.t('dovetail.replicas'),
+        sortable: true,
+        sorter: CommonSorter(dataIndex),
+        render: (_, record) => {
+            return (_jsxs("span", { children: [record.readyReplicas, "/", record.replicas] }));
+        },
+    };
+};
+export const AgeColumnRenderer = (i18n) => {
+    const dataIndex = ['metadata', 'creationTimestamp'];
+    return {
+        key: 'creationTimestamp',
+        display: true,
+        dataIndex,
+        title: i18n.t('dovetail.created_time'),
+        sortable: true,
+        sorter: (a, b) => {
+            const valA = new Date(get(a, dataIndex));
+            const valB = new Date(get(b, dataIndex));
+            if (valA === valB)
+                return 0;
+            if (valA > valB)
+                return 1;
+            return -1;
+        },
+        render: (value) => {
+            return _jsx(Time, { date: new Date(value) });
+        },
+    };
+};
+export const NodeNameColumnRenderer = (i18n, options) => {
+    const dataIndex = ['spec', 'nodeName'];
+    return {
+        key: 'node',
+        display: true,
+        dataIndex,
+        title: i18n.t('dovetail.node_name'),
+        sortable: true,
+        sorter: CommonSorter(dataIndex),
+        ...options,
+    };
+};
+export const RestartCountColumnRenderer = (i18n) => {
+    const dataIndex = ['restartCount'];
+    return {
+        key: 'restartCount',
+        display: true,
+        dataIndex,
+        title: i18n.t('dovetail.restarts'),
+        sortable: true,
+        sorter: CommonSorter(dataIndex),
+    };
+};
+export const CompletionsCountColumnRenderer = (i18n) => {
+    const dataIndex = ['completionsDisplay'];
+    return {
+        key: 'completions',
+        display: true,
+        dataIndex,
+        title: i18n.t('completions'),
+        sortable: true,
+        sorter: CommonSorter(dataIndex),
+    };
+};
+export const DurationColumnRenderer = (i18n) => {
+    const dataIndex = ['duration'];
+    return {
+        key: 'duration',
+        display: true,
+        dataIndex,
+        title: i18n.t('dovetail.duration'),
+        sortable: true,
+        sorter: CommonSorter(dataIndex),
+        render: v => {
+            const i18nMap = {
+                sec: i18n.t('dovetail.sec'),
+                day: i18n.t('dovetail.day'),
+                min: i18n.t('dovetail.min'),
+                hr: i18n.t('dovetail.hr'),
+            };
+            return _jsx("span", { children: elapsedTime(v, i18nMap).label || '-' });
+        },
+    };
+};
+export const ServiceTypeColumnRenderer = (i18n) => {
+    const dataIndex = ['spec', 'type'];
+    return {
+        key: 'type',
+        title: i18n.t('dovetail.type'),
+        display: true,
+        dataIndex,
+        sortable: true,
+        sorter: CommonSorter(dataIndex),
+    };
+};
+export const PodWorkloadColumnRenderer = (i18n) => {
+    const dataIndex = ['metadata', 'ownerReferences'];
+    return {
+        key: 'type',
+        title: i18n.t('dovetail.workload'),
+        display: true,
+        dataIndex,
+        sortable: true,
+        sorter: CommonSorter(dataIndex),
+        render(value, record) {
+            return value.map(o => (_jsx(ReferenceLink, { ownerReference: o, namespace: record.metadata.namespace || 'default' }, o.name)));
+        },
+    };
+};
+export const IngressRulesColumnRenderer = (i18n) => {
+    const dataIndex = ['spec', 'rules'];
+    return {
+        key: 'type',
+        title: i18n.t('dovetail.rule'),
+        display: true,
+        dataIndex,
+        sortable: true,
+        sorter: CommonSorter(dataIndex),
+        render(_, record) {
+            return _jsx(IngressRulesComponent, { ingress: record });
+        },
+    };
+};
+export const IngressDefaultBackendColumnRenderer = (i18n) => {
+    const dataIndex = ['spec', 'defaultBackend'];
+    return {
+        key: 'defaultBackend',
+        display: true,
+        dataIndex,
+        title: i18n.t('dovetail.default_backend'),
+        sortable: true,
+        sorter: CommonSorter(['spec', 'defaultBackend']),
+        render: (defaultBackend, record) => {
+            if (!defaultBackend?.service?.name)
+                return _jsx("span", { children: "-" });
+            const divider = 'Default > ';
+            return (_jsxs("span", { children: [divider, _jsx(ResourceLink, { name: "services", namespace: record.metadata.namespace || 'default', resourceId: defaultBackend.service?.name || '' })] }));
+        },
+    };
+};

package/lib/src/hooks/useEagleTable/index.d.ts

@@ -1,52 +1,2 @@
-import { useTable } from '@refinedev/core';
-import React from 'react';
-import { Column, TableProps } from '../../components/Table';
-import { ResourceModel } from '../../model';
-import { Resource } from '../../types';
-type Params<Raw extends Resource, Model extends ResourceModel> = {
-    useTableParams: Parameters<typeof useTable<Raw>>[0];
-    columns: Column<Model>[];
-    tableProps?: Partial<TableProps<Model>>;
-    formatter: (d: Raw) => Model;
-    Dropdown?: React.FC<{
-        data: Model;
-    }>;
-};
-export declare enum ColumnKeys {
-    age = "age",
-    name = "name",
-    namespace = "namespace",
-    phase = "phase",
-    replicas = "replicas",
-    deploymentImage = "deploymentImage",
-    podImage = "podImage"
-}
-export declare const useEagleTable: <Raw extends Resource, Model extends ResourceModel>(params: Params<Raw, Model>) => {
-    tableQueryResult: import("@tanstack/query-core").QueryObserverResult<import("@refinedev/core").GetListResponse<Raw>, import("@refinedev/core").HttpError>;
-    sorter: import("@refinedev/core").CrudSorting;
-    sorters: import("@refinedev/core").CrudSorting;
-    setSorter: (sorter: import("@refinedev/core").CrudSorting) => void;
-    setSorters: (sorter: import("@refinedev/core").CrudSorting) => void;
-    filters: import("@refinedev/core").CrudFilters;
-    setFilters: ((filters: import("@refinedev/core").CrudFilters, behavior?: ("replace" | "merge") | undefined) => void) & ((setter: (prevFilters: import("@refinedev/core").CrudFilters) => import("@refinedev/core").CrudFilters) => void);
-    createLinkForSyncWithLocation: (params: {
-        pagination: {
-            current?: number | undefined;
-            pageSize?: number | undefined;
-        };
-        sorter?: import("@refinedev/core").CrudSorting | undefined;
-        sorters: import("@refinedev/core").CrudSorting;
-        filters: import("@refinedev/core").CrudFilters;
-    }) => string;
-    current: number;
-    setCurrent: (value: React.SetStateAction<number>) => void;
-    pageSize: number;
-    setPageSize: (value: React.SetStateAction<number>) => void;
-    pageCount: number;
-    overtime: {
-        elapsedTime?: number | undefined;
-    };
-    tableProps: TableProps<Model>;
-    selectedKeys: string[];
-};
-export {};
+export * from './columns';
+export * from './useEagleTable';

package/lib/src/hooks/useEagleTable/index.js

@@ -0,0 +1,2 @@
+export * from './columns';
+export * from './useEagleTable';

package/lib/src/hooks/useEagleTable/useEagleTable.d.ts

@@ -0,0 +1,51 @@
+import { useTable } from '@refinedev/core';
+import React from 'react';
+import { Column, TableProps } from '../../components/Table';
+import { ResourceModel } from '../../models';
+type Params<Model extends ResourceModel> = {
+    useTableParams: Parameters<typeof useTable<Model>>[0];
+    columns: Column<Model>[];
+    tableProps?: Partial<TableProps<Model>>;
+    formatter?: (d: Model) => Model;
+    Dropdown?: React.FC<{
+        record: Model;
+    }>;
+};
+export declare enum ColumnKeys {
+    age = "age",
+    name = "name",
+    namespace = "namespace",
+    phase = "phase",
+    replicas = "replicas",
+    deploymentImage = "deploymentImage",
+    podImage = "podImage"
+}
+export declare const useEagleTable: <Model extends ResourceModel<import("k8s-api-provider").Unstructured>>(params: Params<Model>) => {
+    tableQueryResult: import("@tanstack/query-core").QueryObserverResult<import("@refinedev/core").GetListResponse<Model>, import("@refinedev/core").HttpError>;
+    sorter: import("@refinedev/core").CrudSorting;
+    sorters: import("@refinedev/core").CrudSorting;
+    setSorter: (sorter: import("@refinedev/core").CrudSorting) => void;
+    setSorters: (sorter: import("@refinedev/core").CrudSorting) => void;
+    filters: import("@refinedev/core").CrudFilters;
+    setFilters: ((filters: import("@refinedev/core").CrudFilters, behavior?: ("replace" | "merge") | undefined) => void) & ((setter: (prevFilters: import("@refinedev/core").CrudFilters) => import("@refinedev/core").CrudFilters) => void);
+    createLinkForSyncWithLocation: (params: {
+        pagination: {
+            current?: number | undefined;
+            pageSize?: number | undefined;
+        };
+        sorter?: import("@refinedev/core").CrudSorting | undefined;
+        sorters: import("@refinedev/core").CrudSorting;
+        filters: import("@refinedev/core").CrudFilters;
+    }) => string;
+    current: number;
+    setCurrent: (value: React.SetStateAction<number>) => void;
+    pageSize: number;
+    setPageSize: (value: React.SetStateAction<number>) => void;
+    pageCount: number;
+    overtime: {
+        elapsedTime?: number | undefined;
+    };
+    tableProps: TableProps<Model>;
+    selectedKeys: string[];
+};
+export {};

package/lib/src/hooks/useEagleTable/useEagleTable.js

@@ -0,0 +1,63 @@
+import { useTable, useResource } from '@refinedev/core';
+import { merge } from 'lodash-es';
+import { useCallback, useMemo, useState } from 'react';
+import K8sDropdown from '../../components/K8sDropdown';
+import { useNamespacesFilter, ALL_NS } from '../../components/NamespacesFilter';
+export var ColumnKeys;
+(function (ColumnKeys) {
+    ColumnKeys["age"] = "age";
+    ColumnKeys["name"] = "name";
+    ColumnKeys["namespace"] = "namespace";
+    ColumnKeys["phase"] = "phase";
+    ColumnKeys["replicas"] = "replicas";
+    ColumnKeys["deploymentImage"] = "deploymentImage";
+    ColumnKeys["podImage"] = "podImage";
+})(ColumnKeys || (ColumnKeys = {}));
+export const useEagleTable = (params) => {
+    const { columns, tableProps, formatter, Dropdown = K8sDropdown } = params;
+    const [selectedKeys, setSelectedKeys] = useState([]);
+    const [currentPage, setCurrentPage] = useState(tableProps?.currentPage || 1);
+    const { resource } = useResource();
+    const { value: nsFilter } = useNamespacesFilter();
+    const useTableParams = useMemo(() => {
+        // TODO: check whether resource can be namespaced
+        const mergedParams = merge(params.useTableParams, {
+            pagination: {
+                mode: 'off',
+            },
+            filters: {
+                permanent: [
+                    {
+                        field: 'metadata.namespace',
+                        operator: 'eq',
+                        value: nsFilter === ALL_NS ? null : nsFilter,
+                    },
+                ],
+            },
+        });
+        return mergedParams;
+    }, [params.useTableParams, nsFilter]);
+    const table = useTable(useTableParams);
+    const onPageChange = useCallback((page) => {
+        setCurrentPage(page);
+    }, [setCurrentPage]);
+    const data = table.tableQueryResult.data?.data;
+    const finalDataSource = formatter ? data?.map(formatter) : data;
+    const finalProps = {
+        tableKey: resource?.name || 'table',
+        loading: table.tableQueryResult.isLoading,
+        data: finalDataSource || [],
+        columns,
+        refetch: () => null,
+        error: false,
+        rowKey: 'id',
+        currentPage,
+        currentSize: tableProps?.currentSize || 5,
+        onPageChange: onPageChange,
+        onSelect: keys => {
+            setSelectedKeys(keys);
+        },
+        RowMenu: Dropdown
+    };
+    return { tableProps: finalProps, selectedKeys, ...table };
+};

package/lib/src/hooks/useEdit.js

@@ -0,0 +1,19 @@
+import { useGo, useNavigation, useParsed } from '@refinedev/core';
+import { useCallback } from 'react';
+export function useEdit() {
+    const { resource } = useParsed();
+    const go = useGo();
+    const navigation = useNavigation();
+    const edit = useCallback((id) => {
+        go({
+            to: navigation.editUrl(resource?.name || '', id),
+            query: {
+                id,
+            },
+            options: {
+                keepQuery: true,
+            },
+        });
+    }, [go, resource?.name]);
+    return { edit };
+}

package/lib/src/hooks/useGlobalStore.d.ts

@@ -0,0 +1,3 @@
+export declare const useGlobalStore: () => {
+    globalStore?: import("k8s-api-provider").GlobalStore | undefined;
+};

package/lib/src/hooks/useGlobalStore.js

@@ -0,0 +1,5 @@
+import { useContext } from 'react';
+import GlobalStoreContext from '../contexts/global-store';
+export const useGlobalStore = () => {
+    return useContext(GlobalStoreContext);
+};

package/lib/src/hooks/useK8sYamlEditor.d.ts

@@ -0,0 +1,5 @@
+import * as monaco from 'monaco-editor';
+declare function useK8sYamlEditor(): {
+    fold: (editor: monaco.editor.IStandaloneCodeEditor) => Promise<void>;
+};
+export default useK8sYamlEditor;