@fmfi-uk-1-ain-412/structure-explorer 0.0.8 → 0.1.0

package/dist/App.d.ts

@@ -1,2 +1,5 @@
-declare function App(): import("react/jsx-runtime").JSX.Element;
+interface AppProps {
+    viewOnlyMode?: boolean;
+}
+declare function App({ viewOnlyMode }: AppProps): import("react/jsx-runtime").JSX.Element;
 export default App;

package/dist/app/store.d.ts

@@ -1,16 +1,59 @@
-export declare const createStore: () => import('@reduxjs/toolkit').EnhancedStore<{
+import { Action, Middleware, ThunkAction } from '@reduxjs/toolkit';
+declare const rootReducer: {
+    formulas: import('redux').Reducer<import('../features/formulas/formulasSlice').FormulasState>;
+    language: import('redux').Reducer<import('../features/language/languageSlice').LanguageState>;
+    structure: import('redux').Reducer<import('../features/structure/structureSlice').StructureState>;
+    variables: import('redux').Reducer<import('../features/variables/variablesSlice').VariablesState>;
+    teacherMode: import('redux').Reducer<import('../features/teacherMode/teacherModeslice').TeacherModeState>;
+    graphView: import('redux').Reducer<import('../features/graphView/graphs/graphSlice').GraphManagerState>;
+    textView: import('redux').Reducer<import('../features/textView/textViewSlice').TextViewState>;
+    databaseView: import('redux').Reducer<import('../features/databaseView/databaseViewSlice.ts').DatabaseViewState>;
+    editorToolbar: import('redux').Reducer<import('../features/editorToolbar/editorToolbarSlice').EditorToolbarState>;
+    errorAlert: import('redux').Reducer<import('../features/errorAlert/errorAlertSlice.ts').ErrorState>;
+};
+declare const undoReducer: import('redux').Reducer<import('redux-undo').StateWithHistory<{
     formulas: import('../features/formulas/formulasSlice').FormulasState;
     language: import('../features/language/languageSlice').LanguageState;
     structure: import('../features/structure/structureSlice').StructureState;
     variables: import('../features/variables/variablesSlice').VariablesState;
-}, import('redux').UnknownAction, import('@reduxjs/toolkit').Tuple<[import('redux').StoreEnhancer<{
-    dispatch: import('redux-thunk').ThunkDispatch<{
+    teacherMode: import('../features/teacherMode/teacherModeslice').TeacherModeState;
+    graphView: import('../features/graphView/graphs/graphSlice').GraphManagerState;
+    textView: import('../features/textView/textViewSlice').TextViewState;
+    databaseView: import('../features/databaseView/databaseViewSlice.ts').DatabaseViewState;
+    editorToolbar: import('../features/editorToolbar/editorToolbarSlice').EditorToolbarState;
+    errorAlert: import('../features/errorAlert/errorAlertSlice.ts').ErrorState;
+}>, import('redux').UnknownAction>;
+export declare const createStore: (extraMiddleware?: Middleware) => import('@reduxjs/toolkit').EnhancedStore<import('redux-undo').StateWithHistory<{
+    formulas: import('../features/formulas/formulasSlice').FormulasState;
+    language: import('../features/language/languageSlice').LanguageState;
+    structure: import('../features/structure/structureSlice').StructureState;
+    variables: import('../features/variables/variablesSlice').VariablesState;
+    teacherMode: import('../features/teacherMode/teacherModeslice').TeacherModeState;
+    graphView: import('../features/graphView/graphs/graphSlice').GraphManagerState;
+    textView: import('../features/textView/textViewSlice').TextViewState;
+    databaseView: import('../features/databaseView/databaseViewSlice.ts').DatabaseViewState;
+    editorToolbar: import('../features/editorToolbar/editorToolbarSlice').EditorToolbarState;
+    errorAlert: import('../features/errorAlert/errorAlertSlice.ts').ErrorState;
+}>, import('redux').UnknownAction, import('@reduxjs/toolkit').Tuple<[import('redux').StoreEnhancer<{
+    dispatch: ((action: Action<"listenerMiddleware/add">) => import('@reduxjs/toolkit').UnsubscribeListener) & import('redux-thunk').ThunkDispatch<import('redux-undo').StateWithHistory<{
         formulas: import('../features/formulas/formulasSlice').FormulasState;
         language: import('../features/language/languageSlice').LanguageState;
         structure: import('../features/structure/structureSlice').StructureState;
         variables: import('../features/variables/variablesSlice').VariablesState;
-    }, undefined, import('redux').UnknownAction>;
+        teacherMode: import('../features/teacherMode/teacherModeslice').TeacherModeState;
+        graphView: import('../features/graphView/graphs/graphSlice').GraphManagerState;
+        textView: import('../features/textView/textViewSlice').TextViewState;
+        databaseView: import('../features/databaseView/databaseViewSlice.ts').DatabaseViewState;
+        editorToolbar: import('../features/editorToolbar/editorToolbarSlice').EditorToolbarState;
+        errorAlert: import('../features/errorAlert/errorAlertSlice.ts').ErrorState;
+    }>, undefined, import('redux').UnknownAction>;
 }>, import('redux').StoreEnhancer]>>;
 export type AppStore = ReturnType<typeof createStore>;
-export type RootState = ReturnType<AppStore["getState"]>;
 export type AppDispatch = AppStore["dispatch"];
+export type AppThunk<ThunkReturnType = void> = ThunkAction<ThunkReturnType, RootState, unknown, Action>;
+export type RootState = ReturnType<typeof undoReducer>;
+export type RootStateWithoutHistory = {
+    [K in keyof typeof rootReducer]: ReturnType<(typeof rootReducer)[K]>;
+};
+export type RootReducerEntryName = keyof RootStateWithoutHistory;
+export {};

package/dist/common/errors.d.ts

@@ -0,0 +1,18 @@
+import { Location } from '@fmfi-uk-1-ain-412/js-fol-parser';
+export interface BaseError {
+    kind: string;
+    message: string;
+}
+export interface SyntaxError extends BaseError {
+    kind: "syntax";
+    location?: Location;
+}
+export interface ValidationError extends BaseError {
+    kind: "validation";
+}
+export interface SemanticError extends BaseError {
+    kind: "semantic";
+}
+export declare const createValidationError: (message: string) => ValidationError;
+export declare const createSemanticError: (message: string) => SemanticError;
+export type InterpretationError = SyntaxError | ValidationError | SemanticError;

package/dist/common/logging.d.ts

@@ -0,0 +1,6 @@
+export declare const dev: {
+    log: (...args: unknown[]) => false | void;
+    warn: (...args: unknown[]) => false | void;
+    time: (label: string) => false | void;
+    timeEnd: (label: string) => false | void;
+};

package/dist/common/redux.d.ts

@@ -0,0 +1,31 @@
+import { Action, PayloadAction } from '@reduxjs/toolkit';
+import { ValidationError } from './errors';
+export interface LockableValue<T> {
+    locked: boolean;
+    value: T;
+}
+export type Validated<T> = {
+    parsed: T;
+    error?: ValidationError;
+};
+export declare const prepareWithSourceMeta: <P>(payload: P, meta?: {
+    source?: string;
+}) => {
+    payload: P;
+    meta: {
+        source?: string;
+    };
+};
+export declare const prepareWithListenerIgnoreMeta: <P>(payload: P, meta?: {
+    ignore?: boolean;
+}) => {
+    payload: P;
+    meta: {
+        ignore?: boolean;
+    };
+};
+export type PayloadActionListenerIgnore<P = void> = PayloadAction<P, string, {
+    ignore?: boolean;
+}>;
+export declare const listenerShouldIgnore: (action: Action) => boolean;
+export declare const fallbackToEmptyArray: <T>(array: T[] | undefined) => T[];

package/dist/common/validation.d.ts

@@ -0,0 +1,5 @@
+import { default as z } from 'zod';
+export declare const lockable: <T extends z.ZodType>(value: T) => z.ZodObject<{
+    value: T;
+    locked: z.ZodBoolean;
+}, z.core.$strip>;

package/dist/components_helper/ComponentCard/ComponentCard.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface ComponentCardProps {
+    heading: React.ReactNode;
+    help?: React.ReactNode;
+    right?: React.ReactNode;
+    children?: React.ReactNode;
+    className?: string;
+}
+export default function ComponentCard({ heading, help, right, children, className, }: ComponentCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components_helper/ControlButtons/ControlButtons.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+export type ControlButton<T> = {
+    text: React.ReactNode;
+    value: T;
+} | {
+    text: React.ReactNode;
+    value: T[];
+    dropDown: {
+        text: React.ReactNode;
+        value: T;
+    }[];
+};
+export interface ControlButtonsProps<T> {
+    id: string;
+    buttons: ControlButton<T>[];
+    selected: T;
+    onSelected: (selected: T) => void;
+    teacherMode?: boolean;
+    locked?: boolean;
+    locker?: () => void;
+    disabled?: boolean;
+}
+export default function ControlButtons<T extends string | number>({ id, buttons, selected, onSelected, teacherMode, locked, locker, disabled, }: ControlButtonsProps<T>): import("react/jsx-runtime").JSX.Element | null;

package/dist/components_helper/ControlButtons/omitControlButtons.d.ts

@@ -0,0 +1,3 @@
+import { EditorType } from '../../features/structure/InterpretationEditor';
+import { ControlButton } from './ControlButtons';
+export declare const omitControlButtons: (controlButtons: ControlButton<EditorType>[], omit: EditorType[]) => ControlButton<EditorType>[];

package/dist/components_helper/CustomIcons.d.ts

@@ -0,0 +1,5 @@
+import { SVGProps } from 'react';
+export interface CustomIconProps extends SVGProps<SVGSVGElement> {
+    size?: SVGProps<SVGSVGElement>["height"];
+}
+export declare function ForwardSlashIcon(props: CustomIconProps): import("react/jsx-runtime").JSX.Element;

package/dist/components_helper/EmptyPlaceholder/EmptyPlaceholder.d.ts

@@ -0,0 +1,4 @@
+export interface EmptyPlaceholderProps {
+    message: string;
+}
+export default function EmptyPlaceholder({ message }: EmptyPlaceholderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components_helper/ErrorFeedback.d.ts

@@ -1,7 +1,8 @@
 import { SyntaxError } from '@fmfi-uk-1-ain-412/js-fol-parser';
-interface Props {
-    error: SyntaxError | Error | undefined;
+import { InterpretationError } from '../common/errors';
+interface ErrorFeedbackProps {
+    error: SyntaxError | Error | InterpretationError | undefined;
     text: string;
 }
-export default function ErrorFeedback({ error, text }: Props): import("react/jsx-runtime").JSX.Element | null;
+export default function ErrorFeedback({ error, text }: ErrorFeedbackProps): import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/components_helper/Header.d.ts

@@ -0,0 +1 @@
+export default function Header(): import("react/jsx-runtime").JSX.Element;

package/dist/components_helper/InputGroupTitle.d.ts

@@ -1,14 +1,19 @@
 import { ChangeEvent, ReactNode } from 'react';
-import { SyntaxError } from '@fmfi-uk-1-ain-412/js-fol-parser';
+import { InterpretationError } from '../common/errors';
 interface Props {
     label: string;
     id: string;
     prefix: ReactNode;
     suffix: ReactNode;
+    controlButtons?: ReactNode;
     placeholder: string;
+    disabledOverride?: boolean;
     text: string;
     onChange(event: ChangeEvent<HTMLInputElement>): void;
-    error?: Error | SyntaxError;
+    locker: () => void;
+    lockChecker: boolean | undefined;
+    error?: InterpretationError;
+    createHistoryOnBlur?: boolean;
 }
-export default function InputGroupTitle({ label, id, prefix, suffix, placeholder, text, onChange, error, }: Props): import("react/jsx-runtime").JSX.Element;
+export default function InputGroupTitle({ label, id, prefix, suffix, controlButtons, placeholder, disabledOverride, text, onChange, locker, lockChecker, error, createHistoryOnBlur, }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components_helper/LockButton.d.ts

@@ -0,0 +1,7 @@
+import { ButtonProps } from 'react-bootstrap';
+interface LockButtonProps extends Omit<ButtonProps, "onClick"> {
+    locked: boolean;
+    locker: () => void;
+}
+export default function LockButton({ locker, locked, ...props }: LockButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components_helper/RelevantPredicatesIndicator/RelevantPredicatesIndicator.d.ts

@@ -0,0 +1,7 @@
+interface RelevantPredicatesIndicatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    predicateToColorMap: Map<string, string>;
+    previewed?: string[];
+    size?: "md" | "sm";
+}
+export declare function RelevantPredicatesIndicator({ predicateToColorMap, size, previewed, ...props }: RelevantPredicatesIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/databaseView/DatabaseView.d.ts

@@ -0,0 +1,9 @@
+import { TupleType } from '../structure/structureSlice';
+interface DatabaseViewProps {
+    tupleName: string;
+    tupleArity: number;
+    tupleType: TupleType;
+    locked: boolean;
+}
+export default function DatabaseView({ tupleName, tupleArity, tupleType, locked, }: DatabaseViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/databaseView/databaseViewSlice.d.ts

@@ -0,0 +1,75 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { StructureState, TupleType } from '../structure/structureSlice';
+import { AppThunk, RootState } from '../../app/store';
+export interface DatabaseViewEntry {
+    type: TupleType;
+    domainTuple: string[][];
+}
+export type DatabaseViewState = Record<string, DatabaseViewEntry>;
+type ValueChangedPayload = {
+    tupleName: string;
+    type: TupleType;
+    domainTuple: string[][];
+};
+export declare const databaseViewSlice: import('@reduxjs/toolkit').Slice<DatabaseViewState, {
+    valueChanged(state: import('immer').WritableDraft<DatabaseViewState>, action: PayloadAction<ValueChangedPayload>): void;
+    syncDatabaseView(state: import('immer').WritableDraft<DatabaseViewState>, action: PayloadAction<{
+        structure: StructureState;
+    }>): void;
+}, "databaseView", "databaseView", import('@reduxjs/toolkit').SliceSelectors<DatabaseViewState>>;
+export declare const valueChanged: import('@reduxjs/toolkit').ActionCreatorWithPayload<ValueChangedPayload, "databaseView/valueChanged">, syncDatabaseView: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+    structure: StructureState;
+}, "databaseView/syncDatabaseView">;
+export declare const selectDatabaseViewValues: ((state: import('redux-undo').StateWithHistory<{
+    formulas: import('../formulas/formulasSlice').FormulasState;
+    language: import('../language/languageSlice').LanguageState;
+    structure: StructureState;
+    variables: import('../variables/variablesSlice').VariablesState;
+    teacherMode: import('../teacherMode/teacherModeslice').TeacherModeState;
+    graphView: import('../graphView/graphs/graphSlice').GraphManagerState;
+    textView: import('../textView/textViewSlice').TextViewState;
+    databaseView: DatabaseViewState;
+    editorToolbar: import('../editorToolbar/editorToolbarSlice').EditorToolbarState;
+    errorAlert: import('../errorAlert/errorAlertSlice').ErrorState;
+}>, __: string, ___: TupleType, arity: number) => {
+    values: string[][];
+    leftovers: string[];
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import('../../common/redux').LockableValue<import('../structure/structureSlice').DomainRepresentation>, resultFuncArgs_1: DatabaseViewEntry, resultFuncArgs_2: TupleType, resultFuncArgs_3: number) => {
+        values: string[][];
+        leftovers: string[];
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: import('../../common/redux').LockableValue<import('../structure/structureSlice').DomainRepresentation>, resultFuncArgs_1: DatabaseViewEntry, resultFuncArgs_2: TupleType, resultFuncArgs_3: number) => {
+        values: string[][];
+        leftovers: string[];
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        values: string[][];
+        leftovers: string[];
+    };
+    dependencies: [(state: RootState) => import('../../common/redux').LockableValue<import('../structure/structureSlice').DomainRepresentation>, (state: RootState, key: string, type: TupleType) => DatabaseViewEntry, (_: RootState, __: string, type: TupleType) => TupleType, (_: RootState, __: string, ___: TupleType, arity: number) => number];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import('reselect').weakMapMemoize;
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const updateDatabaseViewValue: ({ domainTuple, type, tupleName, arity, }: {
+    domainTuple: string[][];
+    type: TupleType;
+    tupleName: string;
+    arity: number;
+}) => AppThunk;
+export declare const isValidTuple: (tuple: string[], arity: number) => boolean;
+declare const _default: import('redux').Reducer<DatabaseViewState>;
+export default _default;

package/dist/features/drawerEditor/DrawerEditor.d.ts

@@ -0,0 +1,23 @@
+import { EditorType } from '../structure/InterpretationEditor';
+import { ReactNode } from 'react';
+import { InterpretationError } from '../../common/errors';
+import { TupleType } from '../structure/structureSlice';
+export type DrawerEditorType = Exclude<EditorType, "text">;
+interface DrawerEditorProps {
+    tupleName: string;
+    type: DrawerEditorType;
+    tupleDisplayName: string;
+    tupleArity: number;
+    tupleType: TupleType;
+    editorDisplayName: string;
+    buildControlButtons: (omit?: EditorType[]) => ReactNode;
+    locker: () => void;
+    locked?: boolean;
+    error?: InterpretationError;
+}
+export default function DrawerEditor(props: DrawerEditorProps): import("react/jsx-runtime").JSX.Element;
+export interface EditorTitleProps {
+    base: string;
+    editor: string;
+}
+export {};

package/dist/features/drawerEditor/unaryPredicateColors.d.ts

@@ -0,0 +1,3 @@
+export declare const unaryPredicatesColors: string[];
+export declare function getUnaryPredicateColor(idx: number): string;
+export declare function getUnaryPredicateToColorMap(relevantPredicates: string[], allPredicates: [string, number][]): Map<string, string>;

package/dist/features/drawerEditor/usePreservedSize.d.ts

@@ -0,0 +1,8 @@
+export type Size = {
+    width: number;
+    height: number;
+};
+export default function usePreservedSize<T extends HTMLElement>(): {
+    ref: import('react').MutableRefObject<T | null>;
+    size: Size | null;
+};

package/dist/features/editorToolbar/components/DomainSelector.d.ts

@@ -0,0 +1,6 @@
+import { TupleType } from '../../structure/structureSlice';
+export interface DomainSelectorProps {
+    tupleName: string;
+    tupleType: TupleType;
+}
+export default function DomainSelector({ tupleName, tupleType, }: DomainSelectorProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/editorToolbar/components/EditorToolbar.d.ts

@@ -0,0 +1,6 @@
+import { TupleType } from '../../structure/structureSlice';
+export interface GraphToolbarProps {
+    tupleName: string;
+    tupleType: TupleType;
+}
+export declare function EditorToolbar({ tupleName, tupleType }: GraphToolbarProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/editorToolbar/components/InterpretationFilters.d.ts

@@ -0,0 +1,6 @@
+import { TupleType } from '../../structure/structureSlice';
+export interface InterpretationFiltersProps {
+    tupleName: string;
+    tupleType: TupleType;
+}
+export default function InterpretationFilters({ tupleName, tupleType, }: InterpretationFiltersProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/editorToolbar/components/useClickAwayListener.d.ts

@@ -0,0 +1,5 @@
+export interface UseClickAwayListenerProps {
+    onClickOutside: () => void;
+    shouldListen: boolean;
+}
+export default function useClickAwayListener<T extends HTMLElement>({ onClickOutside, shouldListen, }: UseClickAwayListenerProps): import('react').MutableRefObject<T | null>;

package/dist/features/editorToolbar/components/useDragginScroll.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export default function useDraggingScroll(scrollContainerRef: RefObject<HTMLElement>): void;

package/dist/features/editorToolbar/components/useScrollControls.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+interface UseScrollViewOptions {
+    scrollIntoViewOptions?: ScrollIntoViewOptions;
+    edgeMargin?: number;
+}
+export default function useScrollControls(scrollContainerRef: RefObject<HTMLElement>, options?: UseScrollViewOptions): {
+    scrollIntoView: (direction: "left" | "right") => void;
+    showLeftControl: boolean;
+    showRightControl: boolean;
+};
+export {};