@fmfi-uk-1-ain-412/structure-explorer 0.0.6

package/dist/features/game/GameComponent.d.ts

@@ -0,0 +1,8 @@
+import { default as Formula } from '../../model/formula/Formula';
+interface Props {
+    id: number;
+    guess: boolean;
+    originalFormula: Formula;
+}
+export default function GameComponent({ id }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/game/GameControls.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    id: number;
+}
+export default function GameControl({ id }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/game/GameHistory.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    id: number;
+}
+export default function GameHistory({ id }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/import/importThunk.d.ts

@@ -0,0 +1,2 @@
+import { AppDispatch, RootState } from '../../app/store';
+export declare const importAppState: (importedState: RootState) => (dispatch: AppDispatch) => void;

package/dist/features/language/LanguageComponent.d.ts

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

package/dist/features/language/languageSlice.d.ts

@@ -0,0 +1,588 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { RootState } from '../../app/store';
+import { default as Language } from '../../model/Language';
+export interface LanguageState {
+    constants: string;
+    predicates: string;
+    functions: string;
+}
+export declare const languageSlice: import('@reduxjs/toolkit').Slice<LanguageState, {
+    importLanguageState: (_state: import('immer').WritableDraft<LanguageState>, action: PayloadAction<string>) => any;
+    updateConstants: (state: import('immer').WritableDraft<LanguageState>, action: PayloadAction<string>) => void;
+    updatePredicates: (state: import('immer').WritableDraft<LanguageState>, action: PayloadAction<string>) => void;
+    updateFunctions: (state: import('immer').WritableDraft<LanguageState>, action: PayloadAction<string>) => void;
+}, "language", "language", import('@reduxjs/toolkit').SliceSelectors<LanguageState>>;
+export declare const updateConstants: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "language/updateConstants">, updatePredicates: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "language/updatePredicates">, updateFunctions: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "language/updateFunctions">, importLanguageState: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "language/importLanguageState">;
+declare const _default: import('redux').Reducer<LanguageState>;
+export default _default;
+export declare const selectConstants: (state: RootState) => string;
+export declare const selectPredicates: (state: RootState) => string;
+export declare const selectFunctions: (state: RootState) => string;
+export declare const selectParsedConstants: ((state: {
+    formulas: import('../formulas/formulasSlice').FormulasState;
+    language: LanguageState;
+    structure: import('../structure/structureSlice').StructureState;
+    variables: import('../variables/variablesSlice').VariablesState;
+}) => {
+    parsed: Set<string>;
+    error?: undefined;
+} | {
+    error: Error;
+    parsed?: undefined;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string) => {
+        parsed: Set<string>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: string) => {
+        parsed: Set<string>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        parsed: Set<string>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    };
+    dependencies: [(state: RootState) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import('reselect').weakMapMemoize;
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectParsedPredicates: ((state: {
+    formulas: import('../formulas/formulasSlice').FormulasState;
+    language: LanguageState;
+    structure: import('../structure/structureSlice').StructureState;
+    variables: import('../variables/variablesSlice').VariablesState;
+}) => {
+    parsed: Map<string, number>;
+    error?: undefined;
+} | {
+    error: Error;
+    parsed?: undefined;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string) => {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: string) => {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    };
+    dependencies: [(state: RootState) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import('reselect').weakMapMemoize;
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectParsedFunctions: ((state: {
+    formulas: import('../formulas/formulasSlice').FormulasState;
+    language: LanguageState;
+    structure: import('../structure/structureSlice').StructureState;
+    variables: import('../variables/variablesSlice').VariablesState;
+}) => {
+    parsed: Map<string, number>;
+    error?: undefined;
+} | {
+    error: Error;
+    parsed?: undefined;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string) => {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: string) => {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    };
+    dependencies: [(state: RootState) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import('reselect').weakMapMemoize;
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectSymbolsClash: ((state: {
+    formulas: import('../formulas/formulasSlice').FormulasState;
+    language: LanguageState;
+    structure: import('../structure/structureSlice').StructureState;
+    variables: import('../variables/variablesSlice').VariablesState;
+}) => "" | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        parsed: Set<string>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }, resultFuncArgs_1: {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }, resultFuncArgs_2: {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) => "" | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        parsed: Set<string>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }, resultFuncArgs_1: {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }, resultFuncArgs_2: {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) => "" | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => "" | undefined;
+    dependencies: [((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: LanguageState;
+        structure: import('../structure/structureSlice').StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => {
+        parsed: Set<string>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: string) => {
+            parsed: Set<string>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: string) => {
+            parsed: Set<string>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            parsed: Set<string>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        dependencies: [(state: RootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }, ((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: LanguageState;
+        structure: import('../structure/structureSlice').StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: string) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: string) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        dependencies: [(state: RootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }, ((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: LanguageState;
+        structure: import('../structure/structureSlice').StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: string) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: string) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        dependencies: [(state: RootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import('reselect').weakMapMemoize;
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectLanguage: ((state: {
+    formulas: import('../formulas/formulasSlice').FormulasState;
+    language: LanguageState;
+    structure: import('../structure/structureSlice').StructureState;
+    variables: import('../variables/variablesSlice').VariablesState;
+}) => Language) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        parsed: Set<string>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }, resultFuncArgs_1: {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }, resultFuncArgs_2: {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) => Language;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        parsed: Set<string>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }, resultFuncArgs_1: {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }, resultFuncArgs_2: {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) => Language) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Language;
+    dependencies: [((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: LanguageState;
+        structure: import('../structure/structureSlice').StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => {
+        parsed: Set<string>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: string) => {
+            parsed: Set<string>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: string) => {
+            parsed: Set<string>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            parsed: Set<string>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        dependencies: [(state: RootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }, ((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: LanguageState;
+        structure: import('../structure/structureSlice').StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: string) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: string) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        dependencies: [(state: RootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }, ((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: LanguageState;
+        structure: import('../structure/structureSlice').StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: string) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: string) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        dependencies: [(state: RootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import('reselect').weakMapMemoize;
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+};

package/dist/features/structure/InterpretationInput.d.ts

@@ -0,0 +1,14 @@
+import { InterpretationState } from './structureSlice';
+import { RootState } from '../../app/store';
+import { ChangeEvent } from 'react';
+interface Props {
+    name: string;
+    id: string;
+    selector: (state: RootState, name: string) => InterpretationState;
+    parser: (state: RootState, name: string) => {
+        error?: Error;
+    };
+    onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+}
+export default function InterpretationInput({ name, id, selector, parser, onChange, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/structure/StructureComponent.d.ts

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