@sapphire-ion/framework 0.30.26 → 0.30.28

package/build.ps1

@@ -0,0 +1,39 @@
+$HorizontalBoxChar = [string][char]9552
+$VerticalBoxChar = [string][char]9553
+$TopLeftBoxChar = [string][char]9556
+$TopRightBoxChar = [string][char]9559
+$BottomLeftBoxChar = [string][char]9562
+$BottomRightBoxChar = [string][char]9565
+
+Function CreateBoxText() {
+    Begin {
+        $lines = @()
+    }
+    Process {
+        $maxLength = 0
+        $lineCount = 0
+        $_ -split "`r`n" | ForEach-Object {
+            $lines += $_
+            If ($lines[$lineCount].Length -gt $maxLength) {
+                $maxLength = $lines[$lineCount].Length
+            }
+            $lineCount++
+        }
+    }
+    End {
+        $TopLeftBoxChar + ($HorizontalBoxChar * ($maxLength + 2)) + $TopRightBoxChar
+        For ($i = 0; $i -lt $lineCount; $i++) {
+            $VerticalBoxChar + " " + $lines[$i] + (" " * ($maxLength - $lines[$i].Length + 1)) + $VerticalBoxChar
+        }
+        $BottomLeftBoxChar + ($HorizontalBoxChar * ($maxLength + 2)) + $BottomRightBoxChar
+    }   
+}
+
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+echo "Starting build at: $basedir" | CreateBoxText
+$newMinorVesion = npm version patch
+npm run build
+cd "$($basedir)/dist"
+npm publish --access=public
+cd "$($basedir)"
+echo "Build $newMinorVesion completed and published successfully!" | CreateBoxText

package/ng-package.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "./dist",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  },
+  "assets": [
+    { "input": "src/lib", "glob": "**/*.{scss,css,ttf}", "output": "themes" }
+  ]
+}

package/package.json

@@ -1,41 +1,37 @@
-{
-  "name": "@sapphire-ion/framework",
-  "version": "0.30.26",
-  "private": false,
-  "peerDependencies": {
-    "@angular/common": "^18.2.8",
-    "@angular/core": "^18.2.8",
-    "@angular/forms": "^18.2.8",
-    "@ionic/angular": "^8.3.1",
-    "@maskito/angular": "^3.1.2",
-    "@maskito/core": "^3.1.2",
-    "@maskito/kit": "^3.1.0",
-    "@ngx-translate/core": "^16.0.3",
-    "jwt-decode": "^4.0.0",
-    "@capawesome/capacitor-file-picker": "^7.0.1",
-    "@capacitor/preferences": "^7.0.0",
-    "@capacitor/clipboard": "^7.0.0",
-    "@capacitor/camera": "^7.0.0",
-    "@types/node": "^20.11.2",
-    "ts-node": "^8.3.0",
-    "moment": "^2.30.1",
-    "typescript": "~5.5.3"
-  },
-  "dependencies": {
-    "tslib": "^2.3.0"
-  },
-  "sideEffects": false,
-  "module": "fesm2022/sapphire-ion-framework.mjs",
-  "typings": "index.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "esm2022": "./esm2022/sapphire-ion-framework.mjs",
-      "esm": "./esm2022/sapphire-ion-framework.mjs",
-      "default": "./fesm2022/sapphire-ion-framework.mjs"
-    }
-  }
-}
+{
+  "name": "@sapphire-ion/framework",
+  "version": "0.30.28",
+  "private": false,
+  "scripts": {
+    "build": "npx tailwindcss@3.4.17 -c ./tailwind.config.js -o ./src/lib/compiled-styles.scss && ng build",
+    "css": "npx tailwindcss@3.4.17 -c ./tailwind.config.js -o ./src/lib/compiled-styles.scss"
+  },
+  "peerDependencies": {
+    "@angular/common": "^18.2.8",
+    "@angular/core": "^18.2.8",
+    "@angular/forms": "^18.2.8",
+    "@ionic/angular": "^8.3.1",
+    "@maskito/angular": "^3.1.2",
+    "@maskito/core": "^3.1.2",
+    "@maskito/kit": "^3.1.0",
+    "@ngx-translate/core": "^16.0.3",
+    "jwt-decode": "^4.0.0",
+    "@capawesome/capacitor-file-picker": "^7.0.1",
+    "@capacitor/preferences": "^7.0.0",
+    "@capacitor/clipboard": "^7.0.0",
+    "@capacitor/camera": "^7.0.0",
+    "@types/node": "^20.11.2",
+    "ts-node": "^8.3.0",
+    "moment": "^2.30.1",
+    "typescript": "~5.5.3"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "devDependencies": {
+    "autoprefixer": "^10.4.17",
+    "postcss": "^8.4.35",
+    "tailwindcss": "^3.4.17"
+  }
+}

package/src/lib/classes/comparison/comparison-operator.ts

@@ -0,0 +1,17 @@
+export enum ComparisonOperator{
+  Equals             = 1,
+  GreaterThan        = 2,
+  GreaterThanOrEqual = 3,
+  LessThan           = 4,
+  LessThanOrEqual    = 5,
+  IsContainedIn      = 6,
+}
+
+export const ComparisonOperatorString: Map<ComparisonOperator, string> = new Map<ComparisonOperator, string>([
+  [ComparisonOperator.Equals            , "Equals"            ],
+  [ComparisonOperator.GreaterThan       , "GreaterThan"       ],
+  [ComparisonOperator.GreaterThanOrEqual, "GreaterThanOrEqual"],
+  [ComparisonOperator.LessThan          , "LessThan"          ],
+  [ComparisonOperator.LessThanOrEqual   , "LessThanOrEqual"   ],
+  [ComparisonOperator.IsContainedIn     , "IsContainedIn"     ],
+]);

package/src/lib/classes/comparison/comparison-value-type.ts

@@ -0,0 +1,34 @@
+export enum ComparisonValueType{
+  Long       = 10,
+  ListLong   = 11,
+  
+  Int        = 20,
+  ListInt    = 21,
+  
+  Enum       = 30,
+  ListEnum   = 31,
+
+  Decimal    = 40,
+  ListDecimal = 41,
+
+  String     = 50,
+  ListString = 51,
+
+  DateTime   = 60,
+  ListDateTime = 61,
+
+  Date       = 70,
+  ListDate   = 71,
+
+  Time       = 80,
+  ListTime   = 81,
+
+
+  List       = 90,
+  ListList   = 91,
+
+  Bool       = 100,
+  ListBool   = 101,
+
+  ListUnknown = 200,
+}

package/src/lib/classes/comparison/comparison.ts

@@ -0,0 +1,45 @@
+import { TableField } from "../inputs/table-field";
+import { ComparisonOperator, ComparisonOperatorString } from "./comparison-operator";
+import { ComparisonValueType } from "./comparison-value-type";
+
+export class Comparison<T = any> {
+  constructor(
+    public propertyName: string,
+    public operator: ComparisonOperator,
+    public value: T | undefined = undefined,
+    public valueType: ComparisonValueType,
+
+    public disableChange: boolean = false,
+
+    /** @beta */
+    public isNot: boolean = false,
+
+    /** @beta */
+    public targetTable: string | undefined = undefined,
+  ){}
+
+  public toString(): string {
+    return `${this.propertyName} ${ComparisonOperatorString.get(this.operator)} ${this.value}`;
+  }
+}
+
+export function CompileLstTableField(lstTableFields: TableField[]): Comparison[] {
+  var lstComparison: Comparison[] = [];
+  for (const tf of lstTableFields) {
+    if(!tf.filter){ continue; } 
+
+    if(lstComparison){
+      lstComparison.push(...tf.filter);
+    }else{
+      lstComparison = [...tf.filter]; 
+    }
+  }
+  return lstComparison;
+}
+
+/**
+ * @deprecated
+ */
+export function CompileFilters(filter: Comparison[]){
+  return filter.map(p => p);
+}

package/src/lib/classes/comparison/properties/bool-property.ts

@@ -0,0 +1,16 @@
+import { Comparison } from "../comparison";
+import { ComparisonOperator } from "../comparison-operator";
+import { ComparisonValueType } from "../comparison-value-type";
+
+export class BoolProperty {
+  constructor(
+    public propertyName: string
+  ) {  }
+  
+  Equals(value: boolean): Comparison<boolean> {
+    return new Comparison<boolean>(this.propertyName, ComparisonOperator.Equals, value, ComparisonValueType.Bool);
+  }
+  IsContainedIn(value: boolean[]): Comparison<boolean[]> {
+    return new Comparison<boolean[]>(this.propertyName, ComparisonOperator.IsContainedIn, value, ComparisonValueType.ListBool);
+  }
+}

package/src/lib/classes/comparison/properties/date-property.ts

@@ -0,0 +1,28 @@
+import { Comparison } from "../comparison";
+import { ComparisonOperator } from "../comparison-operator";
+import { ComparisonValueType } from "../comparison-value-type";
+
+export class DateProperty {
+  constructor(
+    public propertyName: string
+  ) {  }
+  
+  Equals(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.Equals, value, ComparisonValueType.Date);
+  }
+  GreaterThan(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.GreaterThan, value, ComparisonValueType.Date);
+  }
+  GreaterThanOrEqual(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.GreaterThanOrEqual, value, ComparisonValueType.Date);
+  }
+  LessThan(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.LessThan, value, ComparisonValueType.Date);
+  }
+  LessThanOrEqual(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.LessThanOrEqual, value, ComparisonValueType.Date);
+  }
+  IsContainedIn(value: string[]): Comparison<string[]> {
+    return new Comparison<string[]>(this.propertyName, ComparisonOperator.IsContainedIn, value, ComparisonValueType.ListDate);
+  }
+}

package/src/lib/classes/comparison/properties/datetime-property.ts

@@ -0,0 +1,28 @@
+import { Comparison } from "../comparison";
+import { ComparisonOperator } from "../comparison-operator";
+import { ComparisonValueType } from "../comparison-value-type";
+
+export class DateTimeProperty {
+  constructor(
+    public propertyName: string
+  ) {  }
+  
+  Equals(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.Equals, value, ComparisonValueType.DateTime);
+  }
+  GreaterThan(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.GreaterThan, value, ComparisonValueType.DateTime);
+  }
+  GreaterThanOrEqual(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.GreaterThanOrEqual, value, ComparisonValueType.DateTime);
+  }
+  LessThan(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.LessThan, value, ComparisonValueType.DateTime);
+  }
+  LessThanOrEqual(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.LessThanOrEqual, value, ComparisonValueType.DateTime);
+  }
+  IsContainedIn(value: string[]): Comparison<string[]> {
+    return new Comparison<string[]>(this.propertyName, ComparisonOperator.IsContainedIn, value, ComparisonValueType.ListDateTime);
+  }
+}

package/src/lib/classes/comparison/properties/decimal-property.ts

@@ -0,0 +1,28 @@
+import { Comparison } from "../comparison";
+import { ComparisonOperator } from "../comparison-operator";
+import { ComparisonValueType } from "../comparison-value-type";
+
+export class DecimalProperty {
+  constructor(
+    public propertyName: string
+  ) {  }
+  
+  Equals(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.Equals, value, ComparisonValueType.Decimal);
+  }
+  GreaterThan(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.GreaterThan, value, ComparisonValueType.Decimal);
+  }
+  GreaterThanOrEqual(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.GreaterThanOrEqual, value, ComparisonValueType.Decimal);
+  }
+  LessThan(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.LessThan, value, ComparisonValueType.Decimal);
+  }
+  LessThanOrEqual(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.LessThanOrEqual, value, ComparisonValueType.Decimal);
+  }
+  IsContainedIn(value: number[]): Comparison<number[]> {
+    return new Comparison<number[]>(this.propertyName, ComparisonOperator.IsContainedIn, value, ComparisonValueType.ListDecimal);
+  }
+}

package/src/lib/classes/comparison/properties/enum-property.ts

@@ -0,0 +1,28 @@
+import { Comparison } from "../comparison";
+import { ComparisonOperator } from "../comparison-operator";
+import { ComparisonValueType } from "../comparison-value-type";
+
+export class EnumProperty {
+  constructor(
+    public propertyName: string
+  ) {  }
+  
+  Equals(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.Equals, value, ComparisonValueType.Enum);
+  }
+  GreaterThan(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.GreaterThan, value, ComparisonValueType.Enum);
+  }
+  GreaterThanOrEqual(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.GreaterThanOrEqual, value, ComparisonValueType.Enum);
+  }
+  LessThan(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.LessThan, value, ComparisonValueType.Enum);
+  }
+  LessThanOrEqual(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.LessThanOrEqual, value, ComparisonValueType.Enum);
+  }
+  IsContainedIn(value: number[]): Comparison<number[]> {
+    return new Comparison<number[]>(this.propertyName, ComparisonOperator.IsContainedIn, value, ComparisonValueType.ListEnum);
+  }
+}

package/src/lib/classes/comparison/properties/implicit-property.ts

@@ -0,0 +1,13 @@
+import { Comparison } from "../comparison";
+import { ComparisonOperator } from "../comparison-operator";
+import { ComparisonValueType } from "../comparison-value-type";
+
+export class ImplicitProperty {
+  constructor(
+    public propertyName: string
+  ) {  }
+  
+  IsContainedIn(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.IsContainedIn, value, ComparisonValueType.ListUnknown);
+  }
+}

package/src/lib/classes/comparison/properties/int-property.ts

@@ -0,0 +1,28 @@
+import { Comparison } from "../comparison";
+import { ComparisonOperator } from "../comparison-operator";
+import { ComparisonValueType } from "../comparison-value-type";
+
+export class IntProperty {
+  constructor(
+    public propertyName: string
+  ) {  }
+  
+  Equals(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.Equals, value, ComparisonValueType.Int);
+  }
+  GreaterThan(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.GreaterThan, value, ComparisonValueType.Int);
+  }
+  GreaterThanOrEqual(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.GreaterThanOrEqual, value, ComparisonValueType.Int);
+  }
+  LessThan(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.LessThan, value, ComparisonValueType.Int);
+  }
+  LessThanOrEqual(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.LessThanOrEqual, value, ComparisonValueType.Int);
+  }
+  IsContainedIn(value: number[]): Comparison<number[]> {
+    return new Comparison<number[]>(this.propertyName, ComparisonOperator.IsContainedIn, value, ComparisonValueType.ListInt);
+  }
+}

package/src/lib/classes/comparison/properties/long-property.ts

@@ -0,0 +1,28 @@
+import { Comparison } from "../comparison";
+import { ComparisonOperator } from "../comparison-operator";
+import { ComparisonValueType } from "../comparison-value-type";
+
+export class LongProperty {
+  constructor(
+    public propertyName: string
+  ) {  }
+  
+  Equals(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.Equals, value, ComparisonValueType.Long);
+  }
+  GreaterThan(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.GreaterThan, value, ComparisonValueType.Long);
+  }
+  GreaterThanOrEqual(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.GreaterThanOrEqual, value, ComparisonValueType.Long);
+  }
+  LessThan(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.LessThan, value, ComparisonValueType.Long);
+  }
+  LessThanOrEqual(value: number): Comparison<number> {
+    return new Comparison<number>(this.propertyName, ComparisonOperator.LessThanOrEqual, value, ComparisonValueType.Long);
+  }
+  IsContainedIn(value: number[]): Comparison<number[]> {
+    return new Comparison<number[]>(this.propertyName, ComparisonOperator.IsContainedIn, value, ComparisonValueType.ListLong);
+  }
+}

package/src/lib/classes/comparison/properties/string-property.ts

@@ -0,0 +1,16 @@
+import { Comparison } from "../comparison";
+import { ComparisonOperator } from "../comparison-operator";
+import { ComparisonValueType } from "../comparison-value-type";
+
+export class StringProperty {
+  constructor(
+    public propertyName: string
+  ) {  }
+  
+  Equals(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.Equals, value, ComparisonValueType.String);
+  }
+  IsContainedIn(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.IsContainedIn, value, ComparisonValueType.String);
+  } 
+}

package/src/lib/classes/comparison/properties/time-property.ts

@@ -0,0 +1,28 @@
+import { Comparison } from "../comparison";
+import { ComparisonOperator } from "../comparison-operator";
+import { ComparisonValueType } from "../comparison-value-type";
+
+export class TimeProperty {
+  constructor(
+    public propertyName: string
+  ) {  }
+  
+  Equals(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.Equals, value, ComparisonValueType.Time);
+  }
+  GreaterThan(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.GreaterThan, value, ComparisonValueType.Time);
+  }
+  GreaterThanOrEqual(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.GreaterThanOrEqual, value, ComparisonValueType.Time);
+  }
+  LessThan(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.LessThan, value, ComparisonValueType.Time);
+  }
+  LessThanOrEqual(value: string): Comparison<string> {
+    return new Comparison<string>(this.propertyName, ComparisonOperator.LessThanOrEqual, value, ComparisonValueType.Time);
+  }
+  IsContainedIn(value: string[]): Comparison<string[]> {
+    return new Comparison<string[]>(this.propertyName, ComparisonOperator.IsContainedIn, value, ComparisonValueType.ListTime);
+  }
+}

package/{lib/classes/credentials.d.ts → src/lib/classes/credentials.ts}

@@ -1,5 +1,5 @@
-/** Interface base para utilização de credenciais para autenticação na API */
-export interface Credentials {
-    apelido: string;
-    senha: string;
-}
+/** Interface base para utilização de credenciais para autenticação na API */
+export interface Credentials{
+  apelido : string;
+  senha   : string;
+}

package/src/lib/classes/environment.ts

@@ -0,0 +1,35 @@
+import { INT_MAX } from "../services/utils.service";
+import { Credentials } from "./credentials";
+import { ViewFiltros } from "./filters/view-filtros";
+import { PageOption } from "./page-option";
+
+export class Environment {
+  production     : boolean = false;
+  applicationName: string  = "Panel";
+  apiUrl         : string | null = null;
+  defaultCredentials: Credentials = { apelido: "admin", senha: "Coopertec@2017" };
+  defaultPageLimits : PageOption[] = [
+    { value: 25  , label: "25"    },
+    { value: 50  , label: "50"    },
+    { value: 100 , label: "100"   },
+    { value: 200 , label: "200"   },
+    { value: INT_MAX, label: "Todos" },
+  ];
+  get defaultPageLimit(): number | null {
+    return this.defaultPageLimits[0].value
+  }
+  get defaultPaginationObject(): ViewFiltros{
+    return new ViewFiltros(10, "", 1)
+  }
+
+  constructor(production: boolean, applicationName: string, apiUrl: string, defaultCredentials?: Credentials, defaultPageLimits?: PageOption[]){
+    this.production         = production;
+    this.applicationName    = applicationName;
+    this.apiUrl             = apiUrl;
+    //[ ApiUrls ]
+    if(defaultCredentials)
+    this.defaultCredentials = defaultCredentials;
+    if(defaultPageLimits)
+    this.defaultPageLimits  = defaultPageLimits
+  }
+}

package/src/lib/classes/filters/view-filtros.ts

@@ -0,0 +1,18 @@
+import { INT_MAX } from "../../services/utils.service";
+import { Comparison } from "../comparison/comparison";
+
+export class ViewFiltros{
+  limit          : number       = 0;
+  public filter  : Comparison[] = [];
+
+  constructor(
+      limit : number | null = 25, 
+      public search: string = "", 
+      public page  : number = 1, 
+      public orderByProperty: string | null = null, 
+      public ascending      : boolean = true
+  ){
+      if(limit == null){ this.limit = INT_MAX } 
+      else             { this.limit = limit; }
+  }
+}

package/src/lib/classes/infinite-scroll.ts

@@ -0,0 +1,112 @@
+import { InfiniteScrollCustomEvent } from "@ionic/angular";
+
+/**
+ * @deprecated
+ */
+export class InfiniteScroll {
+  public configuration: InfiniteScrollConfiguration;
+
+  private console: InfiniteScrollConsole;
+  
+  constructor(configuration: InfiniteScrollConfiguration){
+    this.configuration = configuration;
+    
+    this.console = new InfiniteScrollConsole(configuration.logging);
+  } 
+
+  get pushTreshhold(): number { return this.configuration.pushTreshold } 
+
+  private originalArray: any[] = [];
+  public internalArray: any[] = [];
+
+  public array: any[] = [];
+
+  get CanScroll(): boolean{
+    return this.array.length != this.internalArray.length
+  }
+  get NoItems(): boolean{
+    return this.array.length == 0;
+  }
+
+  public PushItens(event? : InfiniteScrollCustomEvent): void {
+    const minimum = this.array.length;
+    const size    = this.array.length + this.pushTreshhold;
+
+    for (let i = minimum; i < size; i++) {
+      this.console.log("[ Pushing @ ]", i, minimum, size, this.originalArray.length)
+      if(i > this.originalArray.length){ 
+        this.console.warn("[ Warning! ] [ End of array! ]"); 
+        break; 
+      }
+
+      const data = this.internalArray[i];
+      if(data){ this.array.push(data); }
+    }
+
+    if(event){ event.target.complete(); }
+  }
+
+  public search: string = "";
+  
+  public SetArray(array: any[]){
+    this.originalArray = array;
+    this.internalArray = array;
+    this.array        = [];
+  }
+  
+  public Search(){
+    this.internalArray = [];
+    this.array         = [];
+  
+    var search: string = this.search.toLowerCase();
+
+    this.originalArray.forEach(el => {
+      var hidden: boolean = true;
+      const lbl = this.getLabel(el).toLowerCase();
+      try{
+        hidden = !lbl.includes(search);
+      }catch{ 
+        this.console.warn("[ Error in searching @ object! ]", this.configuration, el) 
+      }
+
+      if(!hidden){ this.internalArray.push(el); }
+    });
+
+    this.PushItens();
+  }
+
+  private getLabel(item: any): string{
+    return typeof(this.configuration.bindLabel) == 'function' ? this.configuration.bindLabel(item) + '' : item[this.configuration.bindLabel] + ''
+  }
+}
+  
+export class InfiniteScrollConfiguration{
+  bindLabel    : string | ((...args: any[]) => string);
+  pushTreshold : number   = 50;
+  logging      : boolean = false;
+  constructor(bindLabel: string | ((...args: any[]) => string) = "nome", pushTreshold: number = 50, logging: boolean = false){
+    this.bindLabel    = bindLabel
+    this.pushTreshold = pushTreshold
+    this.logging      = logging
+  }
+}
+
+class InfiniteScrollConsole {
+  private logging: boolean = false;
+  constructor(logging: boolean){
+    this.logging = logging;
+    const _ = ((...args: any[]) : void => { return; })
+    this.warn  = _;
+    this.log   = _;
+    this.error = _;
+    if(logging){
+      this.log   = console.log;
+      this.warn  = console.warn;
+      this.error = console.error;
+    }
+  }
+
+  warn  : ((...args: any[]) => void );
+  log   : ((...args: any[]) => void );
+  error : ((...args: any[]) => void );
+}