@eodash/eodash 5.0.0-rc.3 → 5.1.0

package/dist/client/templates.js

@@ -0,0 +1,850 @@
+import { mdiViewDashboardVariant, mdiViewDashboard } from '@mdi/js';
+import { G as includesProcess } from './helpers-Dy0Q13tP.js';
+
+/**
+ * Special values that tell deepmerge to perform a certain action.
+ */
+const actions = {
+    defaultMerge: Symbol("deepmerge-ts: default merge")};
+/**
+ * Special values that tell deepmergeInto to perform a certain action.
+ */
+const actionsInto = {
+    defaultMerge: actions.defaultMerge,
+};
+
+/**
+ * The default function to update meta data.
+ *
+ * It doesn't update the meta data.
+ */
+function defaultMetaDataUpdater(previousMeta, metaMeta) {
+    return metaMeta;
+}
+/**
+ * The default function to filter values.
+ *
+ * It filters out undefined values.
+ */
+function defaultFilterValues(values, meta) {
+    return values.filter((value) => value !== undefined);
+}
+
+/**
+ * The different types of objects deepmerge-ts support.
+ */
+var ObjectType;
+(function (ObjectType) {
+    ObjectType[ObjectType["NOT"] = 0] = "NOT";
+    ObjectType[ObjectType["RECORD"] = 1] = "RECORD";
+    ObjectType[ObjectType["ARRAY"] = 2] = "ARRAY";
+    ObjectType[ObjectType["SET"] = 3] = "SET";
+    ObjectType[ObjectType["MAP"] = 4] = "MAP";
+    ObjectType[ObjectType["OTHER"] = 5] = "OTHER";
+})(ObjectType || (ObjectType = {}));
+/**
+ * Get the type of the given object.
+ *
+ * @param object - The object to get the type of.
+ * @returns The type of the given object.
+ */
+function getObjectType(object) {
+    if (typeof object !== "object" || object === null) {
+        return 0 /* ObjectType.NOT */;
+    }
+    if (Array.isArray(object)) {
+        return 2 /* ObjectType.ARRAY */;
+    }
+    if (isRecord(object)) {
+        return 1 /* ObjectType.RECORD */;
+    }
+    if (object instanceof Set) {
+        return 3 /* ObjectType.SET */;
+    }
+    if (object instanceof Map) {
+        return 4 /* ObjectType.MAP */;
+    }
+    return 5 /* ObjectType.OTHER */;
+}
+/**
+ * Get the keys of the given objects including symbol keys.
+ *
+ * Note: Only keys to enumerable properties are returned.
+ *
+ * @param objects - An array of objects to get the keys of.
+ * @returns A set containing all the keys of all the given objects.
+ */
+function getKeys(objects) {
+    const keys = new Set();
+    for (const object of objects) {
+        for (const key of [...Object.keys(object), ...Object.getOwnPropertySymbols(object)]) {
+            keys.add(key);
+        }
+    }
+    return keys;
+}
+/**
+ * Does the given object have the given property.
+ *
+ * @param object - The object to test.
+ * @param property - The property to test.
+ * @returns Whether the object has the property.
+ */
+function objectHasProperty(object, property) {
+    return typeof object === "object" && Object.prototype.propertyIsEnumerable.call(object, property);
+}
+/**
+ * Get an iterable object that iterates over the given iterables.
+ */
+function getIterableOfIterables(iterables) {
+    let mut_iterablesIndex = 0;
+    let mut_iterator = iterables[0]?.[Symbol.iterator]();
+    return {
+        [Symbol.iterator]() {
+            return {
+                next() {
+                    do {
+                        if (mut_iterator === undefined) {
+                            return { done: true, value: undefined };
+                        }
+                        const result = mut_iterator.next();
+                        if (result.done === true) {
+                            mut_iterablesIndex += 1;
+                            mut_iterator = iterables[mut_iterablesIndex]?.[Symbol.iterator]();
+                            continue;
+                        }
+                        return {
+                            done: false,
+                            value: result.value,
+                        };
+                    } while (true);
+                },
+            };
+        },
+    };
+}
+// eslint-disable-next-line unicorn/prefer-set-has -- Array is more performant for a low number of elements.
+const validRecordToStringValues = ["[object Object]", "[object Module]"];
+/**
+ * Does the given object appear to be a record.
+ */
+function isRecord(value) {
+    // All records are objects.
+    if (!validRecordToStringValues.includes(Object.prototype.toString.call(value))) {
+        return false;
+    }
+    const { constructor } = value;
+    // If has modified constructor.
+    // eslint-disable-next-line ts/no-unnecessary-condition
+    if (constructor === undefined) {
+        return true;
+    }
+    const prototype = constructor.prototype;
+    // If has modified prototype.
+    if (prototype === null ||
+        typeof prototype !== "object" ||
+        !validRecordToStringValues.includes(Object.prototype.toString.call(prototype))) {
+        return false;
+    }
+    // If constructor does not have an Object-specific method.
+    // eslint-disable-next-line sonar/prefer-single-boolean-return, no-prototype-builtins
+    if (!prototype.hasOwnProperty("isPrototypeOf")) {
+        return false;
+    }
+    // Most likely a record.
+    return true;
+}
+
+/**
+ * The default strategy to merge records into a target record.
+ *
+ * @param mut_target - The result will be mutated into this record
+ * @param values - The records (including the target's value if there is one).
+ */
+function mergeRecordsInto$1(mut_target, values, utils, meta) {
+    for (const key of getKeys(values)) {
+        const propValues = [];
+        for (const value of values) {
+            if (objectHasProperty(value, key)) {
+                propValues.push(value[key]);
+            }
+        }
+        if (propValues.length === 0) {
+            continue;
+        }
+        const updatedMeta = utils.metaDataUpdater(meta, {
+            key,
+            parents: values,
+        });
+        const propertyTarget = { value: propValues[0] };
+        mergeUnknownsInto(propertyTarget, propValues, utils, updatedMeta);
+        if (key === "__proto__") {
+            Object.defineProperty(mut_target.value, key, {
+                value: propertyTarget.value,
+                configurable: true,
+                enumerable: true,
+                writable: true,
+            });
+        }
+        else {
+            mut_target.value[key] = propertyTarget.value;
+        }
+    }
+}
+/**
+ * The default strategy to merge arrays into a target array.
+ *
+ * @param mut_target - The result will be mutated into this array
+ * @param values - The arrays (including the target's value if there is one).
+ */
+function mergeArraysInto$1(mut_target, values) {
+    mut_target.value.push(...values.slice(1).flat());
+}
+/**
+ * The default strategy to merge sets into a target set.
+ *
+ * @param mut_target - The result will be mutated into this set
+ * @param values - The sets (including the target's value if there is one).
+ */
+function mergeSetsInto$1(mut_target, values) {
+    for (const value of getIterableOfIterables(values.slice(1))) {
+        mut_target.value.add(value);
+    }
+}
+/**
+ * The default strategy to merge maps into a target map.
+ *
+ * @param mut_target - The result will be mutated into this map
+ * @param values - The maps (including the target's value if there is one).
+ */
+function mergeMapsInto$1(mut_target, values) {
+    for (const [key, value] of getIterableOfIterables(values.slice(1))) {
+        mut_target.value.set(key, value);
+    }
+}
+/**
+ * Set the target to the last value.
+ */
+function mergeOthersInto$1(mut_target, values) {
+    mut_target.value = values.at(-1);
+}
+/**
+ * The merge functions.
+ */
+const mergeIntoFunctions = {
+    mergeRecords: mergeRecordsInto$1,
+    mergeArrays: mergeArraysInto$1,
+    mergeSets: mergeSetsInto$1,
+    mergeMaps: mergeMapsInto$1,
+    mergeOthers: mergeOthersInto$1,
+};
+
+function deepmergeInto(target, ...objects) {
+    return void deepmergeIntoCustom({})(target, ...objects);
+}
+function deepmergeIntoCustom(options, rootMetaData) {
+    const utils = getIntoUtils(options, customizedDeepmergeInto);
+    /**
+     * The customized deepmerge function.
+     */
+    function customizedDeepmergeInto(target, ...objects) {
+        mergeUnknownsInto({ value: target }, [target, ...objects], utils, rootMetaData);
+    }
+    return customizedDeepmergeInto;
+}
+/**
+ * The the utils that are available to the merge functions.
+ *
+ * @param options - The options the user specified
+ */
+function getIntoUtils(options, customizedDeepmergeInto) {
+    return {
+        defaultMergeFunctions: mergeIntoFunctions,
+        mergeFunctions: {
+            ...mergeIntoFunctions,
+            ...Object.fromEntries(Object.entries(options)
+                .filter(([key, option]) => Object.hasOwn(mergeIntoFunctions, key))
+                .map(([key, option]) => (option === false ? [key, mergeIntoFunctions.mergeOthers] : [key, option]))),
+        },
+        metaDataUpdater: (options.metaDataUpdater ?? defaultMetaDataUpdater),
+        deepmergeInto: customizedDeepmergeInto,
+        filterValues: options.filterValues === false ? undefined : (options.filterValues ?? defaultFilterValues),
+        actions: actionsInto,
+    };
+}
+/**
+ * Merge unknown things into a target.
+ *
+ * @param mut_target - The target to merge into.
+ * @param values - The values.
+ */
+function mergeUnknownsInto(mut_target, values, utils, meta) {
+    const filteredValues = utils.filterValues?.(values, meta) ?? values;
+    if (filteredValues.length === 0) {
+        return;
+    }
+    if (filteredValues.length === 1) {
+        return void mergeOthersInto(mut_target, filteredValues, utils, meta);
+    }
+    const type = getObjectType(mut_target.value);
+    if (type !== 0 /* ObjectType.NOT */ && type !== 5 /* ObjectType.OTHER */) {
+        for (let mut_index = 1; mut_index < filteredValues.length; mut_index++) {
+            if (getObjectType(filteredValues[mut_index]) === type) {
+                continue;
+            }
+            return void mergeOthersInto(mut_target, filteredValues, utils, meta);
+        }
+    }
+    switch (type) {
+        case 1 /* ObjectType.RECORD */: {
+            return void mergeRecordsInto(mut_target, filteredValues, utils, meta);
+        }
+        case 2 /* ObjectType.ARRAY */: {
+            return void mergeArraysInto(mut_target, filteredValues, utils, meta);
+        }
+        case 3 /* ObjectType.SET */: {
+            return void mergeSetsInto(mut_target, filteredValues, utils, meta);
+        }
+        case 4 /* ObjectType.MAP */: {
+            return void mergeMapsInto(mut_target, filteredValues, utils, meta);
+        }
+        default: {
+            return void mergeOthersInto(mut_target, filteredValues, utils, meta);
+        }
+    }
+}
+/**
+ * Merge records into a target record.
+ *
+ * @param mut_target - The target to merge into.
+ * @param values - The records.
+ */
+function mergeRecordsInto(mut_target, values, utils, meta) {
+    const action = utils.mergeFunctions.mergeRecords(mut_target, values, utils, meta);
+    if (action === actionsInto.defaultMerge) {
+        utils.defaultMergeFunctions.mergeRecords(mut_target, values, utils, meta);
+    }
+}
+/**
+ * Merge arrays into a target array.
+ *
+ * @param mut_target - The target to merge into.
+ * @param values - The arrays.
+ */
+function mergeArraysInto(mut_target, values, utils, meta) {
+    const action = utils.mergeFunctions.mergeArrays(mut_target, values, utils, meta);
+    if (action === actionsInto.defaultMerge) {
+        utils.defaultMergeFunctions.mergeArrays(mut_target, values);
+    }
+}
+/**
+ * Merge sets into a target set.
+ *
+ * @param mut_target - The target to merge into.
+ * @param values - The sets.
+ */
+function mergeSetsInto(mut_target, values, utils, meta) {
+    const action = utils.mergeFunctions.mergeSets(mut_target, values, utils, meta);
+    if (action === actionsInto.defaultMerge) {
+        utils.defaultMergeFunctions.mergeSets(mut_target, values);
+    }
+}
+/**
+ * Merge maps into a target map.
+ *
+ * @param mut_target - The target to merge into.
+ * @param values - The maps.
+ */
+function mergeMapsInto(mut_target, values, utils, meta) {
+    const action = utils.mergeFunctions.mergeMaps(mut_target, values, utils, meta);
+    if (action === actionsInto.defaultMerge) {
+        utils.defaultMergeFunctions.mergeMaps(mut_target, values);
+    }
+}
+/**
+ * Merge other things into a target.
+ *
+ * @param mut_target - The target to merge into.
+ * @param values - The other things.
+ */
+function mergeOthersInto(mut_target, values, utils, meta) {
+    const action = utils.mergeFunctions.mergeOthers(mut_target, values, utils, meta);
+    if (action === actionsInto.defaultMerge || mut_target.value === actionsInto.defaultMerge) {
+        utils.defaultMergeFunctions.mergeOthers(mut_target, values);
+    }
+}
+
+/** @type {import("@/types").Template} */
+const light = {
+  gap: 16,
+  loading: {
+    id: Symbol(),
+    type: "web-component",
+    widget: {
+      // https://uiball.com/ldrs/
+      link: "https://cdn.jsdelivr.net/npm/ldrs/dist/auto/mirage.js",
+      tagName: "l-mirage",
+      properties: {
+        class: "align-self-center justify-self-center",
+        size: "120",
+        speed: "2.5",
+        color: "#004170",
+      },
+    },
+  },
+  background: {
+    id: "background-map",
+    type: "internal",
+    widget: {
+      name: "EodashMap",
+      properties: {
+        enableCompare: true,
+      },
+    },
+  },
+  widgets: [
+    {
+      id: "tools-light",
+      type: "internal",
+      title: "Tools",
+      layout: { x: 0, y: 0, w: "3/3/2", h: 1 },
+      widget: {
+        name: "EodashTools",
+        properties: {
+          layoutTarget: "expert",
+          layoutIcon: mdiViewDashboardVariant,
+          itemFilterConfig: {
+            resultType: "cards",
+            filtersTitle: "",
+            filterProperties: [],
+            resultsTitle: "Explore more indicators",
+            subTitleProperty: "subtitle",
+            imageProperty: "thumbnail",
+            cssVars: {
+              "--filter-display": "none",
+            },
+          },
+        },
+      },
+    },
+    {
+      defineWidget: (selectedSTAC) => {
+        return selectedSTAC
+          ? {
+              id: "layercontrol-light",
+              type: "internal",
+              title: "Layers",
+              layout: { x: 0, y: 1, w: "3/3/2", h: 10 },
+              widget: {
+                name: "EodashLayerControl",
+                properties: {
+                  slider: false,
+                  tools: ["datetime", "info", "legend"],
+                  cssVars: {
+                    "--list-padding": "-8px",
+                    "--tools-button-visibility": "none",
+                    "--layer-input-visibility": "none",
+                    "--layer-type-visibility": "none",
+                    "--padding": "8px",
+                    "--padding-vertical": "16px",
+                    "--layer-tools-button-visibility": "none",
+                    "--layer-toggle-button-visibility": "flex",
+                    "--layer-summary-visibility": "none",
+                    "--layer-visibility": "none",
+                  },
+                },
+              },
+            }
+          : null;
+      },
+    },
+    {
+      defineWidget: (selectedSTAC) => {
+        return selectedSTAC
+          ? {
+              id: "stacinfo-light",
+              type: "internal",
+              title: "Information",
+              layout: { x: "9/9/10", y: 0, w: "3/3/2", h: 12 },
+              widget: {
+                name: "EodashStacInfo",
+                properties: {
+                  tags: [],
+                  header: [],
+                  footer: [],
+                  body: ["description"],
+                  styleOverride: "",
+                  featured: [],
+                },
+              },
+            }
+          : null;
+      },
+    },
+    {
+      defineWidget: (selectedSTAC) => {
+        return selectedSTAC
+          ? {
+              id: "light-datepicker",
+              type: "internal",
+              layout: { x: 4, y: 7, w: 4, h: 5 },
+              title: "Date",
+              widget: {
+                name: "EodashDatePicker",
+                properties: {
+                  hintText: `<b>Hint:</b> closest available date is displayed <br />
+                            on map (see Analysis Layers)`,
+                },
+              },
+            }
+          : null;
+      },
+    },
+  ],
+};
+
+/** @type {import("@/types").Template} */
+const expert = {
+  loading: {
+    id: Symbol(),
+    type: "web-component",
+    widget: {
+      // https://uiball.com/ldrs/
+      link: "https://cdn.jsdelivr.net/npm/ldrs/dist/auto/mirage.js",
+      tagName: "l-mirage",
+      properties: {
+        class: "align-self-center justify-self-center",
+        size: "120",
+        speed: "2.5",
+        color: "#004170",
+      },
+    },
+  },
+  background: {
+    id: "background-map",
+    type: "internal",
+    widget: {
+      name: "EodashMap",
+      properties: {
+        enableCompare: true,
+      },
+    },
+  },
+  widgets: [
+    {
+      id: "Tools",
+      type: "internal",
+      title: "Tools",
+      layout: { x: 0, y: 0, w: "3/3/2", h: 1 },
+      widget: {
+        name: "EodashTools",
+        properties: {
+          layoutTarget: "light",
+          layoutIcon: mdiViewDashboard,
+          itemFilterConfig: {
+            resultType: "cards",
+            subTitleProperty: "subtitle",
+            imageProperty: "thumbnail",
+            aggregateResults: "collection_group",
+          },
+        },
+      },
+    },
+    {
+      id: "Layercontrol",
+      type: "internal",
+      title: "Layers",
+      layout: { x: 0, y: 1, w: "3/3/2", h: 11 },
+      widget: {
+        name: "EodashLayerControl",
+      },
+    },
+    {
+      defineWidget: (selectedSTAC) => {
+        return selectedSTAC
+          ? {
+              id: "Information",
+              title: "Information",
+              layout: { x: "9/9/10", y: 0, w: "3/3/2", h: 6 },
+              type: "internal",
+              widget: {
+                name: "EodashStacInfo",
+              },
+            }
+          : null;
+      },
+    },
+    {
+      defineWidget: (selectedSTAC) => {
+        return selectedSTAC
+          ? {
+              id: "expert-datepicker",
+              type: "internal",
+              layout: { x: 4, y: 7, w: 4, h: 5 },
+              title: "Date",
+              widget: {
+                name: "EodashDatePicker",
+                properties: {
+                  hintText: `<b>Hint:</b> closest available date is displayed <br />
+                            on map (see Analysis Layers)`,
+                  toggleCalendar: true,
+                },
+              },
+            }
+          : null;
+      },
+    },
+    {
+      defineWidget: (selected) => {
+        return selected
+          ? {
+              id: "Buttons",
+              layout: { x: "8/8/9", y: 0, w: 1, h: 2 },
+              title: "Buttons",
+              type: "internal",
+              widget: {
+                name: "EodashMapBtns",
+              },
+            }
+          : null;
+      },
+    },
+    {
+      defineWidget: (selectedSTAC) =>
+        includesProcess(selectedSTAC) && {
+          id: "Processes",
+          type: "internal",
+          title: "Processes",
+          layout: { x: "9/9/10", y: 6, w: "3/3/2", h: 5 },
+          widget: {
+            name: "EodashProcess",
+          },
+        },
+    },
+  ],
+};
+
+/** @type {import("@/types").Template} */
+const compare = {
+  gap: 16,
+  loading: {
+    id: Symbol(),
+    type: "web-component",
+    widget: {
+      // https://uiball.com/ldrs/
+      link: "https://cdn.jsdelivr.net/npm/ldrs/dist/auto/mirage.js",
+      tagName: "l-mirage",
+      properties: {
+        class: "align-self-center justify-self-center",
+        size: "120",
+        speed: "2.5",
+        color: "#004170",
+      },
+    },
+  },
+  background: {
+    id: "background-map",
+    type: "internal",
+    widget: {
+      name: "EodashMap",
+      properties: {
+        enableCompare: true,
+      },
+    },
+  },
+  widgets: [
+    {
+      id: "Tools",
+      type: "internal",
+      title: "Tools",
+      layout: { x: 0, y: 0, w: "3/3/2", h: 1 },
+      widget: {
+        name: "EodashTools",
+        properties: {
+          showLayoutSwitcher: false,
+          itemFilterConfig: {
+            resultType: "cards",
+            filtersTitle: "Select an indicator",
+            resultsTitle: "",
+            subTitleProperty: "subtitle",
+            imageProperty: "thumbnail",
+          },
+        },
+      },
+    },
+    // compare indicators
+    {
+      id: "CompareTools",
+      type: "internal",
+      title: "Tools",
+      layout: { x: "9/9/10", y: 0, w: "3/3/2", h: 1 },
+      widget: {
+        name: "EodashTools",
+        properties: {
+          showLayoutSwitcher: false,
+          indicatorBtnText: "Select second indicator",
+          itemFilterConfig: {
+            enableCompare: true,
+            resultType: "cards",
+            filtersTitle: "Select an indicator to compare",
+            resultsTitle: "",
+            subTitleProperty: "subtitle",
+            imageProperty: "thumbnail",
+          },
+        },
+      },
+    },
+    {
+      id: "layercontrol",
+      type: "internal",
+      title: "Layers",
+      layout: { x: 0, y: 1, w: "3/3/2", h: 5 },
+      widget: {
+        name: "EodashLayerControl",
+      },
+    },
+    {
+      id: "CompareLayerControl",
+      title: "Comparison Layers",
+      layout: { x: "9/9/10", y: 1, w: "3/3/2", h: 5 },
+      type: "internal",
+      widget: {
+        name: "EodashLayerControl",
+        properties: {
+          map: "second",
+        },
+      },
+    },
+    {
+      defineWidget: (selectedSTAC) =>
+        includesProcess(selectedSTAC) && {
+          id: "Process",
+          type: "internal",
+          title: "Processes",
+          layout: { x: 0, y: 6, w: "3/3/2", h: 5 },
+          widget: {
+            name: "EodashProcess",
+          },
+        },
+    },
+    {
+      defineWidget: (_, updatedCompareStac) =>
+        includesProcess(updatedCompareStac, true) && {
+          id: "CompareMapProcess",
+          type: "internal",
+          title: "Processes",
+          layout: { x: 9, y: 6, w: "3/3/2", h: 5 },
+          widget: {
+            name: "EodashProcess",
+            properties: {
+              enableCompare: true,
+            },
+          },
+        },
+    },
+    {
+      defineWidget: (selected) => {
+        return selected
+          ? {
+              id: "Buttons",
+              layout: { x: "8/8/9", y: 0, w: 1, h: 2 },
+              title: "Buttons",
+              type: "internal",
+              widget: {
+                name: "EodashMapBtns",
+                properties: {
+                  compareIndicators: {
+                    fallbackTemplate: "expert",
+                  },
+                },
+              },
+            }
+          : null;
+      },
+    },
+    {
+      defineWidget: (selectedSTAC) => {
+        return selectedSTAC
+          ? {
+              id: "expert-Datepicker",
+              type: "internal",
+              layout: { x: 4, y: 7, w: 4, h: 5 },
+              title: "Date",
+              widget: {
+                name: "EodashDatePicker",
+                properties: {
+                  hintText: `<b>Hint:</b> closest available date is displayed <br />
+                                on map (see Analysis Layers)`,
+                  toggleCalendar: true,
+                },
+              },
+            }
+          : null;
+      },
+    },
+  ],
+};
+
+/** @type {import("@/types").Eodash} */
+const baseConfig = {
+  id: "demo",
+  options: {
+    // useSubCode: true,
+  },
+  stacEndpoint:
+    "https://esa-eodashboards.github.io/eodashboard-catalog/trilateral/catalog.json",
+  brand: {
+    noLayout: true,
+    name: "Demo",
+    font: {
+      headers: {
+        family: "Open Sans",
+        link: "https://eox.at/fonts/opensans/opensans.css",
+      },
+      body: {
+        family: "Sintony",
+        link: "https://eox.at/fonts/sintony/sintony.css",
+      },
+    },
+    theme: {
+      colors: {
+        primary: "#002742",
+        secondary: "#0071C2",
+        surface: "#ffff",
+      },
+      variables: {
+        "surface-opacity": 0.8,
+        "primary-opacity": 0.8,
+      },
+      // Bank-Wong palette
+      collectionsPalette: [
+        "#009E73",
+        "#E69F00",
+        "#56B4E9",
+        "#009E73",
+        "#F0E442",
+        "#0072B2",
+        "#D55E00",
+        "#CC79A7",
+        "#994F00",
+      ],
+    },
+    footerText: "Demo configuration of eodash client",
+  },
+  templates: {
+    light,
+    expert,
+    compare,
+  },
+};
+
+/**
+ * @param {Partial<import("@/types").Eodash>} config
+ */
+const getBaseConfig = (config) => {
+  const merged = /** @type {import("@/types").Eodash} */ ({});
+  deepmergeInto(merged, baseConfig, config || {});
+  return merged;
+};
+
+export { compare, getBaseConfig as default, expert, getBaseConfig, light };