@m4l/gclick 0.0.2

package/contexts/RealTimeProducerContext/sourceDataMechanisms/dummy/dummy.js

@@ -0,0 +1,66 @@
+import { a as GNSSEnumSignal } from "../../../../@types/constants.js";
+import { S as SourceDataBase } from "../base.js";
+import { d as devicesStatusIds, a as devicesIds } from "./constants.js";
+import { g as getDummyRandomCoordinates } from "./helpers.js";
+class SourceDataDummy extends SourceDataBase {
+  intervalId = null;
+  constructor(config, onMessages) {
+    super(config, onMessages);
+  }
+  /**
+   * Start the source data
+   */
+  start() {
+    let first = true;
+    this.intervalId = setInterval(() => {
+      const deviceIndex = parseInt(Math.random() * devicesIds.length + "");
+      const deviceId = devicesIds[deviceIndex];
+      const payload = {
+        current: {
+          vpts: {
+            vptGnss: {
+              gnssAddress: "Vía Sabanalarga - Barranquilla, Km 2.42 Sabanalarga - Campeche Sabanalarga, Atlántico",
+              gnssSpeed: Math.random() * 120,
+              gnssMotionStatus: { value: devicesStatusIds[deviceIndex] },
+              gnssCourse: Math.random() * 360,
+              ...getDummyRandomCoordinates(),
+              gnssSignal: {
+                value: GNSSEnumSignal.reliable,
+                udaptedAt: void 0
+              },
+              gnssHdop: 0,
+              gnssSatelliteQuantity: 0,
+              gnssAltitude: 0,
+              gnssOdometer: 0
+            },
+            vptModem: {
+              lastConnection: (/* @__PURE__ */ new Date()).toISOString(),
+              lastEvent: (/* @__PURE__ */ new Date()).toISOString(),
+              modemCsq: 31,
+              callActive: false
+            }
+          }
+        }
+      };
+      const dummyData = {
+        type: first ? "new" : "update",
+        resourceSerialId: deviceId,
+        payload
+      };
+      first = false;
+      this.onMessages(this.config.resourceTypeId, [dummyData]);
+    }, 1e3);
+  }
+  /**
+   * Stop the source data
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+}
+export {
+  SourceDataDummy as S
+};

package/contexts/RealTimeProducerContext/sourceDataMechanisms/dummy/group.d.ts

@@ -0,0 +1,36 @@
+export declare const group0: {
+    id: number;
+    name: string;
+    bgColor: string;
+    color: string;
+};
+export declare const group1: {
+    id: number;
+    name: string;
+    bgColor: string;
+    color: string;
+};
+export declare const group2: {
+    id: number;
+    name: string;
+    bgColor: string;
+    color: string;
+};
+export declare const group3: {
+    id: number;
+    name: string;
+    bgColor: string;
+    color: string;
+};
+export declare const group4: {
+    id: number;
+    name: string;
+    bgColor: string;
+    color: string;
+};
+export declare const group5: {
+    id: number;
+    name: string;
+    bgColor: string;
+    color: string;
+};

package/contexts/RealTimeProducerContext/sourceDataMechanisms/dummy/group.js

@@ -0,0 +1,45 @@
+const group0 = {
+  id: 1,
+  name: "Group bien largo en el texo para que haga elipsisi",
+  bgColor: "#CFD8DC",
+  color: "#000000"
+};
+const group1 = {
+  id: 1,
+  name: "Group bien largo en el texo para que haga elipsisi",
+  bgColor: "#B45BAB",
+  color: "#FFFFFF"
+};
+const group2 = {
+  id: 2,
+  name: "Group 2",
+  bgColor: "#24A188",
+  color: "#FFFFFF"
+};
+const group3 = {
+  id: 3,
+  name: "Group 3",
+  bgColor: "#2A3232",
+  color: "#FFFFFF"
+};
+const group4 = {
+  id: 4,
+  name: "Group 4",
+  bgColor: "#E1E4B5",
+  color: "#000000"
+};
+const group5 = {
+  id: 5,
+  name: "Group 5",
+  bgColor: "#EEFF00",
+  //Amarillo
+  color: "#000000"
+};
+export {
+  group4 as a,
+  group3 as b,
+  group2 as c,
+  group1 as d,
+  group0 as e,
+  group5 as g
+};

package/contexts/RealTimeProducerContext/sourceDataMechanisms/dummy/helpers.d.ts

@@ -0,0 +1,10 @@
+export declare const centerLatDefault = 6.216601050665157;
+export declare const centerLonDafault = -75.58660090089732;
+export declare const radiusDefault = 100;
+/**
+ * getDummyRandomCoordinates
+ */
+export declare function getDummyRandomCoordinates(lat?: number, lon?: number, radius?: number): {
+    gnssLatitude: number;
+    gnssLongitude: number;
+};

package/contexts/RealTimeProducerContext/sourceDataMechanisms/dummy/helpers.js

@@ -0,0 +1,15 @@
+const centerLatDefault = 6.216601050665157;
+const centerLonDafault = -75.58660090089732;
+const radiusDefault = 100;
+function getDummyRandomCoordinates(lat = centerLatDefault, lon = centerLonDafault, radius = radiusDefault) {
+  const earthRadius = 6378137;
+  const radiusInDegrees = radius / earthRadius * (180 / Math.PI);
+  const angle = Math.random() * 2 * Math.PI;
+  const distance = Math.random() * radiusInDegrees;
+  const newLat = lat + distance * Math.cos(angle);
+  const newLon = lon + distance * Math.sin(angle) / Math.cos(lat * Math.PI / 180);
+  return { gnssLatitude: newLat, gnssLongitude: newLon };
+}
+export {
+  getDummyRandomCoordinates as g
+};

package/contexts/RealTimeProducerContext/sourceDataMechanisms/factory.d.ts

@@ -0,0 +1,12 @@
+import { OnMessagesStoreCallback, RealTimeResourceSourceMechanismConfig } from '../types';
+import { default as SourceDataBase } from './base';
+/**
+ * Source data factory
+ */
+export declare class SourceDataFactory {
+    /**
+     * Create a source data object
+     */
+    static createSourceData(config: RealTimeResourceSourceMechanismConfig, onMessages: OnMessagesStoreCallback): SourceDataBase;
+}
+export default SourceDataFactory;

package/contexts/RealTimeProducerContext/sourceDataMechanisms/factory.js

@@ -0,0 +1,20 @@
+import { S as SourceDataAtmosphere } from "./athmospherejs/index.js";
+import { S as SourceDataDummy } from "./dummy/dummy.js";
+class SourceDataFactory {
+  /**
+   * Create a source data object
+   */
+  static createSourceData(config, onMessages) {
+    switch (config.sourceDataMechanism) {
+      case "dummy":
+        return new SourceDataDummy(config, onMessages);
+      case "atmosphere":
+        return new SourceDataAtmosphere(config, onMessages);
+      default:
+        throw new Error(`Unknown resource type: ${config.sourceDataMechanism}`);
+    }
+  }
+}
+export {
+  SourceDataFactory as S
+};

package/contexts/RealTimeProducerContext/store.d.ts

@@ -0,0 +1,6 @@
+import { RealTimeProducerStoreStateWithActions, InitialRealTimeProducerStoreProps } from './types';
+/**
+ * TODO: Documentar
+ */
+export declare function createRealTimeStore(initProps: InitialRealTimeProducerStoreProps, storeDevtoolsEnabled?: boolean): import('zustand').StoreApi<RealTimeProducerStoreStateWithActions>;
+export type RealTimeStoreType = ReturnType<typeof createRealTimeStore>;

package/contexts/RealTimeProducerContext/store.js

@@ -0,0 +1,136 @@
+import { createStore } from "zustand";
+import { devtools } from "zustand/middleware";
+import { immer } from "zustand/middleware/immer";
+import merge from "lodash-es/merge";
+import { O as ObjectQueue } from "../../utils/ObjectQueue.js";
+import { R as REALTIME_PRODUCER_SOTORE_ID, P as PROCCESS_MESSAGES_INTERVAL } from "./constants.js";
+import { S as SourceDataFactory } from "./sourceDataMechanisms/factory.js";
+import { cloneDeep } from "lodash-es";
+const createDevtools = (immerMiddlewere, config) => {
+  const { enabled = false } = config;
+  if (enabled && process.env.NODE_ENV === "development") {
+    return devtools(immerMiddlewere, config);
+  }
+  return immerMiddlewere;
+};
+function createRealTimeStore(initProps, storeDevtoolsEnabled = false) {
+  const startProps = {
+    ...initProps,
+    hasResourcesTypes: {}
+  };
+  const hasResourcesTypesMessagesManager = {};
+  return createStore(
+    createDevtools(
+      immer((set, get) => ({
+        ...startProps,
+        realTimeProducerActions: {
+          /**
+           * Incializa el store con los recursos configurados, e inicia la captura de datos para cada tipo de recurso suscripto.
+           */
+          init: () => {
+            const { resourceTypesConfig, realTimeProducerActions: realTimeActions } = get();
+            set((state) => {
+              for (const resourceTypeConfig of resourceTypesConfig) {
+                state.hasResourcesTypes[resourceTypeConfig.resourceTypeId] = {
+                  config: resourceTypeConfig,
+                  sourceDataClass: SourceDataFactory.createSourceData(resourceTypeConfig, realTimeActions.onMessages),
+                  status: "init",
+                  hasResources: resourceTypeConfig.initialHashResources ? cloneDeep(resourceTypeConfig.initialHashResources) : {},
+                  suscribedClients: {}
+                };
+                hasResourcesTypesMessagesManager[resourceTypeConfig.resourceTypeId] = {
+                  messagesToProcces: [],
+                  messagesQueue: new ObjectQueue(),
+                  statusProccesing: false
+                };
+                state.hasResourcesTypes[resourceTypeConfig.resourceTypeId].sourceDataClass.start();
+              }
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setStatus: () => {
+          },
+          /**
+           * suscribe a un cliente MFS al tiempo real, usado por los MFS para recibir los mensajes que llegan al host.
+           * Retorna una copia hasResorces
+           */
+          suscribe: (resourceTypeId, options) => {
+            const { onSuscribeCallbacks, ...otherOptions } = options;
+            set((state) => {
+              if (resourceTypeId in state.hasResourcesTypes) {
+                state.hasResourcesTypes[resourceTypeId].suscribedClients[options.clientId] = otherOptions;
+              }
+            });
+            for (let index = 0; index < onSuscribeCallbacks.length; index++) {
+              const onSuscribeCallback = onSuscribeCallbacks[index];
+              onSuscribeCallback(resourceTypeId, cloneDeep(get().hasResourcesTypes[resourceTypeId].hasResources));
+            }
+          },
+          /**
+           * desuscribe a un cliente MFS al tiempo real, para dejar de recibir los mensajes que llegan al host.
+           */
+          unsuscribe: (resourceTypeId, clientId) => {
+            set((state) => {
+              delete state.hasResourcesTypes[resourceTypeId].suscribedClients[clientId];
+            });
+          },
+          /**
+           * Funcion que procesa los mensajes que llegan desde el servidor, indpendiente de donde llegue, sea por socket, simulados, etc.
+           */
+          onMessages: (resourceTypeId, messages) => {
+            messages.forEach((message) => {
+              hasResourcesTypesMessagesManager[resourceTypeId].messagesQueue.enqueue(message);
+            });
+            get().realTimeProducerActions.processMessages(resourceTypeId);
+          },
+          /**
+           * Procesa los mensajes en la cola de mensajes, se encarga de procesar los mensajes uno a uno en el orden que llegaron.
+           */
+          processMessages: (initialResourceTypeId) => {
+            if (hasResourcesTypesMessagesManager[initialResourceTypeId].statusProccesing) {
+              return;
+            }
+            function processNext(resourceTypeId) {
+              let continueNext = true;
+              set((state) => {
+                const message = hasResourcesTypesMessagesManager[resourceTypeId].messagesQueue.dequeue();
+                if (message) {
+                  const { resourceSerialId, payload } = message;
+                  Object.keys(state.hasResourcesTypes[resourceTypeId].suscribedClients).forEach((clientId) => {
+                    const onMessageCallbacks = state.hasResourcesTypes[resourceTypeId].suscribedClients[clientId].onMessageCallbacks;
+                    for (let index = 0; index < onMessageCallbacks.length; index++) {
+                      onMessageCallbacks[index](resourceTypeId, [message]);
+                    }
+                  });
+                  if (!state.hasResourcesTypes[resourceTypeId].hasResources[resourceSerialId]) {
+                    state.hasResourcesTypes[resourceTypeId].hasResources[resourceSerialId] = { ...cloneDeep(payload), resourceSerialId };
+                  } else {
+                    merge(state.hasResourcesTypes[resourceTypeId].hasResources[resourceSerialId], payload);
+                  }
+                }
+                if (hasResourcesTypesMessagesManager[resourceTypeId].messagesQueue.isEmpty()) {
+                  hasResourcesTypesMessagesManager[resourceTypeId].statusProccesing = false;
+                  continueNext = false;
+                } else {
+                  hasResourcesTypesMessagesManager[initialResourceTypeId].statusProccesing = true;
+                }
+              });
+              if (continueNext) {
+                setTimeout(() => {
+                  processNext(resourceTypeId);
+                }, PROCCESS_MESSAGES_INTERVAL);
+              }
+            }
+            processNext(initialResourceTypeId);
+          }
+        }
+      })),
+      { name: `${REALTIME_PRODUCER_SOTORE_ID}: ${initProps.storeId}`, enabled: storeDevtoolsEnabled }
+    )
+  );
+}
+export {
+  createRealTimeStore as c
+};

package/contexts/RealTimeProducerContext/types.d.ts

@@ -0,0 +1,196 @@
+import { ReactNode } from 'react';
+import { ObjectQueue } from '../../utils/ObjectQueue';
+import { default as SourceDataBase } from './sourceDataMechanisms/base';
+import { EnumResourceTypesIds } from './constants';
+/**
+ * Identificación del tipo de recurso
+ */
+export type RealTimeResourceTypeId = keyof typeof EnumResourceTypesIds | string;
+/**
+ * Identificación del tipo de recurso
+ */
+export type ResourceTypeSourceDataMechanism = 'dummy' | 'atmosphere';
+/**
+ * Identificación del recurso
+ */
+export type RealTimeResourceSerialId = number | string;
+/**
+ * Payload del mensaje de tiempo real
+ */
+export type RealTimeMessagePayload = Record<string | number, any>;
+/**
+ * Mensaje de tiempo real
+ */
+export interface RealTimeMessage {
+    type: 'new' | 'update' | 'delete';
+    resourceSerialId: RealTimeResourceSerialId;
+    readonly payload: RealTimeMessagePayload;
+}
+export type OnRealTimeConsumerMessageCallback = (resourceTypeId: RealTimeResourceTypeId, messages: Array<RealTimeMessage>) => void;
+export type OnRealTimeConsumerSuscribeCallback = (resourceTypeId: RealTimeResourceTypeId, initialHashResources: Record<RealTimeResourceSerialId, any>) => void;
+export type Suscriber = {
+    clientId: string;
+    /**
+     * A donde se invoca cuando se procesan los mensajes.
+     */
+    onMessageCallbacks: OnRealTimeConsumerMessageCallback[];
+};
+export interface SuscribeOptions extends Pick<Suscriber, 'clientId' | 'onMessageCallbacks'> {
+    /**
+     * Cuando se suscribe el consumidor, el productor invoca a los onSuscribeCallbacks, para indicarles cual es hashResources actual en el store.
+     */
+    onSuscribeCallbacks: OnRealTimeConsumerSuscribeCallback[];
+}
+/**
+ * Estado de la conexión de tiempo real
+ */
+export type RealTimeStatus = 'init' | 'conecting' | 'connected' | 'standby';
+/**
+ * Configuración de los tipos de recursos de tiempo real
+ */
+export interface RealTimeResourceSourceMechanismConfigBase {
+    /**
+     * Indica cual es el método de conexión y origen de los datos que se va a utilizar para el tiempo real.
+     */
+    sourceDataMechanism: ResourceTypeSourceDataMechanism;
+    /**
+     * Indica el tipo de recurso del cual están llegando mensajes.
+     */
+    resourceTypeId: RealTimeResourceTypeId;
+    /**
+     * estado inicial del hashResources del resourceTypeId
+     */
+    initialHashResources?: Record<RealTimeResourceSerialId, any>;
+}
+/**
+ * Configuración de los tipos de recursos de tiempo real
+ */
+export interface RealTimeResourceSourceMechanismConfigAtmosphere extends RealTimeResourceSourceMechanismConfigBase {
+    /**
+     * Indica cual es el método de conexión y origen de los datos que se va a utilizar para el tiempo real.
+     */
+    sourceDataMechanism: 'atmosphere';
+    /**
+     * TODO: Documentar
+     */
+    host: string;
+    /**
+     * TODO: Documentar
+     */
+    port: string;
+    /**
+     * TODO: Documentar
+     */
+    path: string;
+    /**
+     * TODO: Documentar
+     */
+    topic: string;
+    /**
+     * TODO: Documentar
+     */
+    sessionId: string;
+}
+export interface RealTimeResourceSourceMechanismConfigDummy extends RealTimeResourceSourceMechanismConfigBase {
+    sourceDataMechanism: 'dummy';
+}
+export type RealTimeResourceSourceMechanismConfig = RealTimeResourceSourceMechanismConfigAtmosphere | RealTimeResourceSourceMechanismConfigDummy;
+/**
+ * Store del tiempo real, actualizado por sockets
+ */
+export interface MessageQueueManager {
+    /**
+     * Mensajes a procesr del tiempo real
+     */
+    messagesToProcces: RealTimeMessage[];
+    /**
+     * Cola de mensajes, se de esta manera, para que no reaccione zustand cuando se procesen los mensajes, debido a que están dentro de la clase y no directos.
+     * Adicionalmente es una cola O(1) para encolar y desencolar.
+     */
+    messagesQueue: ObjectQueue<RealTimeMessage>;
+    /**
+     * Indica si se está procesando los mensajes del tipo de recurso
+     */
+    statusProccesing: boolean;
+}
+/**
+ * Store del tiempo real, actualizado por sockets
+ */
+export interface RealTimeResourceType {
+    /**
+     * Configuración de los tipos de recursos de tiempo real
+     */
+    config: RealTimeResourceSourceMechanismConfig;
+    /**
+     * Estado de la conexión de tiempo real
+     */
+    status: RealTimeStatus;
+    /**
+     * Clase encargada de obtener los datos del tiempo real
+     */
+    sourceDataClass: SourceDataBase;
+    /**
+     * Datos del tiempo real
+     */
+    hasResources: Record<RealTimeResourceSerialId, any>;
+    /**
+     * Clientes suscritos al tiempo real al recurso indicado.
+     */
+    suscribedClients: Record<RealTimeResourceSerialId, Suscriber>;
+}
+/**
+ * Callback al cual se debe llamar para procesar los mensajes.
+ */
+export type OnMessagesStoreCallback = (resourceTypeId: RealTimeResourceTypeId, message: RealTimeMessage[]) => void;
+/**
+ * Store del tiempo real, actualizado por sockets
+ */
+export interface RealTimeProducerStoreState {
+    /**
+     * Id del store
+     */
+    storeId: string;
+    /**
+     * Indica los tipos de recurso y sus configuraciones de tiempo a los cuales se va a conectar
+     */
+    resourceTypesConfig: RealTimeResourceSourceMechanismConfig[];
+    /**
+     * Tiempo de real de los recursos.
+     */
+    hasResourcesTypes: Record<RealTimeResourceTypeId, RealTimeResourceType>;
+}
+export interface RealTimeProducerStoreStateWithActions extends RealTimeProducerStoreState {
+    realTimeProducerActions: {
+        /**
+         * @description
+         */
+        init(): void;
+        /**
+         * Actualiza el estado del store
+         */
+        setStatus: (newState: RealTimeStatus) => void;
+        /**
+         * suscribe un cliente al tiempo real, usado por los MFS para recibir los mensajes que llegan al host.
+         * Retorna el hasResources como actualmente se encuentra en el productor.
+         */
+        suscribe: (resourceTypeId: RealTimeResourceTypeId, options: SuscribeOptions) => void;
+        /**
+         * desuscribe un cliente al tiempo real, para dejar de recibir los mensajes que llegan al host.
+         */
+        unsuscribe: (resourceTypeId: RealTimeResourceTypeId, clientId: string) => void;
+        /**
+         * Funcion que procesa los mensajes que llegan desde el servidor, indpendiente de donde llegue, sea por socket, simulados, etc.
+         * Los reparte a los clientes suscritos y al propio hasResources del store.
+         */
+        onMessages: OnMessagesStoreCallback;
+        /**
+         * Funcion que procesa los mensajes utilizando la cola
+         */
+        processMessages: (resourceTypeId: RealTimeResourceTypeId) => void;
+    };
+}
+export type InitialRealTimeProducerStoreProps = Omit<RealTimeProducerStoreState, 'status' | 'suscribedClients' | 'messagesToProcces' | 'messagesQueue' | 'statusProccesing' | 'hasResourcesTypes'>;
+export interface RealTimeProducerProviderProps extends InitialRealTimeProducerStoreProps {
+    storeDevtoolsEnabled?: boolean;
+    children: ReactNode;
+}

package/contexts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './RealTimeProducerContext';
+export * from './RealTimeConsumerContext';

package/contexts/index.js

@@ -0,0 +1 @@
+

package/formatters/CourseFormatter/CourseFormatter.d.ts

@@ -0,0 +1,14 @@
+import { CourseFormatterProps } from './types';
+/**
+ * "CourseFormatter" que se encarga de visualizar el Curse Over Ground (Sentido manecilla del reloj, 0grados = Norte )
+ *  a (Sentido contrario manecillas del reloj 0grados = East).
+ * Curso: 0  => 90 - Norte
+ * Curso: 90 => 0  - Este
+ * Curso: 180 => 270 - Sur
+ * Curso: 270 => 180 - Oeste
+ *
+ */
+/**
+ * CourseFormatter Component
+ */
+export declare const CourseFormatter: (props: CourseFormatterProps) => import("react/jsx-runtime").JSX.Element;

package/formatters/CourseFormatter/CourseFormatter.js

@@ -0,0 +1,33 @@
+import { jsx } from "react/jsx-runtime";
+import { C as CFRootStyled } from "./slots/CourseFormatterSlots.js";
+import { g as getCardinalDirection } from "./helper.js";
+import { g as getPropDataTestId } from "../../test/getNameDataTestId.js";
+import { C as CourseFormatterSlots } from "./slots/CourseFormatterEnum.js";
+import { D as DEFAULT_GAP_ANGLE, C as COMPONET_KEY_COMPONENT } from "./constants.js";
+import { c as courseToCartesianAngle } from "../../components/maps/utils/courseToCartesianAngle.js";
+const CourseFormatter = (props) => {
+  const {
+    course,
+    gapAngle: gap = DEFAULT_GAP_ANGLE,
+    size = "medium",
+    dataTestId
+  } = props;
+  const ownerState = {
+    size,
+    variant: "standard"
+  };
+  const angle = courseToCartesianAngle(course);
+  const ret = getCardinalDirection(angle, gap);
+  return /* @__PURE__ */ jsx(
+    CFRootStyled,
+    {
+      ownerState: { ...ownerState },
+      ...getPropDataTestId(COMPONET_KEY_COMPONENT, CourseFormatterSlots.root, dataTestId),
+      skeletonWidth: "10%",
+      children: ret
+    }
+  );
+};
+export {
+  CourseFormatter as C
+};

package/formatters/CourseFormatter/CourseFormatter.styles.d.ts

@@ -0,0 +1,2 @@
+import { CourseFormatterStyles } from './types';
+export declare const courseFormatterStyles: CourseFormatterStyles;

package/formatters/CourseFormatter/CourseFormatter.styles.js

@@ -0,0 +1,23 @@
+import { getTypographyStyles } from "@m4l/components";
+const courseFormatterStyles = {
+  /** Styles applied to the root element. */
+  root: ({ theme, ownerState }) => ({
+    "&.MuiTypography-root": {
+      "&.M4lclassCssSpecificity": {
+        ...getTypographyStyles(
+          theme.generalSettings.isMobile,
+          ownerState.size || "medium",
+          "body"
+        ),
+        ...getTypographyStyles(
+          theme.generalSettings.isMobile,
+          ownerState.size || "small",
+          "body"
+        )
+      }
+    }
+  })
+};
+export {
+  courseFormatterStyles as c
+};

package/formatters/CourseFormatter/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const COMPONENT_TEST_ID = "M4LCourseFormatter";
+export declare const COMPONET_KEY_COMPONENT = "M4LCourseFormatter";
+export declare const DEFAULT_GAP_ANGLE = 5;

package/formatters/CourseFormatter/constants.js

@@ -0,0 +1,6 @@
+const COMPONET_KEY_COMPONENT = "M4LCourseFormatter";
+const DEFAULT_GAP_ANGLE = 5;
+export {
+  COMPONET_KEY_COMPONENT as C,
+  DEFAULT_GAP_ANGLE as D
+};

package/formatters/CourseFormatter/dictionary.d.ts

@@ -0,0 +1,12 @@
+export declare const CF_DICTIONARY_ID = "course_formatter";
+export declare function getCourseFormatterComponentsDictionary(): string[];
+export declare const CF_DICCTIONARY: {
+    readonly LABEL_NORTH: "course_formatter.label_north";
+    readonly LABEL_SOUTH: "course_formatter.label_south";
+    readonly LABEL_EAST: "course_formatter.label_east";
+    readonly LABEL_WEST: "course_formatter.label_west";
+    readonly LABEL_NORTH_EAST: "course_formatter.label_north_east";
+    readonly LABEL_NORTH_WEST: "course_formatter.label_north_west";
+    readonly LABEL_SOUTH_EAST: "course_formatter.label_south_east";
+    readonly LABEL_SOUTH_WEST: "course_formatter.label_south_west";
+};