numbers condition and fix of inline additions

Author: RafaelGB

src/components/cellTypes/NumberCell.tsx

@@ -112,7 +112,7 @@ const NumberCell = (props: CellComponentProps) => {
       }}
       tabIndex={0}
     >
-      {(numberCell !== undefined && numberCell.toString()) || ""}
+      {isNaN(numberCell) ? "" : numberCell}
     </span>
   );
 };

src/lib/features/filters/components/OperatorSelectorComponent.tsx

@@ -56,6 +56,7 @@ function operatorFilterEntriesInFuctionOf(type: string) {
   switch (type) {
     case InputType.CALENDAR:
     case InputType.CALENDAR_TIME:
+    case InputType.NUMBER:
       return rawOperators.filter(
         (op) =>
           ![

src/lib/features/filters/domain/FilterActions.ts

@@ -1,5 +1,5 @@
 import { AtomicFilter, FilterGroup, FilterGroupCondition } from "cdm/SettingsModel";
-import { ConditionFiltersOptions, OperatorFilter } from "helpers/Constants";
+import { ConditionFiltersOptions, InputType, OperatorFilter } from "helpers/Constants";
 import { ColumnFilterOption } from "../model/FiltersModel";
 
 export enum ModifyFilterOptionsEnum {
@@ -71,6 +71,10 @@ const modifyRecursiveFilterGroups = (
                 break;
             case ModifyFilterOptionsEnum.FIELD:
                 (filterGroups[recursiveIndex[level]] as AtomicFilter).field = value;
+                const potentialTypedField = possibleColumns.find(
+                    (column) => column.key === value
+                );
+                (filterGroups[recursiveIndex[level]] as AtomicFilter).type = potentialTypedField ? potentialTypedField.type : InputType.TEXT;
                 break;
             case ModifyFilterOptionsEnum.VALUE:
                 (filterGroups[recursiveIndex[level]] as AtomicFilter).value = value;

src/lib/features/filters/domain/ValidateFilter.ts

@@ -69,15 +69,40 @@ class ValidateFilter {
         if (OperatorFilter.IS_NOT_EMPTY[1] === operatorFilter) {
             return (literalToCheck !== null && literalToCheck !== undefined && literalToCheck !== '');
         }
-
         switch (type) {
             case InputType.CALENDAR:
             case InputType.CALENDAR_TIME:
                 return this.calendarAtomicFilter(literalToCheck, operatorFilter, value);
+            case InputType.NUMBER:
+                return this.numberAtomicFilter(literalToCheck, operatorFilter, value);
             default:
                 return this.mdAtomicFilter(literalToCheck, operatorFilter, value);
         }
     }
+    private numberAtomicFilter(literalToCheck: Literal, operator: string, value: string): boolean {
+        const adaptedLiteral = ParseService.parseLiteral(literalToCheck, InputType.NUMBER, this.ddbbConfig) as number;
+        const adaptedValue = ParseService.parseLiteral(value, InputType.NUMBER, this.ddbbConfig) as number;
+        if (isNaN(adaptedLiteral) || isNaN(adaptedValue)) {
+            return false;
+        }
+        switch (operator) {
+            case OperatorFilter.EQUAL[1]:
+                return adaptedLiteral === adaptedValue;
+            case OperatorFilter.NOT_EQUAL[1]:
+                return adaptedLiteral !== adaptedValue;
+            case OperatorFilter.GREATER_THAN[1]:
+                return adaptedValue > adaptedLiteral;
+            case OperatorFilter.LESS_THAN[1]:
+                return adaptedValue < adaptedLiteral;
+            case OperatorFilter.GREATER_THAN_OR_EQUAL[1]:
+                return adaptedValue >= adaptedLiteral;
+            case OperatorFilter.LESS_THAN_OR_EQUAL[1]:
+                return adaptedValue <= adaptedLiteral;
+            default:
+                LOGGER.error(`Operator ${operator} not supported for numberAtomicFilter`);
+                return false;
+        }
+    }
 
     private calendarAtomicFilter(literalToCheck: Literal, operator: string, value: string): boolean {
         if (!DateTime.isDateTime(literalToCheck)) {

src/patterns/builders/NoteContentActionBuilder.ts

@@ -111,7 +111,7 @@ export default class NoteContentActionBuilder {
             case INLINE_POSITION.LAST_FIELD:
                 if (INLINE_REGEX.INLINE_LAST_FIELD.test(this.content)) {
                     inlineAddRegex = INLINE_REGEX.INLINE_LAST_FIELD;
-                    regex_target = `$1$2$3$4$5$6$7$8$9$10$2$3$4\n${columnId}$6:: ${newValue}$9\n$12`;
+                    regex_target = `$1$2$3$4$5$6$7$8$9$10$2\n$3$4${columnId}$6:: ${newValue}$9\n$12`;
                     break;
                 }
             // Else, fall through to default

src/services/ParseService.ts

@@ -22,7 +22,7 @@ class Parse {
     public parseLiteral(literal: Literal, dataTypeDst: string, localSettings: LocalSettings, isInline = false, wrapQuotes = false): Literal {
         // Check empty or undefined literals
         if (!DataviewService.isTruthy(literal?.toString())) {
-            return "";
+            literal = "";
         }
         literal = this.parseDataArray(literal);
         const wrapped = DataviewService.wrapLiteral(literal);

src/services/parseServiceHelpers/ArrayParser.ts

@@ -3,8 +3,12 @@ import { satinizedColumnOption } from "helpers/FileManagement";
 import { WrappedLiteral } from "obsidian-dataview";
 import { DataviewService } from "services/DataviewService";
 
-class ArrayParser extends TypeParser<string[]> {
+class ArrayParser extends TypeParser<string[] | string> {
     parse(wrapped: WrappedLiteral) {
+        if (wrapped.value === "") {
+            return wrapped.value;
+        }
+
         if (wrapped.type !== 'array') {
             return wrapped.value.toString().split(",").map(s => satinizedColumnOption(s.toString().trim()));
         }

src/stateManagement/columns/handlers/AlterOptionToColumnAction.ts

@@ -11,6 +11,10 @@ export default class AlterOptionToColumnHandlerAction extends AbstractTableActio
             column: TableColumn,
             option: ColumnOption
         ) => {
+            if (option.value === "" || option.label === "") {
+                // End the execution if the option is empty
+                return;
+            }
             if (OptionSource.FORMULA === column.config.option_source) {
                 // End the execution if the option is from a formula
                 return;