@inventreedb/ui 0.0.1 → 0.0.3

package/dist/node_modules/unraw/dist/index.js

@@ -0,0 +1,112 @@
+import { __exports as dist } from "../../../_virtual/index2.js";
+import { __require as requireErrors } from "./errors.js";
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.unraw = exports.errorMessages = exports.ErrorType = void 0;
+    const errors_1 = requireErrors();
+    Object.defineProperty(exports, "ErrorType", { enumerable: true, get: function() {
+      return errors_1.ErrorType;
+    } });
+    Object.defineProperty(exports, "errorMessages", { enumerable: true, get: function() {
+      return errors_1.errorMessages;
+    } });
+    function parseHexToInt(hex) {
+      const isOnlyHexChars = !hex.match(/[^a-f0-9]/i);
+      return isOnlyHexChars ? parseInt(hex, 16) : NaN;
+    }
+    function validateAndParseHex(hex, errorName, enforcedLength) {
+      const parsedHex = parseHexToInt(hex);
+      if (Number.isNaN(parsedHex) || enforcedLength !== void 0 && enforcedLength !== hex.length) {
+        throw new SyntaxError(errors_1.errorMessages.get(errorName));
+      }
+      return parsedHex;
+    }
+    function parseHexadecimalCode(code) {
+      const parsedCode = validateAndParseHex(code, errors_1.ErrorType.MalformedHexadecimal, 2);
+      return String.fromCharCode(parsedCode);
+    }
+    function parseUnicodeCode(code, surrogateCode) {
+      const parsedCode = validateAndParseHex(code, errors_1.ErrorType.MalformedUnicode, 4);
+      if (surrogateCode !== void 0) {
+        const parsedSurrogateCode = validateAndParseHex(surrogateCode, errors_1.ErrorType.MalformedUnicode, 4);
+        return String.fromCharCode(parsedCode, parsedSurrogateCode);
+      }
+      return String.fromCharCode(parsedCode);
+    }
+    function isCurlyBraced(text) {
+      return text.charAt(0) === "{" && text.charAt(text.length - 1) === "}";
+    }
+    function parseUnicodeCodePointCode(codePoint) {
+      if (!isCurlyBraced(codePoint)) {
+        throw new SyntaxError(errors_1.errorMessages.get(errors_1.ErrorType.MalformedUnicode));
+      }
+      const withoutBraces = codePoint.slice(1, -1);
+      const parsedCode = validateAndParseHex(withoutBraces, errors_1.ErrorType.MalformedUnicode);
+      try {
+        return String.fromCodePoint(parsedCode);
+      } catch (err) {
+        throw err instanceof RangeError ? new SyntaxError(errors_1.errorMessages.get(errors_1.ErrorType.CodePointLimit)) : err;
+      }
+    }
+    function parseOctalCode(code, error = false) {
+      if (error) {
+        throw new SyntaxError(errors_1.errorMessages.get(errors_1.ErrorType.OctalDeprecation));
+      }
+      const parsedCode = parseInt(code, 8);
+      return String.fromCharCode(parsedCode);
+    }
+    const singleCharacterEscapes = /* @__PURE__ */ new Map([
+      ["b", "\b"],
+      ["f", "\f"],
+      ["n", "\n"],
+      ["r", "\r"],
+      ["t", "	"],
+      ["v", "\v"],
+      ["0", "\0"]
+    ]);
+    function parseSingleCharacterCode(code) {
+      return singleCharacterEscapes.get(code) || code;
+    }
+    const escapeMatch = /\\(?:(\\)|x([\s\S]{0,2})|u(\{[^}]*\}?)|u([\s\S]{4})\\u([^{][\s\S]{0,3})|u([\s\S]{0,4})|([0-3]?[0-7]{1,2})|([\s\S])|$)/g;
+    function unraw(raw, allowOctals = false) {
+      return raw.replace(escapeMatch, function(_, backslash, hex, codePoint, unicodeWithSurrogate, surrogate, unicode, octal, singleCharacter) {
+        if (backslash !== void 0) {
+          return "\\";
+        }
+        if (hex !== void 0) {
+          return parseHexadecimalCode(hex);
+        }
+        if (codePoint !== void 0) {
+          return parseUnicodeCodePointCode(codePoint);
+        }
+        if (unicodeWithSurrogate !== void 0) {
+          return parseUnicodeCode(unicodeWithSurrogate, surrogate);
+        }
+        if (unicode !== void 0) {
+          return parseUnicodeCode(unicode);
+        }
+        if (octal === "0") {
+          return "\0";
+        }
+        if (octal !== void 0) {
+          return parseOctalCode(octal, !allowOctals);
+        }
+        if (singleCharacter !== void 0) {
+          return parseSingleCharacterCode(singleCharacter);
+        }
+        throw new SyntaxError(errors_1.errorMessages.get(errors_1.ErrorType.EndOfString));
+      });
+    }
+    exports.unraw = unraw;
+    exports.default = unraw;
+  })(dist);
+  return dist;
+}
+export {
+  requireDist as __require
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/unraw/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../node_modules/unraw/dist/index.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unraw = exports.errorMessages = exports.ErrorType = void 0;\nconst errors_1 = require(\"./errors\");\nObject.defineProperty(exports, \"ErrorType\", { enumerable: true, get: function () { return errors_1.ErrorType; } });\nObject.defineProperty(exports, \"errorMessages\", { enumerable: true, get: function () { return errors_1.errorMessages; } });\n/**\n * Parse a string as a base-16 number. This is more strict than `parseInt` as it\n * will not allow any other characters, including (for example) \"+\", \"-\", and\n * \".\".\n * @param hex A string containing a hexadecimal number.\n * @returns The parsed integer, or `NaN` if the string is not a valid hex\n * number.\n */\nfunction parseHexToInt(hex) {\n    const isOnlyHexChars = !hex.match(/[^a-f0-9]/i);\n    return isOnlyHexChars ? parseInt(hex, 16) : NaN;\n}\n/**\n * Check the validity and length of a hexadecimal code and optionally enforces\n * a specific number of hex digits.\n * @param hex The string to validate and parse.\n * @param errorName The name of the error message to throw a `SyntaxError` with\n * if `hex` is invalid. This is used to index `errorMessages`.\n * @param enforcedLength If provided, will throw an error if `hex` is not\n * exactly this many characters.\n * @returns The parsed hex number as a normal number.\n * @throws {SyntaxError} If the code is not valid.\n */\nfunction validateAndParseHex(hex, errorName, enforcedLength) {\n    const parsedHex = parseHexToInt(hex);\n    if (Number.isNaN(parsedHex) ||\n        (enforcedLength !== undefined && enforcedLength !== hex.length)) {\n        throw new SyntaxError(errors_1.errorMessages.get(errorName));\n    }\n    return parsedHex;\n}\n/**\n * Parse a two-digit hexadecimal character escape code.\n * @param code The two-digit hexadecimal number that represents the character to\n * output.\n * @returns The single character represented by the code.\n * @throws {SyntaxError} If the code is not valid hex or is not the right\n * length.\n */\nfunction parseHexadecimalCode(code) {\n    const parsedCode = validateAndParseHex(code, errors_1.ErrorType.MalformedHexadecimal, 2);\n    return String.fromCharCode(parsedCode);\n}\n/**\n * Parse a four-digit Unicode character escape code.\n * @param code The four-digit unicode number that represents the character to\n * output.\n * @param surrogateCode Optional four-digit unicode surrogate that represents\n * the other half of the character to output.\n * @returns The single character represented by the code.\n * @throws {SyntaxError} If the codes are not valid hex or are not the right\n * length.\n */\nfunction parseUnicodeCode(code, surrogateCode) {\n    const parsedCode = validateAndParseHex(code, errors_1.ErrorType.MalformedUnicode, 4);\n    if (surrogateCode !== undefined) {\n        const parsedSurrogateCode = validateAndParseHex(surrogateCode, errors_1.ErrorType.MalformedUnicode, 4);\n        return String.fromCharCode(parsedCode, parsedSurrogateCode);\n    }\n    return String.fromCharCode(parsedCode);\n}\n/**\n * Test if the text is surrounded by curly braces (`{}`).\n * @param text Text to check.\n * @returns `true` if the text is in the form `{*}`.\n */\nfunction isCurlyBraced(text) {\n    return text.charAt(0) === \"{\" && text.charAt(text.length - 1) === \"}\";\n}\n/**\n * Parse a Unicode code point character escape code.\n * @param codePoint A unicode escape code point, including the surrounding curly\n * braces.\n * @returns The single character represented by the code.\n * @throws {SyntaxError} If the code is not valid hex or does not have the\n * surrounding curly braces.\n */\nfunction parseUnicodeCodePointCode(codePoint) {\n    if (!isCurlyBraced(codePoint)) {\n        throw new SyntaxError(errors_1.errorMessages.get(errors_1.ErrorType.MalformedUnicode));\n    }\n    const withoutBraces = codePoint.slice(1, -1);\n    const parsedCode = validateAndParseHex(withoutBraces, errors_1.ErrorType.MalformedUnicode);\n    try {\n        return String.fromCodePoint(parsedCode);\n    }\n    catch (err) {\n        throw err instanceof RangeError\n            ? new SyntaxError(errors_1.errorMessages.get(errors_1.ErrorType.CodePointLimit))\n            : err;\n    }\n}\n// Have to give overload that takes boolean for when compiler doesn't know if\n// true or false\nfunction parseOctalCode(code, error = false) {\n    if (error) {\n        throw new SyntaxError(errors_1.errorMessages.get(errors_1.ErrorType.OctalDeprecation));\n    }\n    // The original regex only allows digits so we don't need to have a strict\n    // octal parser like hexToInt. Length is not enforced for octals.\n    const parsedCode = parseInt(code, 8);\n    return String.fromCharCode(parsedCode);\n}\n/**\n * Map of unescaped letters to their corresponding special JS escape characters.\n * Intentionally does not include characters that map to themselves like \"\\'\".\n */\nconst singleCharacterEscapes = new Map([\n    [\"b\", \"\\b\"],\n    [\"f\", \"\\f\"],\n    [\"n\", \"\\n\"],\n    [\"r\", \"\\r\"],\n    [\"t\", \"\\t\"],\n    [\"v\", \"\\v\"],\n    [\"0\", \"\\0\"]\n]);\n/**\n * Parse a single character escape sequence and return the matching character.\n * If none is matched, defaults to `code`.\n * @param code A single character code.\n */\nfunction parseSingleCharacterCode(code) {\n    return singleCharacterEscapes.get(code) || code;\n}\n/**\n * Matches every escape sequence possible, including invalid ones.\n *\n * All capture groups (described below) are unique (only one will match), except\n * for 4, which can only potentially match if 3 does.\n *\n * **Capture Groups:**\n * 0. A single backslash\n * 1. Hexadecimal code\n * 2. Unicode code point code with surrounding curly braces\n * 3. Unicode escape code with surrogate\n * 4. Surrogate code\n * 5. Unicode escape code without surrogate\n * 6. Octal code _NOTE: includes \"0\"._\n * 7. A single character (will never be \\, x, u, or 0-3)\n */\nconst escapeMatch = /\\\\(?:(\\\\)|x([\\s\\S]{0,2})|u(\\{[^}]*\\}?)|u([\\s\\S]{4})\\\\u([^{][\\s\\S]{0,3})|u([\\s\\S]{0,4})|([0-3]?[0-7]{1,2})|([\\s\\S])|$)/g;\n/**\n * Replace raw escape character strings with their escape characters.\n * @param raw A string where escape characters are represented as raw string\n * values like `\\'` rather than `'`.\n * @param allowOctals If `true`, will process the now-deprecated octal escape\n * sequences (ie, `\\111`).\n * @returns The processed string, with escape characters replaced by their\n * respective actual Unicode characters.\n */\nfunction unraw(raw, allowOctals = false) {\n    return raw.replace(escapeMatch, function (_, backslash, hex, codePoint, unicodeWithSurrogate, surrogate, unicode, octal, singleCharacter) {\n        // Compare groups to undefined because empty strings mean different errors\n        // Otherwise, `\\u` would fail the same as `\\` which is wrong.\n        if (backslash !== undefined) {\n            return \"\\\\\";\n        }\n        if (hex !== undefined) {\n            return parseHexadecimalCode(hex);\n        }\n        if (codePoint !== undefined) {\n            return parseUnicodeCodePointCode(codePoint);\n        }\n        if (unicodeWithSurrogate !== undefined) {\n            return parseUnicodeCode(unicodeWithSurrogate, surrogate);\n        }\n        if (unicode !== undefined) {\n            return parseUnicodeCode(unicode);\n        }\n        if (octal === \"0\") {\n            return \"\\0\";\n        }\n        if (octal !== undefined) {\n            return parseOctalCode(octal, !allowOctals);\n        }\n        if (singleCharacter !== undefined) {\n            return parseSingleCharacterCode(singleCharacter);\n        }\n        throw new SyntaxError(errors_1.errorMessages.get(errors_1.ErrorType.EndOfString));\n    });\n}\nexports.unraw = unraw;\nexports.default = unraw;\n"],"names":["require$$0"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/types/Auth.d.ts

@@ -0,0 +1,51 @@
+export interface AuthContext {
+    status: number;
+    data: {
+        flows: Flow[];
+    };
+    meta: {
+        is_authenticated: boolean;
+    };
+}
+export declare enum FlowEnum {
+    VerifyEmail = "verify_email",
+    Login = "login",
+    Signup = "signup",
+    ProviderRedirect = "provider_redirect",
+    ProviderSignup = "provider_signup",
+    ProviderToken = "provider_token",
+    MfaAuthenticate = "mfa_authenticate",
+    Reauthenticate = "reauthenticate",
+    MfaReauthenticate = "mfa_reauthenticate"
+}
+export interface Flow {
+    id: FlowEnum;
+    providers?: string[];
+    is_pending?: boolean[];
+}
+export interface AuthProvider {
+    id: string;
+    name: string;
+    flows: string[];
+    client_id: string;
+}
+export interface AuthConfig {
+    account: {
+        authentication_method: string;
+    };
+    socialaccount: {
+        providers: AuthProvider[];
+    };
+    mfa: {
+        supported_types: string[];
+    };
+    usersessions: {
+        track_activity: boolean;
+    };
+}
+export type ErrorResponse = {
+    data: any;
+    status: number;
+    statusText: string;
+    message?: string;
+};

package/dist/types/Core.d.ts

@@ -0,0 +1,10 @@
+import { MantineSize } from '@mantine/core';
+export type UiSizeType = MantineSize | string | number;
+export interface UserTheme {
+    primaryColor: string;
+    whiteColor: string;
+    blackColor: string;
+    radius: UiSizeType;
+    loader: string;
+}
+export type PathParams = Record<string, string | number>;

package/dist/types/Filters.d.ts

@@ -0,0 +1,56 @@
+import { ModelType } from '../enums/ModelType';
+/**
+ * Interface for the table filter choice
+ */
+export type TableFilterChoice = {
+    value: string;
+    label: string;
+};
+/**
+ * Available filter types
+ *
+ * boolean: A simple true/false filter
+ * choice: A filter which allows selection from a list of (supplied)
+ * date: A filter which allows selection from a date input
+ * text: A filter which allows raw text input
+ * api: A filter which fetches its options from an API endpoint
+ */
+export type TableFilterType = 'boolean' | 'choice' | 'date' | 'text' | 'api';
+/**
+ * Interface for the table filter type. Provides a number of options for selecting filter value:
+ *
+ * name: The name of the filter (used for query string)
+ * label: The label to display in the UI (human readable)
+ * description: A description of the filter (human readable)
+ * type: The type of filter (see TableFilterType)
+ * choices: A list of TableFilterChoice objects
+ * choiceFunction: A function which returns a list of TableFilterChoice objects
+ * defaultValue: The default value for the filter
+ * value: The current value of the filter
+ * displayValue: The current display value of the filter
+ * active: Whether the filter is active (false = hidden, not used)
+ * apiUrl: The API URL to use for fetching dynamic filter options
+ * model: The model type to use for fetching dynamic filter options
+ * modelRenderer: A function to render a simple text version of the model type
+ */
+export type TableFilter = {
+    name: string;
+    label: string;
+    description?: string;
+    type?: TableFilterType;
+    choices?: TableFilterChoice[];
+    choiceFunction?: () => TableFilterChoice[];
+    defaultValue?: any;
+    value?: any;
+    displayValue?: any;
+    active?: boolean;
+    apiUrl?: string;
+    model?: ModelType;
+    modelRenderer?: (instance: any) => string;
+};
+export type FilterSetState = {
+    filterKey: string;
+    activeFilters: TableFilter[];
+    setActiveFilters: (filters: TableFilter[]) => void;
+    clearActiveFilters: () => void;
+};

package/dist/types/Forms.d.ts

@@ -0,0 +1,159 @@
+import { DefaultMantineColor, MantineStyleProp } from '@mantine/core';
+import { UseFormReturnType } from '@mantine/form';
+import { ReactNode } from 'react';
+import { FieldValues } from 'react-hook-form';
+import { ApiEndpoints } from '../enums/ApiEndpoints';
+import { ModelType } from '../enums/ModelType';
+import { PathParams, UiSizeType } from './Core';
+import { TableState } from './Tables';
+export interface ApiFormAction {
+    text: string;
+    variant?: 'outline';
+    color?: DefaultMantineColor;
+    onClick: () => void;
+}
+export type ApiFormData = UseFormReturnType<Record<string, unknown>>;
+export type ApiFormAdjustFilterType = {
+    filters: any;
+    data: FieldValues;
+};
+export type ApiFormFieldChoice = {
+    value: any;
+    display_name: string;
+};
+export type ApiFormFieldHeader = {
+    title: string;
+    style?: MantineStyleProp;
+};
+/** Definition of the ApiForm field component.
+ * - The 'name' attribute *must* be provided
+ * - All other attributes are optional, and may be provided by the API
+ * - However, they can be overridden by the user
+ *
+ * @param name : The name of the field
+ * @param label : The label to display for the field
+ * @param value : The value of the field
+ * @param default : The default value of the field
+ * @param icon : An icon to display next to the field
+ * @param field_type : The type of field to render
+ * @param api_url : The API endpoint to fetch data from (for related fields)
+ * @param pk_field : The primary key field for the related field (default = "pk")
+ * @param model : The model to use for related fields
+ * @param filters : Optional API filters to apply to related fields
+ * @param required : Whether the field is required
+ * @param hidden : Whether the field is hidden
+ * @param disabled : Whether the field is disabled
+ * @param error : Optional error message to display
+ * @param exclude : Whether to exclude the field from the submitted data
+ * @param placeholder : The placeholder text to display
+ * @param description : The description to display for the field
+ * @param preFieldContent : Content to render before the field
+ * @param postFieldContent : Content to render after the field
+ * @param onValueChange : Callback function to call when the field value changes
+ * @param adjustFilters : Callback function to adjust the filters for a related field before a query is made
+ * @param adjustValue : Callback function to adjust the value of the field before it is sent to the API
+ * @param addRow : Callback function to add a new row to a table field
+ * @param onKeyDown : Callback function to get which key was pressed in the form to handle submission on enter
+ */
+export type ApiFormFieldType = {
+    label?: string;
+    value?: any;
+    default?: any;
+    icon?: ReactNode;
+    field_type?: 'related field' | 'email' | 'url' | 'string' | 'icon' | 'boolean' | 'date' | 'datetime' | 'integer' | 'decimal' | 'float' | 'number' | 'choice' | 'file upload' | 'nested object' | 'dependent field' | 'table';
+    api_url?: string;
+    pk_field?: string;
+    model?: ModelType;
+    modelRenderer?: (instance: any) => ReactNode;
+    filters?: any;
+    child?: ApiFormFieldType;
+    children?: {
+        [key: string]: ApiFormFieldType;
+    };
+    required?: boolean;
+    error?: string;
+    choices?: ApiFormFieldChoice[];
+    hidden?: boolean;
+    disabled?: boolean;
+    exclude?: boolean;
+    read_only?: boolean;
+    placeholder?: string;
+    description?: string;
+    preFieldContent?: JSX.Element;
+    postFieldContent?: JSX.Element;
+    adjustValue?: (value: any) => any;
+    onValueChange?: (value: any, record?: any) => void;
+    adjustFilters?: (value: ApiFormAdjustFilterType) => any;
+    addRow?: () => any;
+    headers?: ApiFormFieldHeader[];
+    depends_on?: string[];
+};
+export type ApiFormFieldSet = Record<string, ApiFormFieldType>;
+/**
+ * Properties for the ApiForm component
+ * @param url : The API endpoint to fetch the form data from
+ * @param pk : Optional primary-key value when editing an existing object
+ * @param pk_field : Optional primary-key field name (default: pk)
+ * @param pathParams : Optional path params for the url
+ * @param method : Optional HTTP method to use when submitting the form (default: GET)
+ * @param fields : The fields to render in the form
+ * @param submitText : Optional custom text to display on the submit button (default: Submit)4
+ * @param submitColor : Optional custom color for the submit button (default: green)
+ * @param fetchInitialData : Optional flag to fetch initial data from the server (default: true)
+ * @param preFormContent : Optional content to render before the form fields
+ * @param postFormContent : Optional content to render after the form fields
+ * @param successMessage : Optional message to display on successful form submission
+ * @param onFormSuccess : A callback function to call when the form is submitted successfully.
+ * @param onFormError : A callback function to call when the form is submitted with errors.
+ * @param processFormData : A callback function to process the form data before submission
+ * @param modelType : Define a model type for this form
+ * @param follow : Boolean, follow the result of the form (if possible)
+ * @param table : Table to update on success (if provided)
+ */
+export interface ApiFormProps {
+    url: ApiEndpoints | string;
+    pk?: number | string;
+    pk_field?: string;
+    pathParams?: PathParams;
+    queryParams?: URLSearchParams;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    fields?: ApiFormFieldSet;
+    focus?: string;
+    initialData?: FieldValues;
+    submitText?: string;
+    submitColor?: string;
+    fetchInitialData?: boolean;
+    ignorePermissionCheck?: boolean;
+    preFormContent?: JSX.Element;
+    preFormWarning?: string;
+    preFormSuccess?: string;
+    postFormContent?: JSX.Element;
+    successMessage?: string | null;
+    onFormSuccess?: (data: any) => void;
+    onFormError?: (response: any) => void;
+    processFormData?: (data: any) => any;
+    table?: TableState;
+    modelType?: ModelType;
+    follow?: boolean;
+    actions?: ApiFormAction[];
+    timeout?: number;
+}
+/**
+ * @param title : The title to display in the modal header
+ * @param cancelText : Optional custom text to display on the cancel button (default: Cancel)
+ * @param cancelColor : Optional custom color for the cancel button (default: blue)
+ * @param onClose : A callback function to call when the modal is closed.
+ * @param onOpen : A callback function to call when the modal is opened.
+ */
+export interface ApiFormModalProps extends ApiFormProps {
+    title: string;
+    cancelText?: string;
+    cancelColor?: string;
+    onClose?: () => void;
+    onOpen?: () => void;
+    closeOnClickOutside?: boolean;
+    size?: UiSizeType;
+}
+export interface BulkEditApiFormModalProps extends ApiFormModalProps {
+    items: number[];
+}

package/dist/types/Icons.d.ts

@@ -0,0 +1,5 @@
+import { Icon, IconProps } from '@tabler/icons-react';
+export type TablerIconType = React.ForwardRefExoticComponent<Omit<IconProps, 'ref'> & React.RefAttributes<Icon>>;
+export type InvenTreeIconType = {
+    [key: string]: TablerIconType;
+};

package/dist/types/Modals.d.ts

@@ -0,0 +1,15 @@
+import { UiSizeType } from './Core';
+export interface UseModalProps {
+    title: string;
+    children: React.ReactElement;
+    size?: UiSizeType;
+    onOpen?: () => void;
+    onClose?: () => void;
+    closeOnClickOutside?: boolean;
+}
+export interface UseModalReturn {
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    modal: React.ReactElement;
+}

package/dist/types/Plugins.d.ts

@@ -0,0 +1,58 @@
+import { MantineColorScheme, MantineTheme } from '@mantine/core';
+import { QueryClient } from '@tanstack/react-query';
+import { AxiosInstance } from 'axios';
+import { NavigateFunction } from 'react-router-dom';
+import { ModelType } from '../enums/ModelType';
+import { ApiFormModalProps, BulkEditApiFormModalProps } from './Forms';
+import { UseModalReturn } from './Modals';
+import { SettingsStateProps } from './Settings';
+import { UserStateProps } from './User';
+export interface PluginProps {
+    name: string;
+    slug: string;
+    version: null | string;
+}
+export type InvenTreeFormsContext = {
+    bulkEdit: (props: BulkEditApiFormModalProps) => UseModalReturn;
+    create: (props: ApiFormModalProps) => UseModalReturn;
+    delete: (props: ApiFormModalProps) => UseModalReturn;
+    edit: (props: ApiFormModalProps) => UseModalReturn;
+};
+/**
+ * A set of properties which are passed to a plugin,
+ * for rendering an element in the user interface.
+ *
+ * @param version - The version of the running InvenTree software stack
+ * @param api - The Axios API instance (see ../states/ApiState.tsx)
+ * @param user - The current user instance (see ../states/UserState.tsx)
+ * @param userSettings - The current user settings (see ../states/SettingsState.tsx)
+ * @param globalSettings - The global settings (see ../states/SettingsState.tsx)
+ * @param navigate - The navigation function (see react-router-dom)
+ * @param theme - The current Mantine theme
+ * @param colorScheme - The current Mantine color scheme (e.g. 'light' / 'dark')
+ * @param host - The current host URL
+ * @param locale - The current locale string (e.g. 'en' / 'de')
+ * @param model - The model type associated with the rendered component (if applicable)
+ * @param id - The ID (primary key) of the model instance for the plugin (if applicable)
+ * @param instance - The model instance data (if available)
+ * @param context - Any additional context data which may be passed to the plugin
+ */
+export type InvenTreePluginContext = {
+    version: string;
+    api: AxiosInstance;
+    queryClient: QueryClient;
+    user: UserStateProps;
+    userSettings: SettingsStateProps;
+    globalSettings: SettingsStateProps;
+    host: string;
+    locale: string;
+    navigate: NavigateFunction;
+    theme: MantineTheme;
+    forms: InvenTreeFormsContext;
+    colorScheme: MantineColorScheme;
+    model?: ModelType | string;
+    id?: string | number | null;
+    instance?: any;
+    context?: any;
+};
+export declare const INVENTREE_PLUGIN_VERSION: string;

package/dist/types/Plugins.js

@@ -0,0 +1,5 @@
+const INVENTREE_PLUGIN_VERSION = "0.0.3";
+export {
+  INVENTREE_PLUGIN_VERSION
+};
+//# sourceMappingURL=Plugins.js.map

package/dist/types/Plugins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Plugins.js","sources":["../../lib/types/Plugins.tsx"],"sourcesContent":["import type { MantineColorScheme, MantineTheme } from '@mantine/core';\nimport type { QueryClient } from '@tanstack/react-query';\nimport type { AxiosInstance } from 'axios';\nimport type { NavigateFunction } from 'react-router-dom';\nimport type { ModelType } from '../enums/ModelType';\nimport type { ApiFormModalProps, BulkEditApiFormModalProps } from './Forms';\nimport type { UseModalReturn } from './Modals';\nimport type { SettingsStateProps } from './Settings';\nimport type { UserStateProps } from './User';\n\nexport interface PluginProps {\n  name: string;\n  slug: string;\n  version: null | string;\n}\n\nexport type InvenTreeFormsContext = {\n  bulkEdit: (props: BulkEditApiFormModalProps) => UseModalReturn;\n  create: (props: ApiFormModalProps) => UseModalReturn;\n  delete: (props: ApiFormModalProps) => UseModalReturn;\n  edit: (props: ApiFormModalProps) => UseModalReturn;\n};\n\n/**\n * A set of properties which are passed to a plugin,\n * for rendering an element in the user interface.\n *\n * @param version - The version of the running InvenTree software stack\n * @param api - The Axios API instance (see ../states/ApiState.tsx)\n * @param user - The current user instance (see ../states/UserState.tsx)\n * @param userSettings - The current user settings (see ../states/SettingsState.tsx)\n * @param globalSettings - The global settings (see ../states/SettingsState.tsx)\n * @param navigate - The navigation function (see react-router-dom)\n * @param theme - The current Mantine theme\n * @param colorScheme - The current Mantine color scheme (e.g. 'light' / 'dark')\n * @param host - The current host URL\n * @param locale - The current locale string (e.g. 'en' / 'de')\n * @param model - The model type associated with the rendered component (if applicable)\n * @param id - The ID (primary key) of the model instance for the plugin (if applicable)\n * @param instance - The model instance data (if available)\n * @param context - Any additional context data which may be passed to the plugin\n */\nexport type InvenTreePluginContext = {\n  version: string;\n  api: AxiosInstance;\n  queryClient: QueryClient;\n  user: UserStateProps;\n  userSettings: SettingsStateProps;\n  globalSettings: SettingsStateProps;\n  host: string;\n  locale: string;\n  navigate: NavigateFunction;\n  theme: MantineTheme;\n  forms: InvenTreeFormsContext;\n  colorScheme: MantineColorScheme;\n  model?: ModelType | string;\n  id?: string | number | null;\n  instance?: any;\n  context?: any;\n};\n\n/*\n * The version of the InvenTree plugin context interface.\n * This number should be incremented if the interface changes.\n */\n\n// @ts-ignore\nexport const INVENTREE_PLUGIN_VERSION: string = __INVENTREE_LIB_VERSION__;\n"],"names":["INVENTREE_PLUGIN_VERSION","__INVENTREE_LIB_VERSION__"],"mappings":"AAmEO,MAAMA,2BAAmCC;"}

package/dist/types/Server.d.ts

@@ -0,0 +1,7 @@
+export interface Host {
+    host: string;
+    name: string;
+}
+export interface HostList {
+    [key: string]: Host;
+}

package/dist/types/Settings.d.ts

@@ -0,0 +1,48 @@
+import { ApiEndpoints } from '../enums/ApiEndpoints';
+import { PathParams } from './Core';
+export declare enum SettingTyp {
+    InvenTree = "inventree",
+    Plugin = "plugin",
+    User = "user",
+    Notification = "notification"
+}
+export declare enum SettingType {
+    Boolean = "boolean",
+    Integer = "integer",
+    String = "string",
+    Choice = "choice",
+    Model = "related field"
+}
+export interface Setting {
+    pk: number;
+    key: string;
+    value: string;
+    name: string;
+    description: string;
+    type: SettingType;
+    units: string;
+    choices: SettingChoice[];
+    model_name: string | null;
+    model_filters: Record<string, any> | null;
+    api_url: string | null;
+    typ: SettingTyp;
+    plugin?: string;
+    method?: string;
+    required?: boolean;
+}
+export interface SettingChoice {
+    value: string;
+    display_name: string;
+}
+export type SettingsLookup = {
+    [key: string]: string;
+};
+export interface SettingsStateProps {
+    settings: Setting[];
+    lookup: SettingsLookup;
+    fetchSettings: () => Promise<boolean>;
+    endpoint: ApiEndpoints;
+    pathParams?: PathParams;
+    getSetting: (key: string, default_value?: string) => string;
+    isSet: (key: string, default_value?: boolean) => boolean;
+}

package/dist/types/Tables.d.ts

@@ -0,0 +1,34 @@
+import { SetURLSearchParams } from 'react-router-dom';
+import { FilterSetState } from './Filters';
+export type TableState = {
+    tableKey: string;
+    refreshTable: () => void;
+    isLoading: boolean;
+    setIsLoading: (value: boolean) => void;
+    filterSet: FilterSetState;
+    queryFilters: URLSearchParams;
+    setQueryFilters: SetURLSearchParams;
+    clearQueryFilters: () => void;
+    expandedRecords: any[];
+    setExpandedRecords: (records: any[]) => void;
+    isRowExpanded: (pk: number) => boolean;
+    selectedRecords: any[];
+    selectedIds: any[];
+    hasSelectedRecords: boolean;
+    setSelectedRecords: (records: any[]) => void;
+    clearSelectedRecords: () => void;
+    hiddenColumns: string[];
+    setHiddenColumns: (columns: string[]) => void;
+    searchTerm: string;
+    setSearchTerm: (term: string) => void;
+    recordCount: number;
+    setRecordCount: (count: number) => void;
+    page: number;
+    setPage: (page: number) => void;
+    pageSize: number;
+    setPageSize: (pageSize: number) => void;
+    records: any[];
+    setRecords: (records: any[]) => void;
+    updateRecord: (record: any) => void;
+    idAccessor?: string;
+};

package/dist/types/User.d.ts

@@ -0,0 +1,55 @@
+import { ModelType } from '../enums/ModelType';
+import { UserPermissions, UserRoles } from '../enums/Roles';
+export interface UserProfile {
+    language: string;
+    theme: any;
+    widgets: any;
+    displayname: string | null;
+    position: string | null;
+    status: string | null;
+    location: string | null;
+    active: boolean;
+    contact: string | null;
+    type: string;
+    organisation: string | null;
+    primary_group: number | null;
+}
+export interface UserProps {
+    pk: number;
+    username: string;
+    first_name: string;
+    last_name: string;
+    email: string;
+    is_staff?: boolean;
+    is_superuser?: boolean;
+    roles?: Record<string, string[]>;
+    permissions?: Record<string, string[]>;
+    groups: any[] | null;
+    profile: UserProfile;
+}
+export interface UserStateProps {
+    user: UserProps | undefined;
+    is_authed: boolean;
+    userId: () => number | undefined;
+    username: () => string;
+    setAuthenticated: (authed?: boolean) => void;
+    fetchUserToken: () => Promise<void>;
+    setUser: (newUser: UserProps | undefined) => void;
+    getUser: () => UserProps | undefined;
+    fetchUserState: () => Promise<void>;
+    clearUserState: () => void;
+    checkUserRole: (role: UserRoles, permission: UserPermissions) => boolean;
+    hasDeleteRole: (role: UserRoles) => boolean;
+    hasChangeRole: (role: UserRoles) => boolean;
+    hasAddRole: (role: UserRoles) => boolean;
+    hasViewRole: (role: UserRoles) => boolean;
+    checkUserPermission: (model: ModelType, permission: UserPermissions) => boolean;
+    hasDeletePermission: (model: ModelType) => boolean;
+    hasChangePermission: (model: ModelType) => boolean;
+    hasAddPermission: (model: ModelType) => boolean;
+    hasViewPermission: (model: ModelType) => boolean;
+    isAuthed: () => boolean;
+    isLoggedIn: () => boolean;
+    isStaff: () => boolean;
+    isSuperuser: () => boolean;
+}