@odoo/o-spreadsheet 14.0.1 → 14.0.2

package/src/functions/arguments.ts

@@ -1,114 +0,0 @@
-import { _lt } from "../translation";
-import { Arg, ArgType } from "../types";
-
-//------------------------------------------------------------------------------
-// Arg description DSL
-//------------------------------------------------------------------------------
-
-const ARG_REGEXP = /(.*?)\((.*?)\)(.*)/;
-const ARG_TYPES: ArgType[] = [
-  "ANY",
-  "BOOLEAN",
-  "DATE",
-  "NUMBER",
-  "STRING",
-  "RANGE",
-  "RANGE<BOOLEAN>",
-  "RANGE<DATE>",
-  "RANGE<NUMBER>",
-  "RANGE<STRING>",
-];
-
-/**
- * This function is meant to be used as a tag for a template strings.
- *
- * Its job is to convert a textual description of the list of arguments into an
- * actual array of Arg, suitable for consumption.
- */
-export function args(strings: string): Arg[] {
-  let lines = strings.split("\n");
-  const result: Arg[] = [];
-  for (let l of lines) {
-    l = l.trim();
-    if (l) {
-      result.push(makeArg(l));
-    }
-  }
-  return result;
-}
-
-function makeArg(str: string): Arg {
-  let parts = str.match(ARG_REGEXP)!;
-  let name = parts[1].trim();
-  let types: ArgType[] = [];
-  let isOptional = false;
-  let isRepeating = false;
-  let isLazy = false;
-  let defaultVal;
-
-  for (let param of parts[2].split(",")) {
-    const key = param.trim().toUpperCase();
-    let type = ARG_TYPES.find((t) => key === t);
-    if (type) {
-      types.push(type);
-    } else if (key === "RANGE<ANY>") {
-      types.push("RANGE");
-    } else if (key === "OPTIONAL") {
-      isOptional = true;
-    } else if (key === "REPEATING") {
-      isRepeating = true;
-    } else if (key === "LAZY") {
-      isLazy = true;
-    } else if (key.startsWith("DEFAULT=")) {
-      const value = param.trim().slice(8);
-      defaultVal = value[0] === '"' ? value.slice(1, -1) : parseFloat(value);
-    }
-  }
-  let description = parts[3].trim();
-  const result: Arg = {
-    name,
-    description,
-    type: types,
-  };
-  if (isOptional) {
-    result.optional = true;
-  }
-  if (isRepeating) {
-    result.repeating = true;
-  }
-  if (isLazy) {
-    result.lazy = true;
-  }
-  if (defaultVal !== undefined) {
-    result.default = defaultVal;
-  }
-  return result;
-}
-
-//------------------------------------------------------------------------------
-// Argument validation
-//------------------------------------------------------------------------------
-
-export function validateArguments(args: Arg[]) {
-  let previousArgRepeating: boolean | undefined = false;
-  let previousArgOptional: boolean | undefined = false;
-  for (let current of args) {
-    if (previousArgRepeating) {
-      throw new Error(
-        _lt(
-          "Function ${name} has at least 2 arguments that are repeating. The maximum repeating arguments is 1."
-        )
-      );
-    }
-
-    if (previousArgOptional && !current.optional) {
-      throw new Error(
-        _lt(
-          "Function ${name} has at mandatory arguments declared after optional ones. All optional arguments must be after all mandatory arguments."
-        )
-      );
-    }
-    previousArgRepeating = current.repeating;
-    previousArgOptional = current.optional;
-  }
-}

package/src/functions/dates.ts

@@ -1,302 +0,0 @@
-// -----------------------------------------------------------------------------
-// Date Type
-// -----------------------------------------------------------------------------
-import { _lt } from "../translation";
-import { toNumber } from "./helpers";
-
-/**
- * All Spreadsheet dates are internally stored as an object with two values:
- * - value (number), which represent the number of day till 30/12/1899
- * - format (string), which keep the information on how the date was defined
- */
-export interface InternalDate {
-  value: number;
-  format: string;
-  jsDate: Date;
-}
-
-// -----------------------------------------------------------------------------
-// Parsing
-// -----------------------------------------------------------------------------
-
-const CURRENT_MILLENIAL = 2000; // note: don't forget to update this in 2999
-const CURRENT_YEAR = new Date().getFullYear();
-const INITIAL_1900_DAY = new Date(1899, 11, 30) as any;
-const INITIAL_JS_DAY = new Date(0) as any;
-const DATE_JS_1900_OFFSET = INITIAL_JS_DAY - INITIAL_1900_DAY;
-
-const mdyDateRegexp = /^\d{1,2}(\/|-|\s)\d{1,2}((\/|-|\s)\d{1,4})?$/;
-const ymdDateRegexp = /^\d{3,4}(\/|-|\s)\d{1,2}(\/|-|\s)\d{1,2}$/;
-const timeRegexp = /((\d+(:\d+)?(:\d+)?\s*(AM|PM))|(\d+:\d+(:\d+)?))$/;
-
-export function parseDateTime(str: string): InternalDate | null {
-  str = str.trim();
-
-  let time;
-  const timeMatch = str.match(timeRegexp);
-  if (timeMatch) {
-    time = parseTime(timeMatch[0]);
-    if (time === null) {
-      return null;
-    }
-    str = str.replace(timeMatch[0], "").trim();
-  }
-
-  let date;
-  const mdyDateMatch = str.match(mdyDateRegexp);
-  const ymdDateMatch = str.match(ymdDateRegexp);
-  if (mdyDateMatch || ymdDateMatch) {
-    let dateMatch;
-    if (mdyDateMatch) {
-      dateMatch = mdyDateMatch[0];
-      date = parseDate(dateMatch, "mdy");
-    } else {
-      dateMatch = ymdDateMatch![0];
-      date = parseDate(dateMatch, "ymd");
-    }
-    if (date === null) {
-      return null;
-    }
-    str = str.replace(dateMatch, "").trim();
-  }
-
-  if (str !== "" || !(date || time)) {
-    return null;
-  }
-
-  if (date && time) {
-    return {
-      value: date.value + time.value,
-      format: date.format + " " + (time.format === "hhhh:mm:ss" ? "hh:mm:ss" : time.format),
-      jsDate: new Date(
-        date.jsDate.getFullYear() + time.jsDate.getFullYear() - 1899,
-        date.jsDate.getMonth() + time.jsDate.getMonth() - 11,
-        date.jsDate.getDate() + time.jsDate.getDate() - 30,
-        date.jsDate.getHours() + time.jsDate.getHours(),
-        date.jsDate.getMinutes() + time.jsDate.getMinutes(),
-        date.jsDate.getSeconds() + time.jsDate.getSeconds()
-      ),
-    };
-  }
-
-  return date || time;
-}
-
-function parseDate(str: string, dateFormat: string): InternalDate | null {
-  const isMDY = dateFormat === "mdy";
-  const isYMD = dateFormat === "ymd";
-  if (isMDY || isYMD) {
-    const parts: string[] = str.split(/\/|-|\s/);
-    const monthIndex = isMDY ? 0 : 1;
-    const dayIndex = isMDY ? 1 : 2;
-    const yearIndex = isMDY ? 2 : 0;
-    const month = Number(parts[monthIndex]);
-    const day = Number(parts[dayIndex]);
-    const leadingZero =
-      (parts[monthIndex].length === 2 && month < 10) || (parts[dayIndex].length === 2 && day < 10);
-    const year = parts[yearIndex] ? inferYear(parts[yearIndex]) : CURRENT_YEAR;
-    const jsDate = new Date(year, month - 1, day);
-    const sep = str.match(/\/|-|\s/)![0];
-    if (jsDate.getMonth() !== month - 1 || jsDate.getDate() !== day) {
-      // invalid date
-      return null;
-    }
-    const delta = (jsDate as any) - INITIAL_1900_DAY;
-
-    let format = leadingZero ? `mm${sep}dd` : `m${sep}d`;
-    if (parts[yearIndex]) {
-      format = isMDY ? format + sep + "yyyy" : "yyyy" + sep + format;
-    }
-    return {
-      value: Math.round(delta / 86400000),
-      format: format,
-      jsDate,
-    };
-  }
-  return null;
-}
-
-function inferYear(str: string): number {
-  const nbr = Number(str);
-  switch (str.length) {
-    case 1:
-      return CURRENT_MILLENIAL + nbr;
-    case 2:
-      const offset = CURRENT_MILLENIAL + nbr > CURRENT_YEAR + 10 ? -100 : 0;
-      const base = CURRENT_MILLENIAL + offset;
-      return base + nbr;
-    case 3:
-    case 4:
-      return nbr;
-  }
-  return 0;
-}
-
-function parseTime(str: string): InternalDate | null {
-  str = str.trim();
-  if (timeRegexp.test(str)) {
-    const isAM = /AM/i.test(str);
-    const isPM = /PM/i.test(str);
-    const strTime = isAM || isPM ? str.substring(0, str.length - 2).trim() : str;
-    const parts: string[] = strTime.split(/:/);
-    const isMinutes = parts.length >= 2;
-    const isSeconds = parts.length === 3;
-    let hours = Number(parts[0]);
-    let minutes = isMinutes ? Number(parts[1]) : 0;
-    let seconds = isSeconds ? Number(parts[2]) : 0;
-    let format = isSeconds ? "hh:mm:ss" : "hh:mm";
-
-    if (isAM || isPM) {
-      format += " a";
-    } else if (!isMinutes) {
-      return null;
-    }
-
-    if (hours >= 12 && isAM) {
-      hours -= 12;
-    } else if (hours < 12 && isPM) {
-      hours += 12;
-    }
-
-    minutes += Math.floor(seconds / 60);
-    seconds %= 60;
-    hours += Math.floor(minutes / 60);
-    minutes %= 60;
-
-    if (hours >= 24) {
-      format = "hhhh:mm:ss";
-    }
-
-    const jsDate = new Date(1899, 11, 30, hours, minutes, seconds);
-
-    return {
-      value: hours / 24 + minutes / 1440 + seconds / 86400,
-      format: format,
-      jsDate: jsDate,
-    };
-  }
-  return null;
-}
-
-// -----------------------------------------------------------------------------
-// Conversion
-// -----------------------------------------------------------------------------
-
-function numberToDate(value: number): Date {
-  const truncValue = Math.trunc(value);
-  let date = new Date(truncValue * 86400 * 1000 - DATE_JS_1900_OFFSET);
-
-  let time = value - truncValue;
-  time = time < 0 ? 1 + time : time;
-
-  const hours = Math.round(time * 24);
-  const minutes = Math.round((time - hours / 24) * 24 * 60);
-  const seconds = Math.round((time - hours / 24 - minutes / 24 / 60) * 24 * 60 * 60);
-
-  date.setHours(hours);
-  date.setMinutes(minutes);
-  date.setSeconds(seconds);
-
-  return date;
-}
-
-export function toNativeDate(date: any): Date {
-  if (typeof date === "object" && date !== null) {
-    if (!date.jsDate) {
-      date.jsDate = new Date(date.value * 86400 * 1000 - DATE_JS_1900_OFFSET);
-    }
-    return date.jsDate;
-  }
-  if (typeof date === "string") {
-    let result = parseDateTime(date);
-    if (result !== null && result.jsDate) {
-      return result.jsDate;
-    }
-  }
-  return numberToDate(toNumber(date));
-}
-
-// -----------------------------------------------------------------------------
-// Formatting
-// -----------------------------------------------------------------------------
-
-export function formatDateTime(date: Omit<InternalDate, "jsDate">, format?: string): string {
-  // TODO: unify the format functions for date and datetime
-  // This requires some code to 'parse' or 'tokenize' the format, keep it in a
-  // cache, and use it in a single mapping, that recognizes the special list
-  // of tokens dd,d,m,y,h, ... and preserves the rest
-
-  const dateTimeFormat = format || date.format;
-  const jsDate = toNativeDate(date);
-  const indexH = dateTimeFormat.indexOf("h");
-  let strDate = "";
-  let strTime = "";
-  if (indexH > 0) {
-    strDate = formatJSDate(jsDate, dateTimeFormat.substring(0, indexH - 1));
-    strTime = formatJSTime(jsDate, dateTimeFormat.substring(indexH));
-  } else if (indexH === 0) {
-    strTime = formatJSTime(jsDate, dateTimeFormat);
-  } else if (indexH < 0) {
-    strDate = formatJSDate(jsDate, dateTimeFormat);
-  }
-  return strDate + (strDate && strTime ? " " : "") + strTime;
-}
-
-function formatJSDate(date: Date, format: string): string {
-  const sep = format.match(/\/|-|\s/)![0];
-  const parts = format.split(sep);
-  return parts
-    .map((p) => {
-      switch (p) {
-        case "d":
-          return date.getDate();
-        case "dd":
-          return date.getDate().toString().padStart(2, "0");
-        case "m":
-          return date.getMonth() + 1;
-        case "mm":
-          return String(date.getMonth() + 1).padStart(2, "0");
-        case "yyyy":
-          return date.getFullYear();
-        default:
-          throw new Error(_lt("invalid format"));
-      }
-    })
-    .join(sep);
-}
-
-function formatJSTime(date: Date, format: string): string {
-  let parts = format.split(/:|\s/);
-
-  const dateHours = date.getHours();
-  const isMeridian = parts[parts.length - 1] === "a";
-  let hours = dateHours;
-  let meridian = "";
-  if (isMeridian) {
-    hours = hours === 0 ? 12 : hours > 12 ? hours - 12 : hours;
-    meridian = dateHours >= 12 ? " PM" : " AM";
-    parts.pop();
-  }
-
-  return (
-    parts
-      .map((p) => {
-        switch (p) {
-          case "hhhh":
-            const helapsedHours = Math.floor(
-              (date.getTime() - INITIAL_1900_DAY) / (60 * 60 * 1000)
-            );
-            return helapsedHours.toString();
-          case "hh":
-            return hours.toString().padStart(2, "0");
-          case "mm":
-            return date.getMinutes().toString().padStart(2, "0");
-          case "ss":
-            return date.getSeconds().toString().padStart(2, "0");
-          default:
-            throw new Error("invalid format");
-        }
-      })
-      .join(":") + meridian
-  );
-}