@nocios/crudify-components 1.0.0

package/coverage/sorter.js

@@ -0,0 +1,210 @@
+/* eslint-disable */
+var addSorting = (function() {
+    'use strict';
+    var cols,
+        currentSort = {
+            index: 0,
+            desc: false
+        };
+
+    // returns the summary table element
+    function getTable() {
+        return document.querySelector('.coverage-summary');
+    }
+    // returns the thead element of the summary table
+    function getTableHeader() {
+        return getTable().querySelector('thead tr');
+    }
+    // returns the tbody element of the summary table
+    function getTableBody() {
+        return getTable().querySelector('tbody');
+    }
+    // returns the th element for nth column
+    function getNthColumn(n) {
+        return getTableHeader().querySelectorAll('th')[n];
+    }
+
+    function onFilterInput() {
+        const searchValue = document.getElementById('fileSearch').value;
+        const rows = document.getElementsByTagName('tbody')[0].children;
+
+        // Try to create a RegExp from the searchValue. If it fails (invalid regex),
+        // it will be treated as a plain text search
+        let searchRegex;
+        try {
+            searchRegex = new RegExp(searchValue, 'i'); // 'i' for case-insensitive
+        } catch (error) {
+            searchRegex = null;
+        }
+
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            let isMatch = false;
+
+            if (searchRegex) {
+                // If a valid regex was created, use it for matching
+                isMatch = searchRegex.test(row.textContent);
+            } else {
+                // Otherwise, fall back to the original plain text search
+                isMatch = row.textContent
+                    .toLowerCase()
+                    .includes(searchValue.toLowerCase());
+            }
+
+            row.style.display = isMatch ? '' : 'none';
+        }
+    }
+
+    // loads the search box
+    function addSearchBox() {
+        var template = document.getElementById('filterTemplate');
+        var templateClone = template.content.cloneNode(true);
+        templateClone.getElementById('fileSearch').oninput = onFilterInput;
+        template.parentElement.appendChild(templateClone);
+    }
+
+    // loads all columns
+    function loadColumns() {
+        var colNodes = getTableHeader().querySelectorAll('th'),
+            colNode,
+            cols = [],
+            col,
+            i;
+
+        for (i = 0; i < colNodes.length; i += 1) {
+            colNode = colNodes[i];
+            col = {
+                key: colNode.getAttribute('data-col'),
+                sortable: !colNode.getAttribute('data-nosort'),
+                type: colNode.getAttribute('data-type') || 'string'
+            };
+            cols.push(col);
+            if (col.sortable) {
+                col.defaultDescSort = col.type === 'number';
+                colNode.innerHTML =
+                    colNode.innerHTML + '<span class="sorter"></span>';
+            }
+        }
+        return cols;
+    }
+    // attaches a data attribute to every tr element with an object
+    // of data values keyed by column name
+    function loadRowData(tableRow) {
+        var tableCols = tableRow.querySelectorAll('td'),
+            colNode,
+            col,
+            data = {},
+            i,
+            val;
+        for (i = 0; i < tableCols.length; i += 1) {
+            colNode = tableCols[i];
+            col = cols[i];
+            val = colNode.getAttribute('data-value');
+            if (col.type === 'number') {
+                val = Number(val);
+            }
+            data[col.key] = val;
+        }
+        return data;
+    }
+    // loads all row data
+    function loadData() {
+        var rows = getTableBody().querySelectorAll('tr'),
+            i;
+
+        for (i = 0; i < rows.length; i += 1) {
+            rows[i].data = loadRowData(rows[i]);
+        }
+    }
+    // sorts the table using the data for the ith column
+    function sortByIndex(index, desc) {
+        var key = cols[index].key,
+            sorter = function(a, b) {
+                a = a.data[key];
+                b = b.data[key];
+                return a < b ? -1 : a > b ? 1 : 0;
+            },
+            finalSorter = sorter,
+            tableBody = document.querySelector('.coverage-summary tbody'),
+            rowNodes = tableBody.querySelectorAll('tr'),
+            rows = [],
+            i;
+
+        if (desc) {
+            finalSorter = function(a, b) {
+                return -1 * sorter(a, b);
+            };
+        }
+
+        for (i = 0; i < rowNodes.length; i += 1) {
+            rows.push(rowNodes[i]);
+            tableBody.removeChild(rowNodes[i]);
+        }
+
+        rows.sort(finalSorter);
+
+        for (i = 0; i < rows.length; i += 1) {
+            tableBody.appendChild(rows[i]);
+        }
+    }
+    // removes sort indicators for current column being sorted
+    function removeSortIndicators() {
+        var col = getNthColumn(currentSort.index),
+            cls = col.className;
+
+        cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
+        col.className = cls;
+    }
+    // adds sort indicators for current column being sorted
+    function addSortIndicators() {
+        getNthColumn(currentSort.index).className += currentSort.desc
+            ? ' sorted-desc'
+            : ' sorted';
+    }
+    // adds event listeners for all sorter widgets
+    function enableUI() {
+        var i,
+            el,
+            ithSorter = function ithSorter(i) {
+                var col = cols[i];
+
+                return function() {
+                    var desc = col.defaultDescSort;
+
+                    if (currentSort.index === i) {
+                        desc = !currentSort.desc;
+                    }
+                    sortByIndex(i, desc);
+                    removeSortIndicators();
+                    currentSort.index = i;
+                    currentSort.desc = desc;
+                    addSortIndicators();
+                };
+            };
+        for (i = 0; i < cols.length; i += 1) {
+            if (cols[i].sortable) {
+                // add the click event handler on the th so users
+                // dont have to click on those tiny arrows
+                el = getNthColumn(i).querySelector('.sorter').parentElement;
+                if (el.addEventListener) {
+                    el.addEventListener('click', ithSorter(i));
+                } else {
+                    el.attachEvent('onclick', ithSorter(i));
+                }
+            }
+        }
+    }
+    // adds sorting functionality to the UI
+    return function() {
+        if (!getTable()) {
+            return;
+        }
+        cols = loadColumns();
+        loadData();
+        addSearchBox();
+        addSortIndicators();
+        enableUI();
+    };
+})();
+
+window.addEventListener('load', addSorting);

package/dist/CrudiaMarkdownField-C54-A_J3.d.mts

@@ -0,0 +1,328 @@
+import React from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { A as AutoGenerateConfig } from './GlobalNotificationProvider-Zq18OkpI.mjs';
+
+/**
+ * Password validation types and constants
+ * Used for password requirements validation in forms
+ */
+type PasswordRuleType = "minLength" | "alphanumeric" | "uppercase" | "lowercase" | "number" | "special";
+interface PasswordRule {
+    type: PasswordRuleType;
+    value?: number | string;
+    message: string;
+    enforce?: boolean;
+}
+interface EvaluatedPasswordRule {
+    message: string;
+    valid: boolean;
+    enforce: boolean;
+}
+/**
+ * Default password rules used as fallback when no custom rules are provided.
+ * Messages are translation keys that should be translated at runtime.
+ */
+declare const DEFAULT_PASSWORD_RULES: PasswordRule[];
+
+type BoxScreenType = "login" | "signUp" | "forgotPassword" | "resetPassword" | "checkCode";
+interface CrudifyLoginConfig {
+    publicApiKey?: string | null;
+    env?: "dev" | "stg" | "api" | "prod";
+    appName?: string;
+    logo?: string;
+    loginActions?: string[];
+}
+interface CrudifyLoginTranslations {
+    [key: string]: string | CrudifyLoginTranslations;
+}
+interface UserLoginData {
+    token: string;
+    username?: string;
+    email?: string;
+    userId?: string;
+    profile?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface CrudifyLoginProps {
+    onScreenChange?: (screen: BoxScreenType, params?: Record<string, string>) => void;
+    onExternalNavigate?: (path: string) => void;
+    onLoginSuccess?: (userData: UserLoginData, redirectUrl?: string) => void;
+    onError?: (error: string) => void;
+    initialScreen?: BoxScreenType;
+    redirectUrl?: string;
+    autoReadFromCookies?: boolean;
+    translations?: CrudifyLoginTranslations;
+    translationsUrl?: string;
+    language?: string;
+    /** Custom password rules for reset password form. Falls back to default rules if not provided. */
+    passwordRules?: PasswordRule[];
+}
+
+declare const CrudifyLogin: React.FC<CrudifyLoginProps>;
+
+interface UserProfileDisplayProps {
+    showExtendedData?: boolean;
+    showProfileCard?: boolean;
+    autoRefresh?: boolean;
+}
+declare const UserProfileDisplay: React.FC<UserProfileDisplayProps>;
+
+declare const POLICY_ACTIONS: readonly ["create", "read", "update", "delete"];
+type PolicyAction = typeof POLICY_ACTIONS[number];
+declare const PREFERRED_POLICY_ORDER: PolicyAction[];
+
+type Policy = {
+    id: string;
+    action: PolicyAction;
+    fields?: {
+        allow: string[];
+        owner_allow: string[];
+        deny: string[];
+    };
+    permission?: string;
+};
+type FieldErrorMap = string | ({
+    _error?: string;
+} & Record<string, string | undefined>);
+interface PoliciesProps {
+    policies: Policy[];
+    onChange: (next: Policy[]) => void;
+    availableFields: string[];
+    errors?: FieldErrorMap;
+    isSubmitting?: boolean;
+}
+declare const Policies: React.FC<PoliciesProps>;
+
+declare function LoginComponent(): react_jsx_runtime.JSX.Element;
+/**
+ * Componente simple de estado de sesión para mostrar en cualquier lugar
+ */
+declare function SessionStatus(): react_jsx_runtime.JSX.Element;
+
+interface CrudiaAutoGenerateProps {
+    config: AutoGenerateConfig;
+    value?: string;
+    onChange?: (value: string) => void;
+    label?: string;
+    error?: boolean;
+    helperText?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+}
+/**
+ * Componente para campos autogenerados (códigos secuenciales)
+ *
+ * Características:
+ * - Auto-fetch del código al montar
+ * - Detección automática de errores de duplicado
+ * - Botón "Regenerar" en endAdornment cuando hay error de duplicado
+ * - Estados de loading y error
+ * - Readonly por defecto
+ * - Integración con useAutoGenerate hook
+ *
+ * Flujo de Manejo de Errores de Duplicado:
+ * 1. Usuario abre formulario → Código se genera automáticamente (ej: PROD-0013671)
+ * 2. Usuario llena formulario y hace submit
+ * 3. Backend retorna error "duplicate key" o "unique constraint"
+ * 4. Formulario padre pasa error={true} y helperText="El código ya existe"
+ * 5. Componente detecta palabras clave de duplicado y muestra botón de regenerar
+ * 6. Usuario hace click en botón de regenerar → Nuevo código se genera
+ * 7. onChange se llama con nuevo código → Formulario padre limpia el error
+ * 8. Botón de regenerar desaparece (porque ya no hay error)
+ *
+ * @example
+ * ```tsx
+ * // Uso básico
+ * <CrudiaAutoGenerate
+ *   config={{ prefix: "PROD-", padding: 7 }}
+ *   onChange={(code) => setFormData({ ...formData, barCode: code })}
+ *   label="Código de Barras"
+ * />
+ *
+ * // Con manejo de error de duplicado desde el formulario
+ * <CrudiaAutoGenerate
+ *   config={{ prefix: "PROD-", padding: 7 }}
+ *   onChange={(code) => {
+ *     setFormData({ ...formData, barCode: code });
+ *     // Limpiar error cuando cambia el código
+ *     setFormErrors({ ...formErrors, barCode: null });
+ *   }}
+ *   label="Código de Barras"
+ *   error={!!formErrors.barCode}
+ *   helperText={formErrors.barCode}
+ * />
+ * ```
+ */
+declare const CrudiaAutoGenerate: React.FC<CrudiaAutoGenerateProps>;
+
+/**
+ * File field component with:
+ * - Drag & drop
+ * - File preview
+ * - Progress bar during upload
+ * - Delete files (soft delete)
+ * - Type and size validation
+ * - Single/multiple support
+ */
+
+/**
+ * Deletion handlers exposed by the component
+ */
+interface CrudiaFileFieldDeletionHandlers {
+    /** Execute all pending deletions (call this on form success callback) */
+    commitDeletions: () => Promise<{
+        success: boolean;
+        errors: string[];
+    }>;
+    /** Cancel all pending deletions and restore files */
+    restorePendingDeletions: () => void;
+    /** Whether there are files pending deletion */
+    hasPendingDeletions: boolean;
+    /** Mark the field as submitted (triggers validation errors display) */
+    markAsSubmitted: () => void;
+    /** Whether the field is valid */
+    isValid: boolean;
+    /** Whether files are currently being uploaded */
+    isUploading: boolean;
+    /** Wait for all uploads to complete - returns completed file paths */
+    waitForUploads: () => Promise<string[]>;
+    /** Get completed file paths synchronously (may be stale if uploads just finished) */
+    getCompletedFilePaths: () => string[];
+}
+/**
+ * Props del componente CrudiaFileField
+ */
+interface CrudiaFileFieldProps {
+    /** Label del campo */
+    label?: string;
+    /** Tipos MIME permitidos (ej: ["image/png", "image/jpeg"]) */
+    accept?: string[];
+    /** Tamaño máximo por archivo en bytes */
+    maxFileSize?: number;
+    /** Permitir múltiples archivos */
+    multiple?: boolean;
+    /** Número máximo de archivos (solo si multiple=true) */
+    maxFiles?: number;
+    /** Número mínimo de archivos requeridos */
+    minFiles?: number;
+    /** Campo requerido */
+    required?: boolean;
+    /** Campo deshabilitado */
+    disabled?: boolean;
+    /** Error externo */
+    error?: boolean;
+    /** Texto de ayuda o error */
+    helperText?: string;
+    /**
+     * Callback cuando cambian los filePaths de archivos completados
+     * Los filePaths son rutas relativas con visibility (public/... o private/...)
+     */
+    onChange?: (filePaths: string[]) => void;
+    /** Callback cuando se valida el campo */
+    onValidation?: (isValid: boolean, error: string | null) => void;
+    /** Archivos existentes (para edición) - usar filePath (ruta relativa con visibility) */
+    initialFiles?: Array<{
+        filePath: string;
+        name: string;
+        size?: number;
+        contentType?: string;
+    }>;
+    /** Texto placeholder para drag zone */
+    placeholder?: string;
+    /** Mostrar lista de archivos */
+    showFileList?: boolean;
+    /**
+     * Visibilidad de los archivos subidos
+     * @default "private"
+     */
+    visibility?: "public" | "private";
+    /**
+     * Mostrar preview de imágenes
+     * @default true para imágenes
+     */
+    showPreview?: boolean;
+    /**
+     * URL base para prefijar al path del archivo
+     * El valor guardado será baseUrl + path
+     * También se usa para previsualizar/descargar archivos públicos en modo readonly
+     */
+    baseUrl: string;
+    /**
+     * Callback called when deletion handlers are ready
+     * Use this to get access to commitDeletions and restorePendingDeletions functions
+     */
+    onDeletionHandlersReady?: (handlers: CrudiaFileFieldDeletionHandlers) => void;
+    /**
+     * Form mode: 'create' or 'edit' - affects delete behavior
+     * - create: delete shows confirmation and deletes immediately from server
+     * - edit: existing files use pendingDeletion, new files delete immediately
+     * @default "create"
+     */
+    mode?: "create" | "edit";
+}
+/**
+ * Main file field component
+ *
+ * @example
+ * ```tsx
+ * // Basic usage - single file
+ * <CrudiaFileField
+ *   label="Document"
+ *   accept={["application/pdf"]}
+ *   onChange={(filePaths) => setFormData({ ...formData, document: filePaths[0] })}
+ * />
+ *
+ * // Multiple files with limits
+ * <CrudiaFileField
+ *   label="Images"
+ *   accept={["image/png", "image/jpeg"]}
+ *   multiple
+ *   maxFiles={5}
+ *   minFiles={1}
+ *   maxFileSize={5 * 1024 * 1024}
+ *   onChange={(filePaths) => setFormData({ ...formData, images: filePaths })}
+ * />
+ *
+ * // With initial files (edit mode)
+ * <CrudiaFileField
+ *   label="Attachments"
+ *   multiple
+ *   initialFiles={existingFiles}
+ *   onChange={handleFilesChange}
+ * />
+ * ```
+ */
+declare const CrudiaFileField: React.FC<CrudiaFileFieldProps>;
+
+/**
+ * Markdown field component with rich text editing using MDXEditor
+ * - WYSIWYG markdown editing
+ * - Toolbar with formatting options
+ * - Saves content as markdown string
+ */
+
+interface CrudiaMarkdownFieldProps {
+    /** Field label */
+    label?: string;
+    /** Current value (markdown string) */
+    value?: string;
+    /** Callback when content changes */
+    onChange?: (value: string) => void;
+    /** Required field */
+    required?: boolean;
+    /** Disabled/readonly field */
+    disabled?: boolean;
+    /** External error state */
+    error?: boolean;
+    /** Helper or error text */
+    helperText?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Minimum editor height in pixels */
+    minHeight?: number;
+    /** Maximum editor height in pixels (scrolls after) */
+    maxHeight?: number;
+}
+declare const CrudiaMarkdownField: React.FC<CrudiaMarkdownFieldProps>;
+
+export { type BoxScreenType as B, CrudifyLogin as C, DEFAULT_PASSWORD_RULES as D, type EvaluatedPasswordRule as E, LoginComponent as L, Policies as P, SessionStatus as S, UserProfileDisplay as U, CrudiaAutoGenerate as a, CrudiaFileField as b, CrudiaMarkdownField as c, type CrudifyLoginConfig as d, type CrudifyLoginProps as e, type CrudifyLoginTranslations as f, type UserLoginData as g, type PolicyAction as h, type CrudiaAutoGenerateProps as i, type CrudiaFileFieldProps as j, type CrudiaMarkdownFieldProps as k, type PasswordRule as l, POLICY_ACTIONS as m, PREFERRED_POLICY_ORDER as n, type CrudiaFileFieldDeletionHandlers as o, type PasswordRuleType as p };