API de la librería Ingra 9
Sección: js
Módulo: ingra..js
| globalThis.ingra | Clase base de la librería ingra |
| Básicos numéricos (M) | |
| globalThis.ingra.red (num, dec) | Redondea num a dec decimales. dec==null coma flotante, dec<0 redondea no formatea |
| globalThis.ingra.iguales (r1, r2, dec=8) | Son iguales los números reales a y b redondeados con dec decimales |
| globalThis.ingra.ac (num, dec, presentaCero, omas) | Convierte a cadena; presentaCero por defecto cadana vacia si 0; omas pone dec decimales o más |
| globalThis.ingra.dc (a, dec) | Convierte de cadena a número |
| globalThis.ingra.ceros (a, tam, pad='0') | Retorna cadena añadiendo por delante a 'a', 'pad' hasta tamaño 'tam' (String(a).padStart(tam,pad)) o si tam<0 añade por detrás (String(a).padEnd(-tam,pad)) |
| globalThis.ingra.aleatorio (n) | Retorna numero aleatorio entre 0..n-1 (Math.round(Math.random()*(n-1))) |
| globalThis.ingra.recta (x1, y1, x2, y2, x) | Devuelve 'y' para la abscisa 'x', que esté en la recta de los 2 primeros puntos (semajanza de triángulos de Tales). Admite (x1,y1,x) |
| globalThis.ingra.entre (x1, x2, x, margen=0) | ¿Está x entre x1 y x2? (1)ok (null)exterior |
| Básicos de Listas (L) | |
| globalThis.ingra.dl (ds, codo=null) | De objeto índice {...} a lista [...] |
| globalThis.ingra.ds (dl, cod, codo=null) | De lista [...] a objeto índice {...}, cod: "a" o ["a",...], codo:dl[codo][cod](opcional) |
| globalThis.ingra.cl (dl, cod, _ordenada) | De lista de objetos a lista de un campo (si ordenada implica única y sin nulos) |
| globalThis.ingra.ao (o, ...vl) | OBSOLETA usar objeto literal. De lista a objeto (cod,val, cod,val, ...) | (objeto, cod,val,...) | (objeto,objeto, cod,val,... ) |
| globalThis.ingra.suma (dl, el) | Suma vectores (vector_numérico) o (vector_objetos, campo[.campo]) o (vector_numerico, vector_numérico) o (vector_numerico, constante) |
| globalThis.ingra.resta (dl, el) | Resta vectores (vector_numerico, vector_numérico) o (vector_numerico, constante) |
| Básicos de cadenas (S) | |
| globalThis.ingra.modo (texto, letra, noexiste, novalor, minimo, maximo) | Analiza modo en cadena con formato: <modo=letra><valor=numero>..., noexiste:0,novalor:1 |
| globalThis.ingra.modos (texto, defectos, conVectores) | Analiza modos en cadena con formato: <modo=letra><valor=numero>... > {letra:numero | letra:[numero]} |
| globalThis.ingra.modos2 (texto, defectos) | Analiza modos en cadena con formato: <modo=letra><valor=numero>... > {letra:numero | letra:[numero]} |
| globalThis.ingra.opcion (i, ...al) | Devuelve índice base Opción |
| globalThis.ingra.compara (a, b, descendente) | Compara a > b ? 1 : a < b ? -1 : 0, si descendente al contrario |
| Básicos de archivos (F) (ruta: protocolo//camino/nombre.extension#marcador?parametos) | |
| globalThis.ingra.ruta2o (ruta) | De cadena ruta a objeto ruta con su despiece: pro//cam/nom.ext#mar?par > {pro, cam,arc,nom,ext, alm,par} |
| globalThis.ingra.o2ruta (o) | Del objeto ruta a cadena ruta: {pro, cam,nom,ext, alm,par} > pro//cam/nom.ext#mar?par) |
| globalThis.ingra.camino (ruta) | Camino de la ruta |
| globalThis.ingra.nombre (ruta, conExtension) | Nombre de la ruta (conExtension obsoleto usar archivo()) |
| globalThis.ingra.extension (ruta, ponExtension) | Extensión de la ruta (ponExtension obsoleto usar ponExtension()) |
| globalThis.ingra.archivo (ruta) | Archivo de la ruta (nombre y extension) |
| globalThis.ingra.ponCamino (ruta, camino) | Cambia el camino de la ruta |
| globalThis.ingra.ponNombre (ruta, nombre) | Cambia el nombre de la ruta (mantiene la extensión) |
| globalThis.ingra.ponExtension (ruta, extension) | Cambia la extensión de la ruta |
| globalThis.ingra.ponArchivo (ruta, archivo) | Cambia el archivo de la ruta (nombre y extension) |
| Básicos de objetos (O) Tipos de datos | |
| globalThis.ingra.esI (o) | Es Integer = Number.isInteger(o) |
| globalThis.ingra.esN (o) | Es Number = Number.isFinite(o) |
| globalThis.ingra.esA (o) | Es Array = Array.isArray(o) |
| globalThis.ingra.esB (o) | Es Boolean (o.constructor === Boolean) |
| globalThis.ingra.esS (o) | Es String (o.constructor === String) |
| globalThis.ingra.esD (o) | Es Date (o instanceof Date) |
| globalThis.ingra.esR (o) | Es RegExp (o instanceof RegExp) |
| globalThis.ingra.esO (o) | Es Object (o instanceof Object) |
| globalThis.ingra.esF (o) | Es Function (o instanceof Function) |
| globalThis.ingra.cbDefecto (r) | cb de defecto, si error presenta en consola |
| globalThis.ingra.cbDialogo (r) | si r.error lo presenta dialogoError, si r.mensaje presenta dialogoInforma |
Módulo: ingra.B..js
| ingra.B | Clase ArrayBuffer; representa un genérico buffer de datos binarios en memoria de longitud fija, no se puede manipular el contenido |
| ingra.B.deFile (file, cb, cbProgress) | De File a ArrayBuffer; utiliza FileReader |
| ingra.B.deCanvas (canvas) | De Canvas a Uint8ClampedArray; utiliza ImageData |
| ingra.B.deString (str) | De cadena a buffer |
| ingra.B.deBase64 (base64) | De base64 a buffer |
| ingra.B.deDataUrl (dataUrl) | De dataURL "data:<mime>;base64,<base64>" a buffer |
| ingra.B.deBlob (blob, cb) | De blob a buffer |
| ingra.B.aString (buf) | A cadena |
| ingra.B.aBlob (buffer, type) | A blob |
| ingra.B.aArray (typedArray) | A array normal, = Array.from, constructor === Array, |
| ingra.B.aBase64 (buf) | A base64 |
| ingra.B.get (url, cb) | Recibe buffer de una URL |
| ingra.B.post (url, buffer, cb) | Envia buffer a una URL; El metodo send() de las instancias XMLHttpRequest ahora admite vectores tipados y objetos ArrayBuffer como argumento. |
| ingra.B.dc (str) | De cadena a buffer ; usa charCodeAt(16unicode) > Uint16Array |
| ingra.B.ac (buf) | De buffer a cadena; Uint16Array > String.fromCharCode(16unicode) |
| ingra.B.ac16 (buf) | De buffer a cadena; Uint16Array > String.fromCharCode(16unicode) |
| ingra.B.dc16 (str) | De cadena a buffer ; usa charCodeAt(16unicode) > Uint16Array |
| ingra.B.igual (a, b) | Compara buffers |
| ingra.blob | Clase (Binary Large OBjects), representación de datos en bruto en disco Blob:{name,size,type,...} |
| ingra.blob.deBase64 (base64, mime) | Convierte de base 64 |
| ingra.blob.deDataUrl (dataUrl) | Convierte de data url > deBase64 |
| ingra.blob.deCanvas (canvas, cb, type, quality) | De canvas type:"image/png"(/jpeg/webp); quality:0.95(0..1) > deDataUrl > (blob) |
| ingra.blob.deImage (image) | De image |
| ingra.blob.deTexto (texto, mime) | Convierte de texto; mime:'text/css'|'text/html'|... |
| ingra.blob.aImage (blob, image) | Retorna image.src |
| ingra.blob.aDataUrl (blob) | Añade un link desde blob |
| ingra.blob.aLink (div, blob) | Añade un link desde blob |
| ingra.base64 | Usa caracteres "A-Z", "a-z", "0-9", "+", "/" y "=" para codificar binarios |
| ingra.base64.dc (str) | De cadena a base64 == window.atob |
| ingra.base64.ac (b64) | De base64 a cadena == window.btoa |
| ingra.dataUrl | Clase dataUrl |
| ingra.dataUrl.deTexto (texto, type='text/plain') | De texto > dataUrl |
| ingra.dataUrl.deBlob (blob, cb) | De blob|file > ({dataUrl}) |
| ingra.dataUrl.deUrl (url, cb) | De url > {dataUrl} |
| ingra.dataUrl.deImg (img, op) | De imagen op:{formato:jpg*|jpeg|png|webp, calidad:0.85, alto[Mm], ancho[Mm], maximo[Mm]} > canvas > {ancho[Mm],alto[Mm],dataUrl} |
| ingra.dataUrl.deImgSrc (src, op, cb) | De imagen (source) op:{formato:jpg*|jpeg|png|webp, calidad:0.85, alto[Mm], ancho[Mm], maximo[Mm]} > Image load > deImg |
Módulo: ingra.D..js
| ingra.D | Clase date. Generales de tiempo, fecha y hora |
| ingra.D.fec (d) | De date a fecha (aaaammdd) |
| ingra.D.hor (d) | De date a hora (hhmmss) |
| ingra.D.fechor (d) | De date a fechahora (aaaammdd.hhmmss) |
| ingra.D.fechor2 (d) | De date a [fecha,hora] (aaaammdd.hhmmss) |
| ingra.D.diaSemana (d) | De date a día de la semana (0)lunes (1)martes ... (7)domingo |
| ingra.D.ao (d) | De date a objeto >{a,m,d,h,mi,s, ms} |
| ingra.D.id2 (d, sep='.', conMs) | De date a formato: aaaammdd.hhmmss[ii]; con milisegundos |
| ingra.D.id3 (d, sep='.') | De date a formato: aaaammdd.hhmmssii |
| ingra.D.ac (d) | De date a formato: "d/m/a h:m:s" |
| ingra.D.forma (d, frm) | De date a formato frm: aaaa(2020) | aa(20) | mmmm(Marzo) | mmm(Mar) | mm(03) | dddd(Martes) | ddd(Mar) | dd(11) | hh(12) | mm(18) | ss(32) Ejemplo:" dddd, d de mmmm de aaaa" |
| ingra.D.am (d) | De date a formato "aaaa-mm" |
| ingra.D.amd (d) | De date a formato "aaaa-mm-dd" |
| ingra.D.amd2 (d) | De date a formato "aaaammdd-hhmmssii" (ISO: aaaa-mm-ddThh:mm:ss.iiiZ 2012-11-30T01:21:00.000Z)" |
| ingra.D.aFH (d) | De Date a fecha y hora > [fec,hor] |
| A date | |
| ingra.D.dc (a) | A date desde formato "d/m/a h:m:s" con cualquier separador |
| ingra.D.pon (a, b) | A date desde (fec,hor) | (fechor) | (Date) | (año, mes, día, horas, minutos, segundos, milisegundos) | (milliseconds) | (isodate String) |
| ingra.D.deFH (fec, hor) | A date desde fecha y hora; admite (fec,hor) o (fechor) |
| ingra.D.deAMDHMS (ano, mes, dia, hrs, min, seg, ms) | A date desde AMDHMS |
| ingra.D.deDMAHMS (dia, mes, ano, hrs, min, seg, ms) | A date desde DMAHMS |
| Varios | |
| ingra.D.ms2a (ms) | De milisegundos a cadena "HHhMMmSSsIIIms" |
| ingra.D.cuantasVeces (tiempo, funcion) | Cuenta veces se ejecuta 'funcion' en 'tiempo' |
| ingra.D.cuantoTiempo (funcion) | Cuenta tiempo (ms) tarda 'funcion' en ejecutarse |
| ingra.fec | Clase fecha entero con formato AAAAMMDD |
| ingra.fec.pon (d, m, a, noAdmiteIncompleta) | Retorna fecha desde (d,m,a) o (Date) o {d,m,a} o (fec) o (a,m,d); |
| ingra.fec.completa (fec) | Retorna fecha completa; debe incluir d,m,a |
| ingra.fec.actual () | Retorna fecha actual |
| ingra.fec.mesAnterior () | Primer día del mes anterior |
| ingra.fec.dia (fec, dia) | Dias de fec (0..31). Si dia retorna fec con dia |
| ingra.fec.mes (fec, mes) | Mes de fec (0..12). Si mes retorna fec con mes |
| ingra.fec.ano (fec, ano) | Año de fec (aaaa). Si ano retorna fec con año |
| ingra.fec.mesNombre (fec) | Nombre del mes de fec (Enero,..) |
| ingra.fec.diaNombre (fec) | Nombre del mdía de fec (Lunes,...) |
| ingra.fec.aDate (fec) | De fec a Date |
| ingra.fec.agrega (fec, d, m, a) | Agrega d(dias) m(meses) a(anos) a fec, d,m,a pueden ser negativos; fec opcional (defecto hoy) |
| ingra.fec.semanaAno (fec) | Nº de semana en el año 1..52 + restos(0,53) |
| ingra.fec.semanaAnoBuffer (fec, buffer) | Nº semana en el año (con buffer para llamadas repetidas) 0..51 (restos a 0 y 51) |
| ingra.fec.diaSemana (fec, comoTexto) | Retorna nombre del día de la semana con 0:LUNES. Admite param. (d,m,a) |
| ingra.fec.diaSemana1 (sem, ano) | Retorna nombre de primer dia de la semana sem |
| diasMes1 | Días del año al comienzo de cada mes (no bisiestos) |
| diasMes2 | Días de cada mes (año no bisiesto) |
| diasMes2.bisiesto (ano) | Retorna true|false |
| diasMes2.diasAno (ano) | Días del año (365 o 366 bisiestos) (ano) o (fec) > nºdias |
| diasMes2.diasMes (mes, ano) | Días del mes. También admite sólo un param (fec) - fecmesdia |
| diasMes2.diasHasta (fec) | Número de dias del año - fecanodia |
| diasMes2.mesesEntre (f1, f2) | Nº de meses entre fechas |
| diasMes2.diasEntre (f1, f2) | Nº de días entre fechas |
| diasMes2.anos (fec) | Fecha en años en decimal |
| diasMes2.nombre (fec, breve) | Formato como '12 Agosto 2009' o 'Ago 2008', incompletas por la izquierda - fec2nom |
| diasMes2.forma (fec, f) | Formato (admite varios) f: aaaa|mmmm|mmm|mm|dddd|ddd|dd|hh|nn|ss|a - fec2forma |
| diasMes2.ao (fec) | De fecha a objeto, aaaammdd > {a,m,d} |
| diasMes2.do (o) | De objeto a fecha, {a,m,d} > aaaammdd |
| diasMes2.ac (fec, op) | Formato a cadena, op:sep|{sep:'/', conceros:1, diaSemana, sinhoy, concolor, defecto}, (diaSemana>0)nºcaracteres |
| diasMes2.dc (a, noAdmiteIncompleta) | Formato de cadena - str2fec |
| ingra.hor | Clase hora entero con formato HHMMSS |
| ingra.hor.pon (h, m, s, esIntervalo) | Retorna hor, admite Date; h,m,s; si !intervalo h:0..24 |
| ingra.hor.actual () | Retorna hor actual |
| ingra.hor.seg (hor, s) | Segundos de 'hor'. Con s(segundos) retorna hor con s incluidos |
| ingra.hor.min (hor, m) | Minutos de 'hor'. Con m(minutos) retorna hor con m incluidos |
| ingra.hor.hrs (hor, h) | Horas de 'hor'. Con h(horas) retorna hor con h incluidas |
| ingra.hor.entre (hor1, hor2) | retorna hora entre dos horas |
| ingra.hor.media (hor1, hor2) | retorna hora media entre dos horas |
| ingra.hor.agrega (hor, h, m, s) | Agrega a hor h(horas), m(minutos) y s(segundos)) |
| ingra.hor.aHoras (hor) | De hor a horas decimales |
| ingra.hor.deHoras (horas) | De horas decimale a hor |
| ingra.hor.ao (hor) | De hor a objeto {h,m,s} |
| ingra.hor.ac (hor, sep=':', def=[2, 2, 2], esPeriodo) | Retorna cadena hh:mm:ss; def dígitos en h,m,s; si esPeriodo retorna h:m:s |
| ingra.hor.dc (a) | Retorna hor desde cadena; trocea cadena con cualquier separador no numérico; '.' hora actual |
| ingra.fechor | Clase número real en formato aaammdd.hhmmss |
| ingra.fechor.actual () | Retorna fh actual |
| ingra.fechor.forma (fh) | Retorna fh desde number, string, date o array |
| ingra.fechor.pon (dia, mes, ano, hrs, min, seg, noAdmiteIncompleta) | Retorna fh; admite (fec,hor), (ano,mes,dia) |
| ingra.fechor.agrega (fec, d, m, a, h, mi, s) | Agrega d(dias) m(meses) a(anos) a fec, d,m,a pueden ser negativos; fec opcional (defecto hoy) |
| ingra.fechor.aFH (fh) | Retorna [fec,hor] de fh |
| ingra.fechor.deFH (f, h) | Retorna fh desde [fec,hor] |
| ingra.fechor.aDate (fh) | Retorna Date |
| ingra.fechor.deDate (d) | Retorna fh desde Date |
| ingra.fechor.aJSON (fh) | Retorna formato ISO: 2013-04-14T18:26:46.613Z |
| ingra.fechor.fec (fh) | Retorna la fecha de fh |
| ingra.fechor.hor (fh) | Retorna la hora de fh |
| ingra.fechor.hrs (fh) | Retorna las horas decimales de fh |
| ingra.fechor.ao (fh) | Retorna objeto > {a,m,d,h,mi,s} |
| ingra.fechor.ac (fh, op) | Retorna "d/m/a h:m:s"; con número de dígitos, op:{sep:'/', conceros:1, diaSemana, sinhoy, concolor}, (diaSemana>0)nºcaracteres |
| ingra.fechor.dc (a) | De cadena "d/m/a h:m:s" a fh; admite cualquier separador; '.' o '/' retorna actual; admite ISO |
| ingra.fechor.diferencia (fh1, fh2) | Retorna diferencia entre fhs en horas decimales |
| ingra.diames | Clase número entero en formato mmdd |
| ingra.diames.pon (d, m) | Retorna dm |
| ingra.diames.actual () | Retorna dm actual |
| ingra.diames.agrega (dm, d, m) | Retorna dm incrementado en d(dias), m(meses) |
| ingra.diames.ac (dm, sep='/', num=2) | Retorna "dd/mm"; num(número de cifras) |
| ingra.diames.dc (a) | Retorna fh de cadena "d/m" con cualquier separador; '.' retorna fh actual |
| ingra.mesano | Clase número entero en formato aaaamm |
| ingra.mesano.pon (m, a) | Retorna ma |
| ingra.mesano.actual () | Retorna ma actual |
| ingra.mesano.agrega (ma, m, a) | Retorna ma incrementado en m(meses) a(años) |
| ingra.mesano.dentro (fec, md1, md2) | fec está entre md1 y md2 |
| ingra.mesano.ao (ma) | Retorna objeto {a,m} |
| ingra.mesano.ac (ma, alfa) | Retorna "mm/aaaa"; alfa: "nombresMes aaaa" |
| ingra.mesano.dc (s) | Retorna ma de cadena "m/a" con cualquier separador; '.' retorna ma actual |
Módulo: ingra.F.js
| ingra.F | Gestión de archivos locales Presenta diálogo del sistema operativo - file:{ name:"a.png", size:47744, type:"image/png", lastModifiedDate } |
| ingra.F.lee (op, cb) | Lee archivo local como texto UTF8, op:{cbProgress} > (data,file,ev) |
| ingra.F.leeAnsi (op, cb) | Lee archivo local como texto ANSI, op:{cbProgress} > (data,file,ev) |
| ingra.F.leeJson (op, cb) | Lee archivo local como JSON, op:{cbProgress} > (objJs,file,ev) |
| ingra.F.leeDataUrl (op, cb) | Lee archivo local como DataUrl, op:{cbProgress} > (dataUrl,file,ev) |
| ingra.F.leeBuffer (op, cb) | Lee archivo local como Buffer, op:{cbProgress} > (buffer,file,ev) |
| Graba archivo local Presenta diálogo del sistema operativo |
|
| ingra.F.graba (name, texto) | Graba archivo de texto utf8 |
| ingra.F.grabaAnsi (name, texto) | Graba archivo de texto ansi |
| ingra.F.grabaBinario (name, buffer) | Graba archivo binario |
| ingra.F.grabaCanvas (name, canvas, quality) | Graba archivo con el contenido de un objeto canvas |
| ingra.F.descarga (url, name, forzada) | Descarga contenido de la url al archivo local name, si no forzada el navegador decide que hacer con los datos a descargar |
| Graba archivo remoto XMLHttpRequest POST |
|
| ingra.F.sendData (data, url, cb) | Envía data a url; XMLHttpRequest POST |
| ingra.F.sendFile (file, url, cb) | Envia file a url |
| ingra.F.sendCanvas (canvas, url, cb, tipo, calidad) | Envia canvas a url; canvas.toDataURL sendData; tipo:png|jpeg|webp; calidad:De jpg |
Módulo: ingra.L..js
| ingra.L | Listas de objetos orden:{codigo:1(ascendente)-1(descendente),...} Admite varios campos de orden y varios niveles de campos campos:{codigo:valor,...} Admite varios campos de búsqueda y varios niveles de campos |
| ingra.L.compara (a, b, orden) | Compara objetos, retorna 1(a>b),0(a=b),-1(a<b), null ~ 0 a todos los efectos en comparaciones |
| ingra.L.ordena (ol, orden) | Ordena lista de objetos sobre si misma |
| ingra.L.buscai (ol, campos) | Busca en lista de objetos el primero que cumple el criterio de campos, retorna -1 o posición en base 0 |
| ingra.L.buscail (ol, campos) | Busca en lista de objetos los que cumplen el criterio de campos, retorna lista de posiciones |
| ingra.L.busca (ol, campos) | Busca en lista de objetos el primero que cumple el criterio de campos, retorna el objeto o null |
| ingra.L.buscal (ol, campos) | Busca en lista de objetos los que cumplen el criterio de campos, retorna lista de objetos o [] |
| ingra.L.cuenta (ol, campos) | Cuenta en lista de objetos los que cumplan el criterio de campos, retorna número de encontrados |
| ingra.L.elimina (ol, campos) | Elimina los objetos de la lista que cumplan el criterio de campos, retorna número de eliminados |
| ingra.L.buscaObjeto (ol, o) | Busca objeto en lista de objetos, retorna -1 o posición del objeto encontrado en base 0 |
| ingra.L.eliminaObjeto (ol, o) | Elimina objeto en lista de objetos, retorna -1 o posición del objeto eliminado en base 0 |
| ingra.L.iniciaCeros (nh, nv) | Crea una lista o una matriz rellena de 0s; (nh,nv=0) > nl | nll |
| ingra.L.agregaSumas (nll, mh, mv) | Agrega filas y columnas con el total; (mh=0,mv=0) > nll:[nl+1]+n |
Módulo: ingra.M..js
| M | librería de matemáticas retorna el objeto M con toda las funciones // -1-Revision |
| M.rad (gra) | De grados a radianes |
| M.gra (rad) | De radianes a grados |
| M.tan2 (rad) | Contraria a atan2(y,x), retorna {x,y} |
| M.igual (n1, n2, mar) | Comprueba que son iguales 2 numeros |
| M.igual0 (n, mar) | Comprueba si n es = 0 |
| M.fraccion (n) | Retorna la parte decimal del numero |
| Operaciones sobre listas numéricas | |
| M.max (nl, cod) | Retorna el valor máximo valor de nl (con parámetro opcional 'cod', retorna el máximo de nl[][cod]) sin 'cod' equivale a Math.max(...nl) |
| M.min (nl, cod) | Retorna el valor mínimo valor de nl (con parámetro opcional 'cod', retorna el mínimo de nl[][cod]) sin 'cod' equivale a Math.min(...nl) |
| M.sum (nl, cod) | Retorna la suma de valores de nl (con parámetro opcional 'cod', retorna la suma de nl[][cod]) |
| M.med (nl, cod) | Retorna la media de valores de nl (con parámetro opcional 'cod', retorna la media de nl[][cod]) |
| M.dev (nl, cod) | Retorna la desviación típica de nl (con parámetro opcional 'cod', retorna la desviación típica de nl[][cod]) |
| M.analiza (nl, cod) | Retorna {min,max,sum,med,des} de (nl,cod) |
| M.unicos (ol, cod) | Ordena y elimina duplicados (opcionalmente cod) |
| operaciones sobre listas con índices | |
| M.eliminaIndices (dl, il) | Elimina elementos de dl en il(índices a dl), modifica dl e il, retorna dl |
| M.mueveIndice (dl, i1, i2) | Mueve elemento en i1(índice a dl) detrás de i2(índice a dl) en dirección i1-i2, modifica dl, retorna dl |
| M.mueveIndicesDelante (dl, il, pos) | Mueve elementos en il(índice a dl) delante de pos(índice a dl); modifica dl y il, retorna il modificado |
| M.mueveIndicesDelante2 (dl, dl2, pos) | Mueve elementos en dl2(elementos de dl) delante de pos(índice a dl); modifica dl y il, retorna il modificado |
| M.formatBytes (valor) | Retorna valor con dos dígitos significativos en Bytes|KB|MB|GB|TB |
| M.randon (min, max) | crea un valor numerico real aleatorio entre min y max (no incluyendo max) |
| M.randonInt (min, max) | crea un valor numeríco entero aleatorio entre min y max (no incluyendo max) |
| M.aleatorio (min, max) | Retorna un número aleatorio entero: (min,max) entre min incluido a max excluido o (numero) desde 0 a numero no incluido |
| M.aleatorioN (N) | Retorna un número aleatorio entero de N cifras; Math.pow(10,5) == 1e5 == 100.000 |
| M.aleatorioC (N) | Retorna una cadena de N carácteres aleatorios entre [A,Z] |
| M.transpuesta (all) | Retorna la matriz traspuesta solo 2d |
| M.determinante (all) | Retorna determinante a[3][3] |
| ingra.bit (v, bit, pone) | Operaciones de bits (v)indice (v,bit)valor (v,bit,0)pone0 (v,bit,1)pone1 (v,bit,-1)cambia bit |
| ingra.bit2l (val, length=8) | De valor en bits a lista de 1|undefined |
| ingra.num2l (num, length=8) | De número a lista de 1|undefined |
Módulo: ingra.O..js
| ingra.O | Manipulación de objetos |
| ingra.O.length (o) | Nº de propiedades |
| ingra.O.vacio (o) | ¿Está vacio? |
| ingra.O.mueve (ori, des) | Elimina componentes propios y copia de origen |
| ingra.O.duplica (oo) | Copia no recursiva |
| ingra.O.copia (origen, destino) | Copia profunda copia propiedades y subobjetos). Si destino copia contenido al objeto |
| ingra.O.deepClone (obj, niv=0) | Copia profunda (copia propiedades y subobjetos) |
| ingra.O.keys (o) | Retorna lista de claves, Object.keys(o); |
| ingra.O.pon (obj, cod0, val0) | (objeto,índice,valor) Admite subobjetos, indice con '.' |
| ingra.O.igual (a, b) | Compara y retorna true|false |
Módulo: ingra.S..js
| ingra.S | Manipulación de cadenas de texto |
| ingra.S.simple (a) | Elimina blancos por delante y por detrás y duplicados |
| ingra.S.troceaComillas (texto, mantieneComillas) | Trocea cadena por espacios externos a '' "" / / [] () |
| ingra.S.troceaExterno (condicion, sep) | Trocea cadena por espacios externos a '' "" / / [] () |
| ingra.S.izquierda (a, sep, porDetras) | Retorna la cadena izquierda desde el primer separador. Sin separador, retorna todo. Si porDetras retorna desde el último separador. Sin separador retorna '' |
| ingra.S.derecha (a, sep, porDetras) | Retorna la cadena derecha desde el primer separador. Sin separador, retorna ''. Si porDetras retorna desde el último separador. Sin separador retorna todo |
| ingra.S.split2 (a, sep, pordetras, conrecorte=1) | Retorna lista [anterior,posterior] desde el primer separador 'sep' buscado desde el inicio o si pordetras desde el final |
| ingra.S.sinComillas (a) | Recorta y elimina comillas " o ' si delante y detrás |
| ingra.S.eliminaLineasBlancas (a) | Aplica expresión regular |
| ingra.S.eliminaComentarios (a, noLineComment) | Elimina texto entre marcas /*...*/, si noLineComment, elimina comentarios simples javascript |
| ingra.S.esNombreVariableValida (nom) | Si el nombre solo contiene caracteres /[\p{L}_$0-9]/u y no empieze por número en expresiones regulares: \p{L}: Representa cualquier letra en cualquier idioma, u: habilita coincidencia de caracteres Unicode ingrid utiliza esta restricción en: códigos de clases, de campos y de opciones |
| ingra.S.validaNombreVariable (nom) | Cambia los caracteres no permitidos por _ y agrega un _ al comienzo si empieza con número |
| ingra.S.esNombreArchivoValido (nom) | Si el nombre no contiene caracteres [\\/:*?"<>|!&~] windows no permite [\\/:*?"<>|], linux además no permite [!&~] |
| ingra.S.validaNombreArchivo (nom) | Cambia los caracteres no permitidos por _ |
| ingra.S.esCodigoValido (cod, noInicial) | Si el nombre no contiene caracteres [\\/:*?"<>| !&~] y no empieza con [0-9] o noInicial |
| ingra.S.validaCodigo (cod, noInicial) | ambia los caracteres no permitidos por _ y agrega un _ al comienzo si empieza con número y !noInical |
| ingra.S.esCodigoMongo (a) | ¿Es un código válido para mongoDb? Retorna /^[a-z!#%&@_-][\w!#%&@_-]+$/i.test(a) |
| ingra.S.siguiente (s) | Devuelve siguiente al nº de la serie, si no acaba en número, añade sufijo "0001" |
| ingra.S.anterior (s) | Devuelve anterior al nº de la serie, si cero o menor, devuelve negativo con el mismo nº de caracteres (A000 > A0-1) |
| ingra.S.esNumero (a) | Retorna false si contiene distinto a 0-9 + - . , e E (- último sino \-) |
| ingra.S.esEntero (a) | Retorna false si contiene distinto a 0-9 + - (- último sino \-) |
| ingra.S.esAlfanumerico (a) | Retorna false si contiene distinto a a-z A-Z 0-9 _ |
| ingra.S.esAlfa (a) | Retorna false si contiene distinto a a-z A-Z y espacio en blanco |
| ingra.S.utf2ansi (s) | Cambio juego de caracteres |
| ingra.S.ansi2utf (s) | Cambio juego de caracteres |
Módulo: ingra.json..js
| ingra.eval (js) | Función eval() con captura de error |
| ingra.jsonl | Clase JSONL (objeto JSON por línea) |
| ingra.jsonl.a (ol, sep='\r\n') | De objeto JSONL a cadena |
| ingra.jsonl.d (jsonl) | De cadena a objeto JSONL |
| ingra.json | Clase con utilidades JSON |
| ingra.json.ao (json) | De cadena JSON a objeto JS; JSON.parse estándar con captura error > {data|error} |
| ingra.json.do (o, sep='\t') | De objeto JS a cadena JSON separados por 'sep'; JSON.stringify estándar > texto |
| ingra.json.dl (ol, sep='\r\n') | De lista de objetos JS a lista de JSONs separados por 'sep' > texto |
| ingra.json.a (o) | De objeto a cadena; JSON.stringify estándar con '\t' |
| ingra.json.at (o, op, _nivel) | De objeto a cadena de texto con desglose de líneas complejas; incluye \t\r\n |
| ingra.json.ah (o, op) | De objeto a cadena html con desglose de líneas complejas; incluye \t\r\n |
| ingra.json.ac (o) | De objeto a cadena no estándar(con funciones), incluye \t\r\n |
| ingra.json.acs (o) | De objeto a cadena simple, una línea por elemento de vactor u objeto [...]{...} |
| ingra.json.acn (o, ) | De objeto a cadena con desglose por líneas de nivel 1 \t\r\n; orden:líneas ordenadas alfabéticamente; html:texto en html; niveles:número de niveles(defecto 1); incluye \t\r\n |
| ingra.json.acol (ol, sincorchetes, enhtml) | De lista de objetos a cadena (uno por línea); si no sincorchetes, envuelto en corchetes y con comas al final de cada línea; incluye \t\r\n |
| ingra.json.acos (os, sinllaves, enhtml) | De objeto a cadena (una linea por propiedad); si no sinllaves, envuelto en llaves y con comas al final de cada línea; incluye \t\r\n |
| ingra.json.parse (json, _cbeo) | De cadena a objeto; JSON.parse estándar con captura error y no estricto, retorna {error:...} si error _cbeo obsoleto |
| De cadena a objeto; JSON.parse estándar con captura error, retorna {error:...} si error | |
| ingra.json.d (json) | De cadena a objeto; JSON.parse estándar con captura error |
| ingra.json.dc (json, d, i, r) | De cadena a objeto; retorna obj|{}|{error}; utiliza Function('d,i,r','return ('+json+')'); mantiene la función en caché |
| ingra.json.dce (json, d, i, r) | Evalua expresion: retorna obj|null |
Módulo: ingra.asincrono..js
| ingra.asincrono.funciones (...funciones) | Ejecuta las funciones de forma secuencial (se ejecuta cada funcion cuando finaliza la anterior) funciones: funcion(cb,i) ... funcion({error}}); si hay error en alguna función, salta a la última con {error} |
| ingra.asincrono.recorre (objetos, cbData, cbEnd) | Ejecuta cbData de cada objeto de forma secuencial (se ejecuta cada funcion cuando finaliza la anterior) objetos: lista de objetos, objeto o número, cbData(i,objeto,cb), cbEnd(data) si hay error en aalguna función salta a cbEnd con {error} |
| ingra.asincrono.paralelo (...funciones) | Ejecuta las funciones de forma paralela (se ejecutan a la vez, se concentran en la última) funcion(cb) ... funcion({datas,error}) si hay error en alguna función, salta a la última con error |
| ingra.terminadores (function () | Terminadores asíncronos Los terminadores permiten programar funciones que se ejecuten al cerrar el interface actual (cambiar de concepto en Ingrid), fundamentalmente para liberar recursos. |
| o.agrega (fun, _name) | Agrega terminador, agrega una función para que se ejecute al cerrar el interface actual. |
| o.ejecuta (_cb) | Ejecuta todos los terminadores y los elimina (automática al cerrar el interface actual) |
| o.elimina (fun) | Elimina terminador sin ejecutar |
| o.libera () | Libera todos los terminadores sin ejecutar |
Módulo: ingra.encoder..js
| ingra.utf2ansi (s) | Cambio juego de caracteres |
| ingra.ansi2utf (s) | Cambio juego de caracteres |
Módulo: ingra.promise..js
| ingra.p2cb (promise, cb) | De promesa a callback opcional |
| ingra.p2cbe (promise, cbe) | De promesa a callback opcional |
Sección: js.a
Módulo: ingra.ayuda.js
| ingra.ventanaAyuda (tema, ev) | Presenta ayuda en ventana separada |
| ingra.presentaAyuda (tema, ev) | Presenta contenedor con ayuda devuelve ayuda9.ingra.es/<tema> |
Módulo: ingra.dom.js
| ingra.dom | Control del DOM de cliente |
| ingra.dom.crea (etiqueta, oo, html, style, properties, ) | Crea elemento DOM. elemento:elemento#id.clase-%type html:value(input)|text(option)|src(img)|href,innerHTML(a)|innerHTML style:{}|[{},{}] cbChange(ev,val,cb), cbReturn(ev,val,cambios) rotulo divStyle spanStyle: agrega un div y un span |
| ingra.dom.buscaClase (o, clase) | Busca clase en ascendentes, retorna ascendente encontrado o null |
| ingra.dom.children (oo) | Retorna elementos hijo (oo.children no es un array) |
| }, | Inserta objeto o al principio del objeto oo |
| }, | Añade objeto o al final del objeto oo - oo.append(o); |
| },.indiceHijo (child) | Retorna el orden del hijo child |
| },.cambia (o1, o2) | Reemplaza objeto o1 por o2 |
| },.esPadre (oo, o) | Retorna true si oo es algún ascendiente de o |
| ingra.dom.redimensionadorHorizontal (div, cb) | Incluye una línea de puntos que permite redimensionar el div |
Módulo: ingra.eventos.js
| ingra.eventos (function() | Eventos gestionados |
| ie.agrega (o, eventName, cb, useCapture) | Agrega evento gestionado Tabla Fija, ingraM,ingraG,grafica,canvas_firma |
| ie.elimina (o, eventName, cb, useCapture) | Elimina evento gestionado Tabla Fija |
| ie.libera () | Elimina todos los eventos gestionados ingra.eventos.libera |
| ie.busca (o, eventName, useCapture) | Busca evento gestionado |
Sección: js.api
Módulo: ingra.ajax.js
| ingra.ajax | Librería comunicación AJAX |
| ingra.ajax.envia (type, url, op, cb, cbProgress) | Envia petición HTTP mediante XMLHttpRequest (ajax), si !cb síncrono, {ansi, nocache, data(enPOST)} > cb(xhr.responseText || xhr.response), cbProgress(ec, progreso_en_%) opcional {headers:{'crossorigin': 'anonymous'}} |
| ingra.ajax.get (url, op, cbo) | Envia petición HTTP GET de texto > ingra.ajax.envia > cb(texto) |
| ingra.ajax.getJson (url, op, cb) | Envia petición HTTP GET de JSON > deJson > ingra.ajax.envia > cb(object) |
| ingra.ajax.getBuffer (url, cb, cbProgress) | Envia petición HTTP GET de Buffer > cb(buffer) |
| ingra.ajax.getBlob (url, cb, cbProgress) | Envia petición HTTP GET de Blob > cb(blob) |
| ingra.ajax.post (url, data, cb, cbProgress) | Envia petición HTTP POST, op.data|data , data: string|file|blob|buffer > (texto) |
| ingra.ajax.postJson (url, data, cb, cbProgress) | Envia petición HTTP POST, op.data|data > (json) |
| ingra.ajax.existeUrl (url, cbo) | ¿Existe URL? > cbo(true/false) o true/false |
Módulo: ingra.audio.js
sonidos
| click () | sonido: click menos intenso |
| beep () | sonido: beep media intensidad telecontrol_global |
| beep2 () | sonido: beep2 mas intenso |
| error () | sonido: error, usado en dialogos |
| dog () | sonido: dog |
| boom () | sonido: boom |
| scream () | sonido: scream |
| typewriter () | sonido: typewriter |
| voces (cb) | Voces apliables a recitar > [{name.lang,localService,default}] solo hay una con default |
| recitar (texto, op=) | Sintetizador de voz, de texto a audio (web-speech-api) {volume=1,pitch=1,rate=1,voice=default} |
| Reconocer (op=) | Reconocimiento de voz |
Módulo: ingra.bandeja.js
Clase bandeja (portapapeles)
| ingra.leeBandeja (cb) | Leer texto de bandeja, pide permiso > {texto} |
| ingra.grabaBandeja (texto, cb) | Graba texto a bandeja |
| ingra.liberaBandeja (cb) | Libera bandeja |
| ingra.leeBandejaJson (cb) | Leer objeto de bandeja > json |
| ingra.grabaBandejaJson (json, cb) | Graba objeto a bandeja |
| ingra.leeBandejaCodigo (codigo, defecto) | Leer objeto de bandeja con codigo > promesa > json |
| ingra.grabaBandejaCodigo (codigo, json) | Graba objeto a bandeja con codigo > promesa |
Módulo: ingra.fetch.js
| ingra.fetch2.text (url, cb) | Recibe texto de URL, GET > {text} |
| ingra.fetch2.json (url, cb) | Recibe JSON de URL, GET > json |
| ingra.fetch2.json_json (url, json, cbo) | Envia JSON y recibe JSON, de URL, POST > json |
| ingra.fetch2.file_json (url, file, cb) | Envia FILE y recibe JSON, de URL, POST > json |
| ingra.fetch2.formdata_json (url, formData, cb) | Envia FORMDATA y recibe JSON, de URL, POST > json |
| ingra.fetch2.json_file_json (url, json, file, cb) | Envia JSON y FILE y recibe JSON, de URL, POST > formdata > json |
| ingra.fetch2.json_blob (url, json, cb) | Envia JSON y recibe BLOB, de URL, POST > {blob} |
| ingra.fetch2.descarga (url, nombre=null) | Descarga una URL (solo web) |
Módulo: ingra.file.js
| ingra.file | Clase file(blob); Formato para manejar objetos binarios, utilizado lara leer/grabar archivos del sistema operativo // { name:"a.png", size:47744, type:"image/png", lastModifiedDate } |
| ingra.file.ac (file, op=) | De file a texto; {cbProgress,ansi} > (data|error) |
| ingra.file.ao (file, op=) | De file a JSON; {cbProgress,ev} > {data|error} |
| ingra.file.aTexto (file, op, cb) | De file a texto; {cbProgress,ev,ansi} > (textoUtf,file,ev) |
| ingra.file.aJson (file, op, cb) | De file a JSON; {cbProgress,ev} > (objJs,file,ev) |
| ingra.file.aDataUrl (file, op, cb) | De file a DataURL; {cbProgress,ev} > (dataUrl,file,ev) |
| ingra.file.aBuffer (file, op, cb) | De file a Buffec; {cbProgress,ev}> (buffer,file,ev) |
| ingra.file.inputFile (op, cb, cbCancel) | {soloImagenes} > (file,ev) incluye file.ev, y file.url si ext=="url" multiple accept="image/*" |
| ingra.file.inputFiles (op, cb, cbCancel) | {soloImagenes} > (files,ev) files pueden incluir url |
| ingra.file.dragDataUrl (obj, cb) | > (dataUrl,file,ev) |
| ingra.file.leeArchivo (...a) | Obsoleto > ingra.F.lee |
| ingra.file.leeArchivoJson (...a) | Obsoleto > ingra.F.leeJson |
| ingra.file.leeArchivoDataURL (...a) | Obsoleto > ingra.F.leeDataUrl |
| ingra.file.leeArchivoBuffer (...a) | Obsoleto > ingra.F.leeBuffer |
| ingra.file.grabaArchivo (...a) | Obsoleto > ingra.F.graba |
Módulo: ingra.location.js
| ingra.location.param (defecto) | De varios formatos de parámetros a objeto ?o# &o; ?{nombre:valor,...} ?nombre=valor&... &valor&... defecto:['basedatos','usuario','clave',..] parámetros sin nombre; |
Módulo: ingra.message.js
| ingra.mensaje | Mensajes entre aplicaciones |
| ingra.mensaje.escucha (tipo, funcionRecibe) | SERVIDOR Registra tipo de mensaje a recibir |
| ingra.mensaje.envia (tipo, data) | CLIENTE Envia mensaje al padre(window.opener) o al hijo(abreHijo) |
| ingra.mensaje.abreParalelo (url, minima, opciones) | CLIENTE inicia hijo PARALELO (url) |
Módulo: ingra.tableta.js
| ingra.detectaTableta () | Detecta tipo de tableta > (0)pc (1)tablet (2)telefono |
Módulo: ingra.websocket.js
| ingra.Websocket (servidor, cb) | Arranca una conexion websocket. Retorna (conexion) |
| oo.enviaMensaje (meta, cb) | Envía el json de meta con meta.retornos[id]=cb; meta.retorno=id; id=#ultimo |
| oo.cierra () | Cierra conexion |
Sección: js.dib
Módulo: ingra.canvas.js
| g.elipse (o, strokeFill=1) | Dibuja Elipse ({x, y, rw, rh, rot=0, a1=0, a2=360, contra:false, pie:false | p,w,h,x1,y1,x2,y2 | pl }) | (pl) |
Módulo: ingra.chart.js
| google_pie (g) | Gráfica de tarta; g:{ tit:"", titl:[""], numl:[N], ancho:800, alto:375, enHtml:1, conCol:"" } |
| google_bar (g) | Gráfica de barras; g:{ tit:"", titl:[""], numl:[[N]], ejexl:[""], ejeyl:[""], ancho:800<1000, alto:375<1000, enHoriz:0, enHtml:1, conCol:"" } |
| google_qr (g) | Gráfica de código QR; g:{ texto:"", tamano:200, nivel:0, enHtm } > src | html |
Módulo: ingra.color..js
color soporta: "[#]rgb[a]" | "[#]rrggbb[aa]" | {r,g,b,[a]} | [r,g,b,[a]] | "rgb(r,g,b)" | "rgba(r,g,b,a)" | "r,g,b[,a]"
| ingra.color (function () | Color #rrggbb[aa] |
| ao (s) | A objeto RGBA: {r,g,b,a} 0-255, defecto(0,0,0,255), < "rgb(r,g,b)" | "rgba(r,g,b,a)" | "r,g,b[,a]" | "[#]rrggbb[aa]" | "[#]rgb[a]" |
| css (color, sinAbreviar, sinOpacidad) | A color #rrggbb[aa] |
| opacidad (color) | Retorna opacidad entre 0..1 con 2 decimales |
| ponOpacidad (color, opacidad) | Pon tranparencia(0..1) a color, retorna CSS |
| opacidad2blanco (color) | De opacidad a equivalente sobre blanco |
| brillo (c) | Brillo medio, (r * 0.299) + (g * 0.587) + (b * 0.144), (<128)oscuro |
| esOscuro (c) | Brillo medio < 128 |
| gris (c) | A gris, (0.299 * r + 0.587 * g + 0.114 * b) |
| claro (c, blanco=0.5) | Aclara color, blanco:(0)c (1)blanco |
| oscuro (c, negro=0.5) | Oscurece color, negro:(0)c (1)negro |
| mezcla (c1, c2, valor2=0.5) | Color mezcla; valor2:(0)c1 (1)c2 |
| ponR (color, r) | Pone componente rojo (0..255) |
| ponG (color, g) | Pone componente verde (0..255) |
| ponB (color, b) | Pone componente azul (0..255) |
| ponA (color, a) | Pone opacidad (0..255) |
| aHSL (c) | De color a HSL; > {h,s,l} |
| deHSL (hsl, rgb=null) | De color HSL a RGB; {h,s,l} > css |
| ponH (color, hue) | Pon Hue a color (Tono o Matiz), hue:0-360, (0)rojo (60)amarillo (120)verde (180)cian (240)azul (300)magenta |
| ponS (color, sat) | Pon Saturation (Saturación) a color, sat:0(gris)-100(color) |
| ponL (color, lum) | Pon Luminance (Luminosidad) a color, lum:0(negro)-100(blanco) |
| luminosidadMaxima (color, max) | Pon Lumninance máxima (0-100) |
| serie (col1, col2, numero, desplaza) | Retorna serie entre col1 y col2 de numero de colores; desplaza opcional |
Módulo: ingra.igra.js
Formato IGRA, igra:{...}
| ingra.igra.dibuja (igra, canvas, estatico) | Dibuja objeto IGRA en canvas, si estático sin elementos interactivos |
| ingra.igra.presenta (padre, igra, style, properties) | Presenta objeto igra en contenedor (padre) style:{ width:100%, height:512px } > canvas, si !padre estático |
Módulo: ingra.imagen.js
| ingra.imagen | Utilidades de imagen |
| Filtros | |
| ingra.imagen.filtroGrises (canvas, modo) | Aplica modo: (0*)media:(r+g+b)/3 o (1)brillo:0.2126*r + 0.7152*g + 0.0722*b |
| ingra.imagen.filtroBlancoNegro (canvas, modo) | Aplica modo: (0*)media=(r+g+b)/3 o (1)brillo:0.2126*r + 0.7152*g + 0.0722*b >128? 255: 0 |
| ingra.imagen.filtroPosteriza (canvas, nivel=2) | Aplica posterización nivel:2..255 (2)8 (3)27 (4)64 ... |
| ingra.imagen.filtroBrillo (canvas, reduce=0) | Amplia o reduce el brillo de la imagen |
| ingra.imagen.filtroInvierte (canvas) | Invierte 3 componentes (no incluye transparencia) r,g,b > 255-r,g,b |
| ingra.imagen.filtroSepia (canvas) | Modifica r,g,b > r*[.393,.769,.189], g*[.349,.686,.168] b*[.272,.534,.131] |
| ingra.imagen.filtroContraste (canvas, contraste=50) | Cambia contraste -255..255 |
| ingra.imagen.filtroEspejo (canvas, vertical) | Aplica espejo horizontal, si vertical espejo vertical (flip) |
| Operaciones | |
| ingra.imagen.cambiaColor (canvas, c1, c2, margen=0) | Cambia color c1 por c2, no modifica alfa c1,c2:{r,g,b} |
| ingra.imagen.grabaCanvas (canvas, arc) | Diálogo graba archivo con el contenido del canvas; jpg png webp |
| ingra.imagen.url2canvas (url, cb) | Carga imagen, crea canvas del mismo tamaño y dibuja imagen en canvas. > (canvas) url2image createElement drawImage |
| ingra.imagen.url2image (url, cb) | Carga imagen, > (image) onload |
Sección: js.ext
Módulo: ingra.csv..js
| ingra.csv | Utilidades para formato CSV {titulo"", campos[{}], lineas[][], estadistica{}} |
| ingra.csv.estadistica (csv, numeroValoreMaxmo=8) | Estadística del contenido de un objeto CSV({campos[{}], lineas[[]], titulo}) > estadistica:[codigoCampo:valor[repeticiones]...resto[]] |
| ingra.csv.lis2tip (ol, cam) | analiza tipo de un campo(código) en lista de objetos ol:[{}] |
| ingra.tex2csv (texto, op) | De texto(contenido archivo CSV) a objeto CSV op:{lintit=0, lincam=0, sinCamposVacios=0, sinLineasVacias=1, conEstadistica=0} lintit:Línea con título; lincam:Línea con campos texto|lineas > {titulo"", campos[{}], lineas[][], estadistica{}} |
| ingra.val2t (val, esTexto) | Retorna tipo de val > [f|e|fh|r|t] esTexto: 1 val como texto con números en formato estándar(.), 2 en formato español(,) |
| ingra.csv2tex (csv, op=) | De objeto CSV a texto CSV > texto csv:{titulo"", campos[{cod}|cod], docl[{}]|lineas[][]}, op:{contit,concam,excel} op.excel: Formato separadores|Excel|Estándar formato estándar: separador de campos ',', de decimales '.' y juego de caracteres ANSI formato Excel: separador de campos ';', de decimales ',' y BOM al comienzo del archivo para detectar utf8 Envuelve con " los datos que incluyen separadores o comillas |
| ingra.bas_docl2csv (bas, docl, op=) | > De lista de documentos a CSV {campos, forcam,forcla,forref} > ingra.docl2csv > {campos,lineas,...} op: {campos,titulo, forcam,forcla,forref} > ingra.docl2csv (campos,titulo, forcam}) > forcla: Formato clasificaciones|*de campo|cod|res|cod·res , solo si bas forref: Formato referencias|*de campo|cod|res|cod·res , solo si bas |
| ingra.docl2csv (docl, op=) | De lista de documentos a CSV {campos, forcam} > {campos,lineas,...} op: {campos, forcam}, elimina campos vacios caml: Formato: "... ... " o ["",...] o [{},...] "cod·res|tip·tam|estilo|atributos" o "cod·res·tip·tam·estilo·atributos" > {cod,res,tip,tam,estilo,atributos} forcam: Formato campos|*cod|res|cod·res|cod·res·tip·tam|sin campos , mantiene tip, cambia res, elimina cod |
| ingra.csv2docl (csv) | Retorna lista de documentos docl, cada uno una línea del csv |
| ingra.csv2table (csv, op=) | Retorna cadena en formato html "<table>...</table>" - {clase,numeros} |
| ingra.csv2html (csv, op=) | Retorna cadena en formato html "<table>...</table>" - {clase,numeros} |
Módulo: ingra.htm..js
| ingra.htm | Objeto HTML |
| ingra.htm.dc (a) | De ASCII a html; \r\n\t"... > <br> " &#..; |
| ingra.htm.ac (a) | De html a ASCII; elimina <...>; <br>, " &#%d+; > \r\n\t"... |
| ingra.htm.table (dll, op) | Retorna cadena en formato html "<table>...</table>" - {campos,numeros,clase,esTexto} |
Módulo: ingra.rtf..js
| ingra.rtf | ingra.rtf.aTexto(rtf) |
| ingra.rtf.aTexto (rtf) | De RTF a texto |
Sección: js.geo
Módulo: ingra.geo..js
| ingra.geo | Librería de geometría de objetos Geo {tip:[POLCREBT], ..., punl:[{x,y}]} |
| ingra.geo.medio (geo, pl) | Medio del límite, usado por geol.medio |
| ingra.geo.centroide (geo, pl) | Retorna el centroide |
| ingra.geo.interior (geo, pl) | Retorna el centroide modificado para que sea interior |
| ingra.geo.perimetro (geo) | Retorna el perímetro |
| ingra.geo.area (geo) | Retorna el área |
| ingra.geol | Librería de geometría de objetos Geol: [geo] |
| ingra.geol.limite (geol, rec) | Retorna el rectangulo horizontal minimo que contiene a geol |
| ingra.geol.medio (geol) | Retorna el punto medio |
| ingra.geol.centroide (geol) | Retorna el centroide |
| ingra.geol.perimetro (geol) | Retorna el perímetro |
| ingra.geol.area (geol) | Retorna el área |
| ingra.geol.envolventeConvexa (geoll, margen) | Envolvente convexa > geo (convex.hull) |
| ingra.geol.envolventeConcava (geoll, dec) | Envolvente cóncava > geol |
| ingra.geol.islas (geol) | Calcula islas geol | {geol} > null | {cambios,orden} cambios en geos, orden cambios en geol |
| ingra.docgeol | Librería de geometría de objetos doc.geol |
| ingra.docgeol.limite (docl) | Límite global del conjunto de documentos > rec |
| ingra.docgeol.simplifica2 (docl, margen, pixels=1000) | pixeles por con |
| ingra.docgeol.simplifica (docl, ) | cambia:original > modificados[{id,geol}] |
Módulo: ingra.pun..js
| ingra.pun | Librería de geometría: Puntos (punto: {x,y,...}) |
| ingra.pun.copia (p) | Copia desde formatos: (x,y) ([x,y]) ({x,y,...}) ({lon,lat}) ({lng,lat}) (number) |
| ingra.pun.forma (p) | Copia si no tiene formato punto |
| ingra.pun.dc (a, sep=';') | De cadena a punto |
| ingra.pun.ac (p, dec, sep='; ') | De punto a cadena |
| Retornan el mismo punto: | |
| ingra.pun.red1 (p, dec=0) | Redondea con 'dec', modifica y retorna p |
| ingra.pun.mas1 (p, p2) | Suma p más p2, modifica y retorna p |
| ingra.pun.men1 (p, p2) | Resta p menos p2, modifica y retorna p |
| Suma p más p2, modifica y retorna p | |
| Resta p menos p2, modifica y retorna p | |
| ingra.pun.mul1 (p, fac) | Multiplica p por fac, modifica y retorna p |
| ingra.pun.div1 (p, fac) | Divide p por fac, modifica y retorna p |
| Retornan pun: | |
| ingra.pun.red (p, dec=0) | Retorna p redondeado con 'dec' decimales |
| ingra.pun.mas (p, p2) | Suma p más p2 (sinónimo: sum) |
| ingra.pun.men (p, p2) | Resta p menos p2 (sinónimo: res) |
| Suma p más p2 (sinónimo: sum) | |
| Resta p menos p2 (sinónimo: res) | |
| ingra.pun.mul (p, fac) | Multiplica p por fac |
| ingra.pun.div (p, fac) | Divide p por fac |
| ingra.pun.medio (a, b) | Punto medio entre 'a' y 'b' (sinónimo: med) |
| ingra.pun.tamano (a, b, abs) | el tamaño o diferencia entre 'a' y 'b' (sinónimo: tam) |
| ingra.pun.intermedio (a, b, d=.5) | Punto intermedio entre 'a' y 'b' a 'd' de a; d:(0)a(1)b |
| ingra.pun.recta (a, b, p) | Retorna punto de forma: 'a' es a 'b' como 'p' es a punto |
| ingra.pun.perpendicular (a, b, p, soloEntre) | Retorna punto intersección de la línea formada por 'a' y 'b' y su perpendicular por 'p' |
| ingra.pun.afactor (a, b, factor) | Retorna punto a distancia(factor: 0 a 1 b) de punto a en dirección a punto b |
| ingra.pun.afactorP (a, b, factor) | Retorna punto a distancia(factor: 0 a 1 b) de a en dirección perpendicular a a-b |
| ingra.pun.adistancia (a, b, distancia) | Retorna punto a distancia de punto a en dirección a punto b |
| ingra.pun.adistanciaP (a, b, distancia) | Retorna punto a distancia de punto a en dirección perpendicular a a-b |
| ingra.pun.incentro (a, b, c) | Retorna punto de corte de las bisectrices de un triangulo (a,b,c) |
| ingra.pun.interseccion (a, b, c, d, soloEntre) | Retorna punto intersección entre linea a-b y linea c-d, si soloEntre retorna null si intersección fuera de segmentos |
| ingra.pun.rota1 (p, p0, alfa, engrados) | Retorna punto p rotado alrededor de p0 un ángulo alfa |
| ingra.pun.rota (p, p0, alfa, engrados) | Retorna punto p rotado alrededor de p0 un ángulo alfa |
| Retornan rectángulo (rec): | |
| ingra.pun.rec (a, b, margen) | Retorna rectángulo {x1,y1,x2,y2} con margen opcional |
| Retornan lista de puntos (punl): | |
| ingra.pun.punl4 (a, b) | Retorna los cuatro puntos del rectángulo |
| ingra.pun.margen4 (a, b, margen) | Retorna los cuatro puntos de la línea con margen, también admite un solo punto |
| ingra.pun.mueveOrtogonal (p0, p) | Retorna p ortogonal a p0 |
| retornan valor: | |
| ingra.pun.igualE (a, b, margen=Number.EPSILON) | Es igual o menor a EPSILON la distancia entre a y b |
| ingra.pun.igual (a, b, margen) | Es igual o menor a margen la distancia entre a y b |
| ingra.pun.distancia2 (a, b) | Distancia al cuadrado entre a y b |
| ingra.pun.distancia (a, b) | Distancia entre a y b |
| ingra.pun.area (a, b, c=null) | Área del triángulo a-b-c o del rectángulo formado por a-b |
| ingra.pun.sin (a, b) | Retorna el seno del ángulo entre dos puntos (versor) |
| ingra.pun.cos (a, b) | Retorna el coseno del ángulo entre dos puntos (versor) |
| ingra.pun.tan (a, b) | Retorna la tangente del ángulo entre dos puntos (sin/cos) |
| ingra.pun.ang (a, b, c, engrados=false) | Retorna el ángulo de la linea a-b o entre líneas b-a y b-c, en el rango [0,360] |
| ingra.pun.alaDerecha (a, b, c) | ¿Está c a la derecha de la línea a-b? |
| ingra.pun.alaDerecha2 (a, b, c, d) | ¿Está d a la derecha de la línea a-b y de la línea b-c? |
| ingra.pun.intersecta (a, b, c, d) | ¿Intersecta el segmento a-b con el c-d? |
| ingra.pun.modulo (a) | Módulo de a SQRT(a.x**2 +a.y**2) |
| ingra.pun.cross (a, b, co) | Producto vectorial o producto cruz (cross) a.x * b.y + a.y * b.x; Si 'co' retorna >0 si co a la derecha de a-b, =0 en la misma línea, <0 si co a la izquierda de a-b |
| ingra.pun.dot (a, b, co) | Producto escalar o producto punto, dot(a,b) = a.x * b.x + a.y * b.y = |a|*|b|*cos(ab) Ángulo entre a y b: acos(dot(a,b)/modulo(a)/modulo(b)) Proyección de a sobre b: dot(a,b)/modulo(a) |
| ingra.punl | Librería de geometría: Lista de puntos (punl:{pun,...}, pun:{x,y,...}) |
| ingra.punl.copia (arg) | Copia desde formatos: (x,y,...) ({x,y},...) ([x,y],...) ([x,y,...]) ([{x,y},...]) ([[x,y],...]) ({x1,y1,x2,y2}) ({left,bottom,right,top}) |
| ingra.punl.forma (arg) | Copia si no tiene formato lista de puntos |
| ingra.punl.dc (a, sep) | Convertir de cadena |
| ingra.punl.ac (pl, dec, sep) | Convertir a cadena |
| ingra.punl.acr (pl, dec, sep) | Convertir todos los puntos relativos al primero |
| ingra.punl.al (pl) | Convertir a lista |
| ingra.punl.all (pl) | Convertir a lista de listas |
| Retorna this: | |
| ingra.punl.red1 (pl, dec=0) | Redondeado al decimal dec |
| ingra.punl.mas1 (pl, p) | Suma p a todos los puntos de pl |
| ingra.punl.men1 (pl, p) | Resta p a todos los puntos de pl |
| ingra.punl.por1 (pl, fac) | Multiplica a todos los puntos de pl por fac |
| retorna PUNL: | |
| ingra.punl.red (pl, dec=0) | Redondeado |
| ingra.punl.mas (pl, p) | Suma p a todos los puntos de pl |
| ingra.punl.men (pl, p) | Resta p a todos los puntos de pl |
| ingra.punl.por (pl, fac) | Multiplica a todos los puntos de pl por fac |
| ingra.punl.punto (pl, cerrado, i) | Punto i de la lista de puntos, cíclico, puede ser < 0 y >= pl.length o null si no cerrado |
| ingra.punl.puntos (pl, cerrado, i1, i2) | Puntos desde i1 a i2 incluidos, de la lista de puntos, cíclico, pueden ser < 0 y >= pl.length o null si no cerrado |
| ingra.punl.rota1 (pl, p0, alfa) | Retorna los mismos puntos pl rotados alrededor de p0 un ángulo alfa |
| ingra.punl.rota (pl, p0, alfa) | Retorna puntos pl rotados alrededor de p0 un ángulo alfa |
| ingra.punl.regular (o) | Crea el polígono regular {x,y,r,n, a=90,r2=r} o {pun,rad,num,ang,rad2} > pl puntoCentral, númeroVertices anguloInicial radios |
| ingra.punl.estrella () | Crea una estrella de n lados > pl |
| ingra.punl.flor () | Crea una flor de n lados > pl |
| ingra.punl.simplifica (pl, margen, altaCalidad) | Elimina puntos colindantes mas cercanos que margen (en pixel margen=1) > pl |
| ingra.punl.envolventeConvexa (pl, margen) | Polígono convexo envolvente positivo de 'pl' con margen |
| ingra.punl.envolventeConcava (pl, margen) | Poligono cóncavo separado 'margen' de 'pl' |
| ingra.punl.rec (pl) | Retorna el recuadro límite |
| ingra.punl.mayor (pl) | Retorna la dimensión mayor del límite |
| ingra.punl.limite (pl) | Retorna el rectangulo mínimo que contiene a pl |
| Retornan PUN: | |
| ingra.punl.centro (pl) | Punto central del límite |
| ingra.punl.medio (pl) | Punto medio {} |
| ingra.punl.centroide (pl) | Centroide == centro de masa (densidad uniforme) == centro de gravedad SUM(a*x)/SUM(a) Centroide o baricentro == centro de masas (densidad uniforme) == centro de gravedad Triángulo , intersección de medianas (The centroid of a triangle is simply the average of its three vertices, i.e., it has coordinates (x1 + x2 + x3)/3 and (y1 + y2 + y3)/3.) |
| Retornan valor: | |
| ingra.punl.distancia (pl, cerrado, pun, soloVertices=false) | Distancia del punto a la polilínea |
| ingra.punl.igualUE (pl, p) | ¿Es igual al último? |
| ingra.punl.chequea (pl, cerrado, margen) | Elimina duplicados, retorna nº eliminados |
| ingra.punl.perimetro (pl, cerrado) | Perímetro. Si cerrado, une último con primero |
| ingra.punl.area (pl) | Área (positivo en sentido agujas reloj) |
| ingra.punl.dentro (punl, pun) | Comprueba si pun está dentro de pl. Usa PNPOLY (Point Inclusión in Polygon) Test W. Randolph Franklin (WRF) |
| ingra.punl.buscaCercano (pl, cerrado, pun, op=) | Distancia del punto a la polilínea op:{D2, soloVertices, busActual} > { t:(V|A|S), p, i, d2} t:Vértice Anterior Siguiente - Centro Medio Rejilla |
| ingra.punl.buscaPunto (pl, pun, op, t=null) | Distancia del punto a la polilínea. {D2,iActual} > { t:V, p, i, d2} |
Módulo: ingra.rec..js
| ingra.rec | Librería de geometría: Rectángulos (rectángulo: {x1,y1,x2,y2}) |
| ingra.rec.punl (r) | convierte rec en lista de 2 puntos |
| ingra.rec._rec (r) | convierte lista de puntos en rec |
| ingra.rec.copia (arg) | Copia a rectángulo desde formatos: {x1,y1,x2,y2}, [x1,y1,x2,y2], [{x,y},{x,y}], {p,r,x,y,w,h}, {left,bottom,right,top}, "x1,y1,x2,y2" punl, rec, pun |
| ingra.rec.forma (arg) | Copia si no tiene formato rectángulo |
| Retornan el mismo: | |
| ingra.rec.agrega1 (r, pl) | crece r para que entre pl |
| ingra.rec.mueve1 (r, pl) | mueve r para incluir el punto/rectan/poligono |
| ingra.rec.mueveDentro1 (r, r2) | mueve r, si es necesario, para que se mantenga dentro de r2 |
| ingra.rec.creciente1 (r) | creciente 1 |
| Retornan rectángulo rec: | |
| ingra.rec.red (r, dec=0) | redondea con ingra.red |
| ingra.rec.suma (r, r2) | suma vertice a vértice r a arg |
| ingra.rec.resta (r, r2) | resta vértice a vértice arg a r |
| ingra.rec.mul (r, fac) | return { x1:r.x1*fac, y1:r.y1*fac, x2:r.x2*fac, y2:r.y2*fac }; }, |
| ingra.rec.margen (r, marx, mary) | return { x1:r.x1-marx, y1:r.y1-mary, x2:r.x2+marx, y2:r.y2+mary }; }, |
| ingra.rec.agrega (r, pl) | agrega a r una polilinea |
| ingra.rec.mueve (r, p) | mueve r hasta contener p |
| ingra.rec.mueveDentro (r, r2) | mueve r si es necesario, para que se mantenga dentro de r2 |
| ingra.rec.creciente (r) | creciente 1 |
| ingra.rec.alineacion (r, ali) | alineacion, de 4 > 0..8 |
| ingra.rec.xywh (arg) | retorna rectángulo x1,y1,x2,y2 dado de la forma x1,y2,width,height |
| Retornan punl: | |
| Retornan punto: | |
| ingra.rec.recta (r1, r2, p, conCambioDeSigno) | retorna punto o rectángulo; r1 es a r2 como p es a |
| ingra.rec.p1 (r) | retorna p1 |
| ingra.rec.p2 (r) | retorna p2 |
| ingra.rec.p3 (r) | retorna p3 |
| ingra.rec.p4 (r) | retorna p4 |
| retorna width, height | |
| ingra.rec.tamano (r) | retorna width, height |
| ingra.rec.medio (r) | retorna el punto medio del rectángulo |
| ingra.rec.apunto (r, ali, enPixel) | punto de alineación: -6-7-8 -3-4-5 0+1+2 +3+4+5 +6+7+8 +9+10+11 |
| Retornan valor: | |
| ingra.rec.mayor (r) | Retorna la mayor dimensión(ancho o alto), en valor absoluto |
| ingra.rec.menor (r) | Retorna la menor dimensión(ancho o alto), en valor absoluto |
| ingra.rec.diagonal2 (r) | retorna distancia al cuadrado |
| ingra.rec.diagonal (r) | retorna distancia |
| ingra.rec.distancia2 (r, p) | retorna distancia al cuadrado |
| ingra.rec.distancia (r) | retorna distancia |
| ingra.rec.compara (cod, a, b, decreciente) | cod:per,are,x1,x2,y1,y2,xx,yy |
| retorna bool | |
| ingra.rec.vacio (r) | |
| ingra.rec.igual (r0, r1) | ¿son r0 y r1 iguales? |
| ingra.rec.dentro (rec, pun, mar, g) | en borde true p:pun|rec|punl |
| ingra.rec.dentroParcial (rec, pun, mar, g) | en borde true p:pun|rec|punl |
| ingra.rec.intersecta (r, r2, incluyeBordes) | intersecta, en borde false |
| retorna distancia del punto al rectángulo. Retorna > { t:(V|A|S), i(base0), d2, p(i|p|p)}; | |
| ingra.rec._dentro (r, p) | en borde true p:pun|rec|punl |
| ingra.rec.perimetro (r) | retorna perímetro |
| ingra.rec.area (r) | retorna área |
| ingra.lin | Librería de geometría: Líneas normalizadas (Línea: {a,b,c} ax+by+c=0) |
| ingra.lin.forma (arg) | Copia si no tiene formato línea |
| ingra.lin.pon (arg) | Línea desde formatos: {a,b,c} [x1,y1,x2,y2] o (x1,y1,x2,y2) [p1,p2] o (p1,p2) {x1,y1,x2,y2} |
| ingra.lin.pon2 (p1, p2) | De puntos {x,y} a línea normalizada {a,b,c}, a*x+b*y+c=0 |
| Retornan línea: | |
| ingra.lin.normaliza (lin) | En la forma normal a·x1+b·y1+c == distancia de x1,y1 a la recta |
| ingra.lin.paralela (p1, p2, dis) | o (lin,dis) Línea paralela a 'lin' a distancia 'dis' |
| ingra.lin.perpendicular (p1, p2, p) | o (lin,p) Línea perpendicular de un punto a una línea (perpendicular a lin que pasa por p) |
| Retornan punto: | |
| ingra.lin.proyectado (p1, p2, p) | o (lin,p) Punto proyectado de p sobre lin |
| ingra.lin.intersecta (p1, p2, p3, p4) | o (lin1,lin2) Intersección de dos líneas |
| ingra.lin.intersectaParalelas (p1, p2, p3, dis) | Punto intersección de lineas paralelas, a p1-p2 a dis, y a p2-p3 a dis |
| Retornan valor: | |
| ingra.lin.distancia (p1, p2, p) | o (lin,p) Distancia de un punto a una línea: (0)en (>0)derecha (<0)izquierda, Sistancia con línea normalizada, sino lugar geométrico |
Módulo: ingra.rin..js
| ingra.rin | Librería de geometría: Rectángulo inclinado 1(inf.izq.), 2(sup.der.tamaño) o 3(inf.der.rotación) puntos. R(Rectángulos) y E(Elípses) |
Módulo: ingra.cur..js
| ingra.cur | Librería de geometría: Curvas (punl: {p1,...}) |
| ingra.cur.controlQuadratic4 (p1, p2, p3, p4, conContinuidad) | Puntos de control entre puntos p1-p2 y p3-p > punto control {pi}; con continuidad tangentes comunes |
| ingra.cur.medioQuadratic4 (p1, p2, p3, p4, conContinuidad) | Punto medio cuadrática entre p1-p2 y p3-p4 > pm |
| ingra.cur.medioQuadratic (p2, pc, p3) | Punto medio cuadrática entre anclas p2,p3 y control pc |
| ingra.cur.medioQuadraticL (p2, pc, p3, nivel) | Puntos medios cuadratica entre anclas p2,p3 y control pc > (nivel)puntos (0)1,(1)3,(2)7,(3)15,(4)31 |
| ingra.cur.controlBezier4 (p1, p2, p3, p4, conContinuidad) | Puntos de control entre puntos p1-p2 y p3-p4 > puntos control {pi,pj}; con continuidad tangentes comunes |
| ingra.cur.medioBezier4 (p1, p2, p3, p4, conContinuidad) | Punto medio bezier entre puntos p1-p2 y p3-p4 > pm |
| ingra.cur.medioBezier (p2, pi, pj, p3) | Punto medio bezier, p2 y p3 puntos ancla; pi y pj puntos control > pm |
| ingra.cur.medioBezierL (p2, pi, pj, p3, nivel) | Puntos medios bezier, p2 y p3 puntos ancla; pi y pj puntos control > (nivel)puntos (0)1,(1)3,(2)7,(3)15,(4)31 |
| ingra.cur.puntoBezier (p2, pi, pj, p3, t) | Punto en curva bezier, p2 y p3 puntos ancla; pi y pj puntos control; t:0(p2)..1(p3) p5.js |
| ingra.cur.arco2c (gc, p1, p2, anti) | Cuarto de círculo definido por dos puntos, desde p1 a p2 > {pc,r,a1,a2,anti,pm} |
| ingra.cur.arco2m (gc, p1, p2, anti) | Medio círculo definido por dos puntos, desde p1 a p2 > {pc,r,a1,a2,anti,pm} |
| ingra.cur.arco3a (gc, p1, p2, p3) | Arco de círculo definido por tres puntos, desde p1 a p3 pasando por p2 > {pc,r,a1,a2,anti,pm} |
| ingra.cur.arco2p (p1, p2, enPixel) | Cuarto de círculo definido por dos puntos, desde p1 a p2 > {pc,r,a1,a2,anti,pm} |
| ingra.cur.arco3p (p1, p2, p3) | Arco de círculo definido por tres puntos, desde p1 a p3 pasando por p2 > {pc,r,a1,a2,anti,pm} |
| ingra.cur.elipsePunto (pc, a, b, ang) | Retorna punto en elipse, pc punto central, a y b semiejes, ang en grados desde x+ |
Módulo: ingra.google.js
| ingra.google | Objeto google |
| ingra.google.punto2url (pun, presenta) | De punto en coordenadas geográficas a url de google maps |
| ingra.google.direccion2url (direccion, presenta) | De dirección a url de google maps · "Calle Cronos,24 28037 Madrid" > "https:/www.google.es/maps/place/Calle+Cronos,+24,+28037+Madrid" |
| ingra.google.direccionPresenta (parent, clase, direccion, cbo) | Presenta subventana con dirección en google maps; parent(dom) > cb({omap}); google_maps_address2 ($parent, div_id, address) div_id |
Sección: js.impresor
Módulo: ingra.impresor3.js
| ingra.Impresor3 (imp) | Objeto impresor {tema,pagina, title,style,script}) |
| Funciones en línea, retornan html Se incluyen en textos: "En un lugar "+imp.rojo("De la mancha")+" de cuyo nombre" |
|
| imp.enlinea (eti, html, style, properties) | Etiqueta html en línea |
| imp.negrita (...al) | span con estilo "font-weight:bold" > enlinea(span,...al) |
| imp.oblicua (...al) | span con estilo "font-style:oblique" > enlinea(span,...al) |
| imp.tachada (...al) | span con estilo "text-decoration:line-through" > enlinea(span,...al) |
| imp.rojo (...al) | span con estilo "color:ROJO' > enlinea(span,...al) |
| imp.azul (...al) | span con estilo "color:AZUL' > enlinea(span,...al) |
| imp.span (...al) | > enlinea(span,...al) |
| imp.code (...al) | > enlinea(code,...al) |
| imp._a (...al) | > enlinea(a,...al), si no incluye href en properties: href=html |
| Funciones de bloque, retornan identificador del bloque Ocupan un espacio horizontal completo, el identificador que se puede utilizar en los hijos del bloque |
|
| imp.etiqueta (eti, ...al) | Etiqueta html: al:[pad,html,style,properties] |
| imp.h1 (...al) | > etiqueta(h1,...al) |
| imp.h2 (...al) | > etiqueta(h2,...al) |
| imp.h3 (...al) | > etiqueta(h3,...al) |
| imp.h4 (...al) | > etiqueta(h4,...al) |
| imp.h5 (...al) | > etiqueta(h5,...al) |
| imp.h6 (...al) | > etiqueta(h6,...al) |
| imp.p (...al) | > etiqueta(p,...al) |
| imp.a (...al) | > etiqueta(a,...al) |
| imp.table (...al) | > etiqueta(table,...al), |
| imp.tr (...al) | > etiqueta(tr,...al) |
| imp.td (...al) | > etiqueta(h1,...al), si padre es 'table', inserta 'tr' |
| imp.th (...al) | > etiqueta(h1,...al), si padre es 'table', inserta 'tr' |
| imp.div (...al) | > etiqueta(div,...al) |
| imp.hr (...al) | > etiqueta(hr,...al) |
| imp.canvas (...al) | > etiqueta(canvas,...al) |
| imp.img (...al) | > etiqueta(img,...al), si no incluye src en properties: src=html |
| Utilidades | |
| imp.error (data) | > div ERROR:... rojo |
| imp.titular (...al) | Monta una envolvente con h3, div {pageBreakInside:'avoid'} envolviendo (etiqueta h3 ...al) > retorna identificador de div |
| imp.salto (pad=0) | Salta página, incrementa contador imp.pagn, agrega div con {pageBreakAfter:'always'}), agrega ... en presentación |
| Funciones compuestas | |
| imp.preparaTabla (tabla) | Prepara tabla antes de imprimir, chequea o crea caml, analiza tipo de datos si no definido |
| imp.tabla (tabla, style, properties) | Tabla con documentos o datos y modificadores, ver imp.preparaTabla |
| imp.imagenes () | Lista de imágenes, ima:{url,url2,pis,cod}, tit:titulo num:número por fila |
| imp.inca (meta, style, properties) | Mapa con objeto INCA |
| imp.igra (igra, style, properties) | Gráfica con objeto IGRA, {pad,...} |
| imp.qrcode (qrcode, style, properties) | Gráfica con imagen QR |
| Impresiones múltiples | |
| imp.iniciaParcial () | Inicia impresiones parciales parcial, ingra.Impresor3.parcial:{oll,imp} |
| imp.montaParcial (cb) | Monta impresiones parciales |
Sección: js.presenta
Módulo: ingra.presenta.js
| ingra.presenta.ventana (meta) | presenta contenido en ventana independiente meta:{url,html,texto,textourl(contenido como texto),name} > window.open |
| ingra.presenta.contenedor (contenedor, op=) | presenta contenido en contenedor |
Sección: js.ui
Módulo: ingra.contenedor.js
| ingra.Contenedor (oPadre, titulo, opciones, estilos, propiedades) | Objeto contenedor; opciones:{res,pis,clase,id,relacion,...} :{esContenedor,res} |
| o.pista (a) | Pista |
| o.titulo (a, pis) | Título (pista opcional) |
| o.contador (a) | Contador |
| o.contenido (a) | Contenido |
| o.liberaContenedor () | Libera |
| o.liberaContenido (liberaIconos) | Libera contenido, opcional libera iconos |
| o.liberaIconos () | Libera solo iconos |
| o.libera (liberaIconos=true) | Libera |
| o.oculto () | Retorna bool |
| o.oculta () | Oculta |
| o.presenta () | Presenta |
| o.ponPestana () | Contenedor hijo |
| o.ponModoPestanas () | Contenedor padre, pestaña última o primera |
| ponModoPestanas (oConcepto) | contenedor padre, modo persianas a pestañas |
Módulo: ingra.dialogo.js
Diálogos modales
| ingra.dialogo (titulo, texto, op=) | Diálogo modal > 0,1..(botones) -1,-2,-3.. op:{botones:['Acepta'], icono:'help', color:'azul', tamano:24px, especial, ms(milesegundos espera), fcuerpo1,fcuerpo2, style} || ms especial: onfocus onblur tamano32px, dialogoError|dialogoAviso|dialogoInforma admiten op=ms return: 0,1,...(botones), -1(close) -2(tiempo) -3(escape,...), i(interrumpido) (finalizado), flecha siguiente/anterior |
| ingra.dialogoError (texto, op=) | Dialogo de error (rojo) |
| ingra.dialogoAviso (texto, op=) | Diálogo de aviso (naranja) |
| ingra.dialogoInforma (texto, op=) | Diálogo de información (verde) |
| ingra.dialogoPregunta (titulo, texto, op=) | Diálogo con botones de defecto: Acepta/Cancela.. |
| ingra.dialogoPreguntaAC (titulo, texto, fAcepta=null, fCancela=null, fResto=null) | Diálogo con botones: Acepta/Cancela, fAcepta,fCancela,fResto si existen sino nada |
| ingra.dialogoPreguntaSN (titulo, texto, fSi=null, fNo=null, fResto=null) | Diálogo con botones: Si/No, fSi,fNo,fResto si existen sino nada |
| ingra.dialogoEdita (titulo, texto, valor='', op=) | Diálogo con campo editable > {ret,val} o cb(ret,val) ret:(0,1..|-1|-2|-3) botones de defecto Acepta/Cancela |
| ingra.dialogoEditaAC (titulo, texto, valor='', fAcepta=null, fCancela=null, fResto=null) | Diálogo con campo editable y botones: Acepta/Cancela retorna si fAcepta,fCancela,fResto o nada > {ret,val} o cb(ret,val) |
| ingra.dialogoPassword (titulo, texto, valor='', op=) | Dialogo con campo editable oculto > {ret,val} o cb(ret,val) ret:(0,1..|-1|-2|-3) |
| ingra.dialogoSeleccion (titulo, columnas, filas, op=) | Diálogo de selección, {sel} > {ret,sel} o cb(ret,sel) op.val: Editor además de la lista, op.val:valor de defecto o '', retorna: {ret,sel,val} o cb(ret,sel,val) op.sel: elección por defecto o 0 columnas:[{}] | [""] | "res;tip;ali;cod|...", filas:[[]] | [{}] > { ret (0,1..|-1|-2|-3), sel:(base0}, val:editor grabacomo) } defecto: titulo="Selección de opciones" botones=['Selecciona','Cierra'] |
| ingra.dialogoSeleccionEdita (titulo, columnas, filas, valor='', op=) | Diálogo de selección con editor, {sel} > {ret,sel,val} o cb(ret,sel,val) |
| ingra.dialogoSeleccionMultiple (titulo, columnas, filas, op=) | Diálogo de selección míltiple, {sell} > {ret,sell:[]} o cb(ret,sell) |
| ingra.dialogoSeleccionTCD (titulo, filas, op=) | Diálogo de selección con columnas="Tipo;i;1|Código|Descripción" |
| ingra.dialogoSeleccionEditaTCD (titulo, filas, valor='', op=) | Diálogo de selección con editor con columnas TCD, {sel} > {ret,sel,val} o cb(ret,sel,val) |
| ingra.dialogoSeleccionMultipleTCD (titulo, filas, op=) | Diálogo de selección múltiple con columnas |
| ingra.dialogoColor (titulo, color, op=) | Selección de color > ['Selecciona','Deselecciona','Cierra'] > {ret,color} o cb(ret,color) |
| ingra.dialogoIcono (titulo, icono, op=) | Selección de icono > ['Selecciona','Deselecciona','Cierra'] > {ret,icono} o cb(ret,icono) |
| ingra.dialogoFecha (titulo, fecha, op=) | Selección de fecha {min,max,sem} > {ret,fecha} o cb(ret,fecha) sem:con semanas, min:Fecha mínima, max:Fecha máxima |
| ingra.dialogoFile (op=) | Selecciona archivo > {file}, |
| ingra.dialogoFiles (op, cb) | Selecciona archivos > {files} |
| ingra.dialogoLeeArchivo (op, cb=null) | Dialogo para leer archivo Local, {accept,multiple} > ({file|files}) op.accept: ",.csv,.json,.jsonl,.inca,.incav,.xlsx" ",.inca,.dxi,.geojson,.geopackage,.shp,.gml,.kml,.dxf" |
| Obsoleto > ingra.F.lee | |
| ingra.dialogoGrabaArchivo (arc, data, cb) | Dialogo para grabar archivo Local, data:string|blob > {name,bytes} |
| ingra.dialogoProgreso (titulo, op=) | Diálogo de progreso dia.inter(texto,titulo=null) modifica texto, opcionalmente título, si retorna true se ha interrumpido dia.cierra() cierra el diálogo al acabar |
| ingra.dialogoProgresoNI (titulo, op=) | Diálogo de progreso no interrumpible |
| ingra.dialogoActual () | último diálogo de progreso abierto > {dialog,titulo,texto,cierra,...} |