markuno_lib 1.1.25 → 1.1.27

package/types/markuno.d.ts

@@ -0,0 +1,552 @@
+export class Ambiente {
+    constructor(cat?: string, maxdelays?: number, righevuote?: boolean);
+    righevuote: boolean;
+    maxdelays: number;
+    setcatalog(cat: any): any;
+    cat: any;
+    item: any;
+    rule: any;
+    model: any;
+    get muvalutatore(): {
+        getcolonne: typeof getcolonne;
+        muCalc: typeof muCalc;
+        muEval: typeof muEval;
+        tipifree: string[];
+    };
+    azzera(mode?: boolean): void;
+    /** @type {Variabile} */
+    vari: Variabile;
+    ruleheader: string;
+    /** @type {Object.<string, Macro>} */
+    macro: {};
+    /** @type {Object.<string, Variante>} */
+    varianti: {};
+    varelenco: {};
+    macroelenco: {};
+    scripts: {};
+    setfndot(fndotcallback: any): Promise<void>;
+    fndotcallback: any;
+    parseheaderfrominfo(tm: any): void;
+    setitem(item: any, rule: any, model: any, datadelgiorno: any): void;
+    data: any;
+    getheader(cod: any): Promise<any>;
+    getalias(): Promise<any>;
+    get deriva(): any;
+    getmacro(riga: any): Promise<{
+        macro: any;
+        pars: string[];
+    } | {
+        macro?: undefined;
+        pars?: undefined;
+    }>;
+    getvariante(cod: any): Promise<any>;
+    varcompila(v: any, callback: any): Promise<void>;
+    macrocompila(v: any, callback: any): Promise<void>;
+    barrecompila(articolibarre: any, titolibarre: any, callback: any): Promise<CodiceBarra>;
+    tojson(d: any): Promise<any>;
+    compila(info: any, callback: any): Promise<void>;
+    getheaderfromdb(name: any): Promise<{
+        head: any;
+        rows: any;
+        macros: any;
+    }>;
+    getlinkedmacros(rule: any, macros: any): Promise<void>;
+    setruleheader(rule: any, pars: any): Promise<any>;
+    getruleheader(): any;
+    setvariante(cod: any, opz: any): Promise<any>;
+    valuta(codice: any): Promise<any>;
+    setinfos(tm: any): void;
+    #private;
+}
+export class CodiceBarra {
+    barre: {};
+    azzera(): void;
+    oriented(t: any, l: any, a: any, p: any): {
+        t: string;
+        x: any;
+        y?: undefined;
+        z?: undefined;
+    } | {
+        t: any;
+        x: any;
+        y: any;
+        z: any;
+    };
+    getcode(codicebarratot: any, l: any, a: any, p: any, callback: any): Promise<any>;
+    compila(vettore: any, headers: any): void;
+}
+export class Macro {
+    constructor(amb: any, name: any);
+    name: any;
+    cat: string;
+    /** @type {Ambiente} */
+    amb: any;
+    azzera(): void;
+    key: string;
+    localvar: {};
+    head: any[] | {
+        cod: any;
+        t: string;
+    }[];
+    frontend: boolean;
+    valid: any[];
+    parametri: {};
+    paralias: {};
+    formula: {};
+    settings: {};
+    errori: any[];
+    codice: any;
+    genera: {};
+    get isgenera(): number;
+    get iscodice(): any;
+    get isheader(): number;
+    geterrori(): any[];
+    getparametri(): {};
+    setparametri(pars: any): Promise<{}>;
+    setparametro(name: any, value: any, propaga?: boolean): Promise<any>;
+    impostaparametri(parimposta: any, parcall: any, ismacro?: boolean): Promise<void>;
+    checkvalid(formula: any): Promise<boolean>;
+    getmacrostr(): string;
+    getmacro(): any;
+    setmacro(vv: any): void;
+    load(xname: any, xcat: any): Promise<boolean>;
+    loadAndCompile(file: any, cat: any, acapo?: boolean): Promise<any>;
+    parsedata(res: any, acapo?: boolean): Promise<void>;
+    cleanfiltraparametri(key: any, codice: any, acapo: any): any[];
+    #private;
+}
+export class Variabile {
+    static isValidKey(key: any): boolean;
+    static sanitizeKey(key: any): any;
+    dictionary: {};
+    vec: any[];
+    counter: number;
+    setfndot(fndotcallback: any): void;
+    fndotcallback: any;
+    /**
+         * Salva lo stato corrente delle variabili nello stack
+         */ push(): void;
+    /**
+         * Ripristina l'ultimo stato salvato delle variabili
+         */ pop(): void;
+    /**
+         * Rimuove tutte le variabili e pulisce lo stack
+         */ clear(): void;
+    azzera: () => void;
+    var(key: any): any;
+    getvar(key: any): any;
+    colonna(value: any, index: any): any;
+    /**
+         * Restituisce un dump delle variabili
+         */ dump(isstr?: boolean): string[] | {
+        cod: string;
+        val: any;
+    }[];
+    /**
+         * Aggiunge o rimuove una variabile
+         */ add(key: any, value: any): void;
+    /**
+         * Valuta un'espressione con supporto per callback asincroni
+         */ valutasync(str: any): any;
+    valuta(ex: any, callback: any): Promise<any>;
+    parametrokeyval(p: any): Promise<{
+        k?: undefined;
+        v?: undefined;
+    } | {
+        k: any;
+        v: any;
+    }>;
+}
+/**
+ * Classe per gestire le varianti di un prodotto.
+ * Permette di caricare, manipolare e convertire varianti di prodotto con relativi attributi e limiti.
+ * @class
+ * @exports
+ */ export class Variante {
+    /**
+         * Crea una nuova istanza di Variante
+         * @param {Object} amb - Ambiente di esecuzione contenente il contesto applicativo
+         */
+    constructor(amb: any);
+    rows: {};
+    name: string;
+    key: string;
+    /** @type {Ambiente} */
+    amb: any;
+    /**
+         * Imposta i dati principali della variante
+         * @param {string} id - Identificativo univoco della variante
+         * @param {string} cat - Categoria di appartenenza
+         * @returns {Object} Oggetto contenente nome e categoria normalizzati
+         */ setheader(id: string, cat: string): any;
+    cat: string;
+    alias: string;
+    obbligo: boolean;
+    des: any;
+    vdef: any[] | string[];
+    h: any[] | {
+        des: string;
+    }[];
+    /**
+         * Cerca la riga con dimensione più vicina a quella richiesta
+         * @param {number|string} dim - Dimensione target da cercare
+         * @param {number} colonna - Indice della colonna (1-based) contenente la dimensione
+         * @returns {string} Riga formattata nel formato CSV
+         */ fromdim(dim: number | string, colonna?: number): string;
+    /**
+         * Carica una variante dal database o da file
+         * @param {string} id - Identificativo della variante
+         * @param {string} cat - Categoria della variante
+         * @param {boolean} nofilter - Se true, non carica i filtri associati
+         * @returns {Promise<boolean>} Promise che risolve a true se il caricamento ha successo
+         */ load(id: string, cat: string, nofilter?: boolean): Promise<boolean>;
+    limits: {}[] | {
+        v: any[];
+        datai: number;
+        dataf: number;
+    }[];
+    /**
+         * Carica il contenuto della variante da array di stringhe
+         * @private
+         * @param {string[]} lines - Array di stringhe contenenti la definizione della variante
+         * @returns {Promise<boolean>} Promise che risolve a true se il caricamento ha successo
+         */ private _loadContent;
+    noerp: boolean;
+    /**
+         * Converte la variante in un vettore di righe
+         * @returns {string[]} Array di righe formattate
+         */ tovec(): string[];
+    /**
+         * Converte un codice nella sua rappresentazione CSV
+         * @param {string} cod - Codice da convertire
+         * @returns {string} Stringa CSV o codice originale se non trovato
+         */ tovar(cod: string, vcod?: string): string;
+    /**
+         * Verifica se un'opzione è valida
+         * @param {string} opz - Opzione da verificare
+         * @returns {boolean} True se l'opzione è valida
+         */ isvalidopz(opz: string): boolean;
+    /**
+         * Trova la prima opzione valida tra quelle disponibili
+         * @param {string} opz - Opzione da controllare per prima
+         * @returns {string|undefined} Prima opzione valida trovata o undefined
+         */ firstvalid(opz: string): string | undefined;
+    /**
+         * Resetta tutti i filtri applicati alla variante
+         */ resetfilter(): void;
+    /**
+         * Restituisce le chiavi valide ordinate alfabeticamente
+         * @returns {string[]} Array di chiavi valide
+         */ validkeys(): string[];
+    limitfiltra(filtra: any): void;
+    /**
+         * Applica i limiti configurati alle opzioni della variante
+         * @returns {Array|void} Array di limiti applicati o void se reset
+         */ limita(filtra: any): any[] | void;
+    /**
+         * Carica il contenuto esteso della variante
+         * @param {Object|string} content - Contenuto da caricare, può essere un oggetto o una stringa
+         * @returns {Promise<void>} Promise che si risolve al completamento del caricamento
+         */ loadContentExtended(content: any | string): Promise<void>;
+    todata(): {
+        name: string;
+        des: any;
+        alias: string;
+        obbligo: boolean;
+        h: any[] | {
+            des: string;
+        }[];
+        rows: {};
+        limits: {}[] | {
+            v: any[];
+            datai: number;
+            dataf: number;
+        }[];
+        key: string;
+    };
+    #private;
+}
+/**
+ * Valida e separa un identificatore e una categoria
+ * @param {string} id - Identificatore da validare (formato: "categoria/nome" o solo "nome")
+ * @param {string} cat - Categoria di default
+ * @throws {Error} Se manca la categoria
+ * @returns {{name: string, cat: string}} Oggetto con nome e categoria validati
+ */ export function checkmu(id: string, cat: string): {
+    name: string;
+    cat: string;
+};
+/**
+ * Valida un identificatore verificando che contenga solo caratteri permessi
+ * @param {string} id - Identificatore da validare
+ * @throws {Error} Se l'identificatore contiene caratteri non validi
+ * @returns {string} Identificatore validato in minuscolo
+ */ export function checkname(id: string): string;
+export function clamp(n: any, min?: number, max?: number): any;
+export function clean(k: any, locase?: boolean): any;
+export function dammivariante(amb: any, macro: any, ky: any): Promise<any>;
+export const errori: {
+    /**
+         * Azzera la lista degli errori
+         */ azzera(): void;
+    err: any[];
+    /**
+         * Aggiunge un errore alla lista
+         * @param {string} msg - Messaggio di errore
+         * @param {Object} row - Informazioni aggiuntive sull'errore
+         */ add(msg: string, row: any): void;
+    /**
+         * Restituisce la lista completa degli errori
+         * @returns {Array} Lista degli errori
+         */ get(): any[];
+    /**
+         * Restituisce il numero di errori presenti
+         * @returns {number} Numero di errori
+         */ readonly length: number;
+    /**
+         * Converte la lista degli errori in stringa
+         * @returns {string} Rappresentazione testuale degli errori
+         */ toString(): string;
+};
+/**
+ * Converte una stringa in un oggetto JSON, gestendo errori e restituendo un valore di default se non valido
+ * @param {string|Array|Object} str - Stringa da convertire in JSON, array o oggetto da restituire direttamente
+ * @param {*} [def={}] - Valore di default da restituire in caso di errore di parsing
+ * @throws {Error} Non genera eccezioni, gli errori vengono loggati internamente
+ * @returns {*} L'oggetto JSON convertito dalla stringa, l'input originale se è un array/oggetto, o il valore di default in caso di errore
+ * @example
+ * fromjson('{"a": 1}') // returns {a: 1}
+ * fromjson([1,2,3]) // returns [1,2,3]
+ * fromjson('invalid json', {}) // returns {}
+ */ export function fromjson(str: string | any[] | any, def?: any): any;
+/**
+ * Estrae le proprietà non-funzione da un oggetto, escludendo chiavi specificate
+ * @param {Object} obj - Oggetto da cui estrarre le proprietà
+ * @param {string[]} [exclude] - Array di chiavi da escludere
+ * @returns {Object} Nuovo oggetto con le proprietà estratte
+ */ export function getOggetto(obj: any, exclude?: string[]): any;
+/**
+ * Converte una stringa in array di colonne, gestendo diversi formati
+ * @param {string} value - Stringa da convertire
+ * @returns {string[]} Array di colonne
+ */ export function getcolonne(value: string, keepquote?: boolean): string[];
+/**
+ * Analizza una stringa per estrarre una coppia chiave-valore
+ * @param {string} r - Stringa da analizzare (es: "chiave=valore")
+ * @param {string} [sep='='] - Carattere separatore
+ * @returns {{v: string, o: string, fl: boolean}} Oggetto contenente chiave (v), valore (o) e flag presenza separatore (fl)
+ */ export function getcouple(r: string, sep?: string, locase?: boolean): {
+    v: string;
+    o: string;
+    fl: boolean;
+};
+/**
+ * Formatta un messaggio di errore rimuovendo informazioni non necessarie
+ * @param {Error|string} err - L'errore da formattare
+ * @returns {string} Il messaggio di errore formattato
+ */ export function geterrdes(err: Error | string): string;
+export function getheaddims(dims: any): any;
+export function gettipocolonna(cod: any): string;
+export function gettipofolder(cod: any): string;
+export function hash(obj: any): string;
+export function impostavariante(amb: any, macro: any, a: any, b: any, head: any): Promise<any>;
+export function intvaluta(amb: any, mac: any, str: any): Promise<any>;
+export function muInit(cat: any, cbGetMacro: any, cbGetVariante: any, cbFunc: any, cbInfo: any, cbGetFile: any, cbLogga: any): Ambiente;
+/**
+ * Funzione di logging che utilizza un callback personalizzato se disponibile
+ * @param {...any} args - Argomenti da loggare
+ */ export function logga(...args: any[]): void;
+/**
+ * Valuta un'espressione matematica o logica e restituisce il risultato
+ * @param {string|number} expression - L'espressione da valutare
+ * @returns {number} Il risultato della valutazione dell'espressione
+ * @description
+ * Supporta operazioni matematiche di base, funzioni trigonometriche,
+ * operatori di confronto e operazioni logiche.
+ * Le funzioni supportate includono: sqrt, floor, abs, sin, cos, random, clamp, round
+ */ export function muCalc(expression: string | number): number;
+/**
+ * Rimuove i commenti dal codice sorgente mantenendo la struttura del codice
+ * @param {string} codice - Il codice sorgente da processare
+ * @param {boolean} tienivuoti - Se true mantiene le righe vuote
+ * @returns {string[]} Array di righe di codice senza commenti
+ */ export function muClComments(codice: string, tienivuoti: boolean): string[];
+/**
+ * Analizza e organizza il codice in una struttura dati gerarchica
+ * @param {string[]} tt - Array di righe di codice da analizzare
+ * @param {boolean} acapo - Se true mantiene i ritorni a capo nel contenuto
+ * @returns {Object[]} Array di oggetti rappresentanti la struttura del codice
+ * @throws {Error} Se tt non è un array
+ */ export function muClean(tt: string[], acapo?: boolean): any[];
+export function muCompileScript(codice: any): any;
+export function muEval(amb: any, mac: any, codice: any, options: any): any;
+export function muEvalScript(amb: Ambiente, codice: any, pars: any, reset?: boolean): Promise<{
+    output: any;
+    vari: {};
+    errori: {
+        /**
+             * Azzera la lista degli errori
+             */ azzera(): void;
+        err: any[];
+        /**
+             * Aggiunge un errore alla lista
+             * @param {string} msg - Messaggio di errore
+             * @param {Object} row - Informazioni aggiuntive sull'errore
+             */ add(msg: string, row: any): void;
+        /**
+             * Restituisce la lista completa degli errori
+             * @returns {Array} Lista degli errori
+             */ get(): any[];
+        /**
+             * Restituisce il numero di errori presenti
+             * @returns {number} Numero di errori
+             */ readonly length: number;
+        /**
+             * Converte la lista degli errori in stringa
+             * @returns {string} Rappresentazione testuale degli errori
+             */ toString(): string;
+    };
+}>;
+export function muGenerate(macro: any, amb: any, genera: any, callback: any, isTestmode?: number): Promise<boolean>;
+/**
+ * Analizza e processa i limiti definiti nel codice
+ * @param {string} dati - Dati contenenti le definizioni dei limiti
+ * @returns {Object[]} Array di oggetti rappresentanti i limiti processati
+ */ export function muLimits(dati: string): any[];
+/**
+ * Analizza il codice sorgente e restituisce un array di token con classi CSS
+ * @param {string} tt - Il codice sorgente da analizzare
+ * @param {boolean} isvar - Flag che indica se analizzare come variabile
+ * @returns {Array<{class: string, text: string}>} Array di token con classi CSS
+ */ export function muParsecode(tt: string, isvar: boolean): Array<{
+    class: string;
+    text: string;
+}>;
+export function muValuta(mu: any, codice: any, azzera: any): any;
+export namespace mustr {
+    namespace mus {
+        namespace variants {
+            let cod: string;
+            let des: string;
+            let alias: string;
+            let info: string;
+            let md: string;
+            let __pk: string;
+        }
+        namespace extras {
+            export let tipo: string;
+            let cod_1: string;
+            export { cod_1 as cod };
+            let info_1: string;
+            export { info_1 as info };
+            let __pk_1: string;
+            export { __pk_1 as __pk };
+        }
+        namespace macros {
+            let cod_2: string;
+            export { cod_2 as cod };
+            let des_1: string;
+            export { des_1 as des };
+            let info_2: string;
+            export { info_2 as info };
+            let md_1: string;
+            export { md_1 as md };
+            export let def: string;
+            export let isgenera: string;
+            export let iscodice: string;
+            export let isheader: string;
+            let __pk_2: string;
+            export { __pk_2 as __pk };
+        }
+        namespace infos {
+            let cod_3: string;
+            export { cod_3 as cod };
+            let des_2: string;
+            export { des_2 as des };
+            let info_3: string;
+            export { info_3 as info };
+            let __pk_3: string;
+            export { __pk_3 as __pk };
+        }
+        namespace barcodes {
+            let cod_4: string;
+            export { cod_4 as cod };
+            let des_3: string;
+            export { des_3 as des };
+            let info_4: string;
+            export { info_4 as info };
+            let __pk_4: string;
+            export { __pk_4 as __pk };
+        }
+    }
+}
+export function newAmbiente(cat: any, maxmillis?: number): Ambiente;
+export function newMacro(amb: any, name: any): Macro;
+export function newVariabile(): Variabile;
+export function newVariante(cod: any, cat: any, amb: any): Promise<Variante>;
+export function parselimitifromdb(rr: any): {}[];
+export function parselimitifromrule(limvec: any): {
+    v: any[];
+    datai: number;
+    dataf: number;
+}[];
+/**
+ * Analizza variabili in un'espressione usando delimitatori
+ * @param {string} ex - Espressione da analizzare
+ * @param {number} k0 - Posizione iniziale
+ * @param {string} inipar - Delimitatore iniziale ([, (, {)
+ * @param {string} endpar - Delimitatore finale (], ), })
+ * @param {boolean} [nonewline=false] - Se true, termina all'incontro di un newline
+ * @returns {{i: number, res: string[]}} Risultato dell'analisi con posizione finale e array risultati
+ */ export function parsevar(ex: string, k0: number, inipar: string, endpar: string, nonewline?: boolean): {
+    i: number;
+    res: string[];
+};
+export function poppars(amb: any, tm: any): Promise<void>;
+export function pushpars(amb: any, macro: any, parsfunzione: any, parsinit: any): Promise<{
+    v: string;
+    o: any;
+}[]>;
+export function quote(v: any): any;
+/**
+ * Classe per la gestione degli errori con funzionalità di accumulo e formattazione
+ */
+/**
+ * Copia le proprietà non-funzione da un oggetto sorgente a uno destinazione
+ * @param {Object} objDestinazione - Oggetto destinazione
+ * @param {Object} objSorgente - Oggetto sorgente
+ */
+export function setOggetto(objDestinazione: any, objSorgente: any): void;
+/**
+ * Esegue una semplice somma sincrona di due numeri
+ * @param {number} a - Primo numero da sommare
+ * @param {number} b - Secondo numero da sommare
+ * @returns {number} La somma dei due numeri
+ */
+export function testsync(a: number, b: number): number;
+export const tipicolonna: ({
+    cod: string;
+    des: string;
+    folder?: undefined;
+} | {
+    cod: string;
+    des: string;
+    folder: string;
+})[];
+export const tipifree: string[];
+export const tipiheader: {
+    cod: string;
+    des: string;
+}[];
+/**
+ * Restituisce il timestamp corrente in millisecondi
+ * @returns {number} Timestamp corrente
+ */ export function tk(): number;
+export function toCadPars(str: any): {};
+export function toJson(t: any): string;
+export function tonum(s: any, dec?: number): number;
+/**
+ * Restituisce il timestamp corrente in millisecondi
+ * @returns {number} Timestamp corrente
+ */ export function xdt(): number;
+export { muInit as jsTest };