apify luxonhelper

Author: RafaelGB

src/cdm/ModulesFnModel.ts

@@ -1,56 +1,74 @@
 import { Literal } from "obsidian-dataview"
 import { DateTime, DurationLikeObject } from "luxon";
 
-type NumbersFnType = {
+export interface NumbersInterface {
     /**
      * Summatory of the list of values
      * @param values 
      * @returns 
      */
     sum: (values: Literal[]) => number;
+
     /**
      * Obtains the minimum value of the list of values
      * @param values
      * @returns
      */
     min: (values: Literal[]) => number;
+
     /**
      * Obtains the maximum value of the list of values
      * @param values
      * @returns
      */
     max: (values: Literal[]) => number;
-    [key: string]: unknown
 }
 
-type LuxonFnType = {
+export interface LuxonInterface {
     /**
      * Returns the earliest date in the list of values
      * @param values 
      * @returns 
      */
     earliest: (values: Literal[]) => DateTime;
+
     /**
      * Returns the latest date in the list of values
      * @param values
      * @returns
      */
     latest: (values: Literal[]) => DateTime;
+
     /**
      * Returns the duration between the earliest and latest dates in the list of values
      * @param values
      * @param dl - Duration like object key. "days" by default. See https://www.jsdocs.io/package/@types/luxon#DurationLikeObject
      * @returns
      */
     range: (values: Literal[], dl?: keyof DurationLikeObject) => number;
-    [key: string]: unknown
+
+    /**
+     * Parse datetime to string under a given format
+     * @param datetime 
+     * @param format - Default: yyyy-MM-dd HH:mm:ss
+     * @returns 
+     */
+    dateToString: (datetime: DateTime, format?: string) => string;
+
+    /**
+     * Parse string to datetime under a given format
+     * @param datetime 
+     * @param format - Default: yyyy-MM-dd HH:mm:ss  
+     * @returns 
+     */
+    stringToDate(datetime: string, format?: string): DateTime;
 }
 
 /**
  * Exposed functionalities under the `db` variable of Formulas
  */
 export type DatabaseFnType = {
-    numbers: NumbersFnType;
-    luxon: LuxonFnType;
+    numbers: NumbersInterface;
+    luxon: LuxonInterface;
     [key: string]: unknown
 }

src/components/cellTypes/CalendarCell.tsx

@@ -13,8 +13,8 @@ import { TableColumn } from "cdm/FolderModel";
 import { ParseService } from "services/ParseService";
 import { DEFAULT_SETTINGS, InputType } from "helpers/Constants";
 import { Platform } from "obsidian";
-import { parseLuxonDateToString } from "helpers/LuxonHelper";
 import { OBSIDIAN_LOCALE } from "lang/helpers";
+import { Db } from "services/CoreService";
 
 const CalendarCell = (calendarProps: CellComponentProps) => {
   const { defaultCell } = calendarProps;
@@ -111,7 +111,7 @@ const CalendarCell = (calendarProps: CellComponentProps) => {
       }}
       tabIndex={0}
     >
-      {parseLuxonDateToString(
+      {Db.coreFns.luxon.dateToString(
         calendarCell,
         configInfo.getLocalSettings().date_format
       )}

src/components/cellTypes/CalendarTimeCell.tsx

@@ -13,8 +13,8 @@ import { ParseService } from "services/ParseService";
 import { DEFAULT_SETTINGS, InputType } from "helpers/Constants";
 import { c } from "helpers/StylesHelper";
 import { Platform } from "obsidian";
-import { parseLuxonDatetimeToString } from "helpers/LuxonHelper";
 import { OBSIDIAN_LOCALE } from "lang/helpers";
+import { Db } from "services/CoreService";
 
 const CalendarTimeCell = (calendarTimeProps: CellComponentProps) => {
   const { defaultCell } = calendarTimeProps;
@@ -112,7 +112,7 @@ const CalendarTimeCell = (calendarTimeProps: CellComponentProps) => {
       }}
       tabIndex={0}
     >
-      {parseLuxonDatetimeToString(
+      {Db.coreFns.luxon.dateToString(
         calendarCell,
         configInfo.getLocalSettings().datetime_format
       )}

src/helpers/LuxonHelper.ts

@@ -25,7 +25,6 @@ export abstract class DbModule implements IGenerateObject {
         await this.create_dynamic_functions();
 
         return {
-            ...this.static_object,
             ...this.static_object,
             ...Object.fromEntries(this.dynamic_functions),
         };

src/lib/core/DbModule.ts

@@ -1,51 +1,59 @@
 import { DbModule } from "lib/core/DbModule";
 import { Literal } from "obsidian-dataview";
 import { DateTime, DurationLikeObject } from "luxon";
+import { DEFAULT_SETTINGS } from "helpers/Constants";
+import { LuxonInterface } from "cdm/ModulesFnModel";
 
-export class LuxonFn extends DbModule {
+
+export class LuxonFn extends DbModule implements LuxonInterface {
     public name: string = "luxon";
 
     async create_static_functions(): Promise<void> {
         this.static_functions.set("earliest", this.earliest.bind(this));
         this.static_functions.set("latest", this.latest.bind(this));
-        this.static_functions.set("range", this.rangeDate.bind(this));
+        this.static_functions.set("range", this.range.bind(this));
+        this.static_functions.set("dateToString", this.dateToString.bind(this));
+        this.static_functions.set("stringToDate", this.stringToDate.bind(this));
     }
 
     async create_dynamic_functions(): Promise<void> { }
 
-    private parseRaw(rawValues: Literal[]): DateTime[] {
+    parseRaw(rawValues: Literal[]): DateTime[] {
         return rawValues
             .filter((value) => DateTime.isDateTime(value))
             .map((value) => value as DateTime);
     }
 
-    /**
-     * Obtains the earliest date of the column (only for dates)
-     * @param rawValues 
-     * @returns 
-     */
-    private earliest(rawValues: Literal[]): DateTime {
+    earliest(rawValues: Literal[]): DateTime {
         return DateTime.min(...this
             .parseRaw(rawValues))
 
     }
 
-    /**
-     * Obtains the latest date of the column (only for dates)
-     * @returns 
-     */
-    private latest(rawValues: Literal[]): DateTime {
+    latest(rawValues: Literal[]): DateTime {
         return DateTime.max(...this
             .parseRaw(rawValues))
     }
 
-    /**
-     * Obtains a range of dates of the column (only for dates) in a given duration
-     * @returns
-     */
-    private rangeDate(rawValues: Literal[], dl: keyof DurationLikeObject = "days"): number {
+    range(rawValues: Literal[], dl: keyof DurationLikeObject = "days"): number {
         const earliest = this.earliest(rawValues);
         const latest = this.latest(rawValues);
         return latest.diff(earliest).as(dl);
     }
+
+    dateToString(datetime: DateTime, format = DEFAULT_SETTINGS.local_settings.datetime_format) {
+        const isDate = DateTime.isDateTime(datetime);
+        return isDate
+            ? datetime.toFormat(format) : null;
+    }
+
+    stringToDate(datetime: string, format = DEFAULT_SETTINGS.local_settings.datetime_format) {
+        let result: DateTime = null;
+        result = DateTime.fromFormat(datetime, format);
+        if (!result.isValid) {
+            result = null;
+        }
+
+        return result;
+    }
 }

src/lib/core/modules/LuxonFn.ts

@@ -1,8 +1,9 @@
+import { NumbersInterface } from "cdm/ModulesFnModel";
 import { DbModule } from "lib/core/DbModule";
 import { Literal } from "obsidian-dataview";
 
 
-export class NumbersFn extends DbModule {
+export class NumbersFn extends DbModule implements NumbersInterface {
     public name: string = "numbers";
 
     async create_static_functions(): Promise<void> {
@@ -13,46 +14,35 @@ export class NumbersFn extends DbModule {
 
     async create_dynamic_functions(): Promise<void> { }
 
-    private parseRaw(rawValues: Literal[]): number[] {
-        return rawValues
-            .filter((value) => value &&
-                typeof value === "string" ||
-                typeof value === "number")
-            .map((value) => {
-                return parseFloat(value.toString());
-            }).filter((value) => {
-                return !isNaN(value);
-            });
-    }
-
-    /**
-     * Obtains the sum of all values
-     * @returns 
-     */
-    private sum(rawValues: Literal[]): number {
+    sum(rawValues: Literal[]): number {
         // Check if key is not truthy, return empty string
         return this
             .parseRaw(rawValues)
             .reduce((a, b) => a + b, 0);
     }
 
-    /**
-     * Obtains the minimum value of the column (only for numbers)
-     * @returns 
-     */
-    private min(rawValues: Literal[]): number {
+    min(rawValues: Literal[]): number {
         return this
             .parseRaw(rawValues)
             .reduce((acc: number, value: number) => Math.min(acc, value), Number.MAX_SAFE_INTEGER);
     }
 
-    /**
-     * Obtains the maximum value of the column (only for numbers)
-     * @returns
-     */
-    private max(rawValues: Literal[]): number {
+    max(rawValues: Literal[]): number {
         return this
             .parseRaw(rawValues)
             .reduce((acc: number, value: number) => Math.max(acc, value), Number.MIN_SAFE_INTEGER);
     }
+
+
+    private parseRaw(rawValues: Literal[]): number[] {
+        return rawValues
+            .filter((value) => value &&
+                typeof value === "string" ||
+                typeof value === "number")
+            .map((value) => {
+                return parseFloat(value.toString());
+            }).filter((value) => {
+                return !isNaN(value);
+            });
+    }
 }

src/lib/core/modules/NumbersFn.ts

@@ -1,7 +1,7 @@
 import { TypeParser } from "cdm/ServicesModel";
-import { parseStringToLuxonDatetime } from "helpers/LuxonHelper";
 import { WrappedLiteral } from "obsidian-dataview";
 import { DateTime } from "luxon";
+import { Db } from "services/CoreService";
 
 class CalendarParser extends TypeParser<DateTime> {
     private dateFormat: string;
@@ -13,7 +13,7 @@ class CalendarParser extends TypeParser<DateTime> {
 
     parse(wrapped: WrappedLiteral) {
         if (wrapped.type === 'string') {
-            return parseStringToLuxonDatetime(wrapped.value, this.dateFormat);
+            return Db.coreFns.luxon.stringToDate(wrapped.value, this.dateFormat);
         }
 
         if (DateTime.isDateTime(wrapped.value)) {

src/services/parseServiceHelpers/CalendarParser.ts

@@ -2,8 +2,8 @@ import { TypeParser } from "cdm/ServicesModel";
 import { satinizedColumnOption } from "helpers/FileManagement";
 import { Literal, WrappedLiteral } from "obsidian-dataview";
 import { DateTime } from "luxon";
-import { parseLuxonDatetimeToString } from "helpers/LuxonHelper";
 import { DataviewService } from "services/DataviewService";
+import { Db } from "services/CoreService";
 
 class SelectParser extends TypeParser<string> {
     /**
@@ -16,7 +16,7 @@ class SelectParser extends TypeParser<string> {
         switch (wrapped.type) {
             case 'object':
                 if (DateTime.isDateTime(wrapped.value)) {
-                    parsedValue = parseLuxonDatetimeToString(wrapped.value, this.config.datetime_format);
+                    parsedValue = Db.coreFns.luxon.dateToString(wrapped.value, this.config.datetime_format);
                 } else if (DataviewService.getDataviewAPI().isDataArray(wrapped.value)) {
                     parsedValue = this.parseArrayToText(
                         (wrapped.value.values as Literal[])