@opengeoweb/taf 19.1.0 → 19.1.1

package/dist/src/lib/components/TafLayout/TacOverview/TacOverview.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { TafFromBackend } from '../../../types';
+interface TacOverviewProps {
+    upcomingTafs: TafFromBackend[];
+    currentTafs: TafFromBackend[];
+    expiredTafs: TafFromBackend[];
+    hideTitle?: boolean;
+    activeTaf?: TafFromBackend;
+    isFormDisabled?: boolean;
+}
+declare const TacOverview: React.FC<TacOverviewProps>;
+export default TacOverview;

package/dist/src/lib/components/TafLayout/TacOverview/TacOverviewMobile.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { TafFromBackend } from '../../../types';
+interface TacOverviewMobileProps {
+    upcomingTafs: TafFromBackend[];
+    currentTafs: TafFromBackend[];
+    expiredTafs: TafFromBackend[];
+    autoTafs?: TafFromBackend[];
+    activeTaf?: TafFromBackend;
+    defaultOpen?: boolean;
+}
+declare const TacOverviewMobile: React.FC<TacOverviewMobileProps>;
+export default TacOverviewMobile;

package/dist/src/lib/components/TafLayout/TacOverview/index.d.ts

@@ -0,0 +1,2 @@
+export { default as TacOverview } from './TacOverview';
+export { default as TacOverviewMobile } from './TacOverviewMobile';

package/dist/src/lib/components/TafLayout/TafLayout.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { TafFromBackend } from '../../types';
+interface TafLayoutProps {
+    tafList: TafFromBackend[];
+    onUpdateTaf: () => Promise<void>;
+    lastUpdateTime?: string;
+    isAutoTafEnabled?: boolean;
+}
+declare const TafLayout: React.FC<TafLayoutProps>;
+export default TafLayout;

package/dist/src/lib/components/TafLayout/TafPanel/TafPanel.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import type { TafFromBackend, Taf, TafActions, TafStatus, TafFromFrontEnd } from '../../../types';
+import type { IssuesPanePosition } from '../../IssuesPane/types';
+import type { TafError } from '../utils';
+export declare const fromActionToStatus: (tafAction: TafActions) => TafStatus;
+interface TafPanelProps {
+    tafFromBackend: TafFromBackend;
+    activeTafIndex: number;
+    index: number;
+    isLoading?: boolean;
+    postTaf?: (taf: TafFromFrontEnd) => Promise<void>;
+    patchTaf?: (taf: TafFromFrontEnd) => Promise<boolean>;
+    isIssuesPaneOpen?: boolean;
+    setIsIssuesPaneOpen?: (isOpen: boolean, position: IssuesPanePosition) => void;
+    isFormDisabled?: boolean;
+    setIsFormDisabled?: (isDisabled: boolean) => void;
+    error?: TafError | null;
+    previousTaf: Taf;
+    tafAction: TafActions;
+    shouldEnableRemark?: boolean;
+}
+declare const TafPanel: React.FC<TafPanelProps>;
+export default TafPanel;

package/dist/src/lib/components/TafLayout/TafPanel/index.d.ts

@@ -0,0 +1 @@
+export { default as TafPanel } from './TafPanel';

package/dist/src/lib/components/TafLayout/TopTabs/TopTabs.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { TafFromBackend, TimeSlot } from '../../../types';
+interface TopTabsProps {
+    timeSlot: TimeSlot;
+    tafFromBackend?: TafFromBackend;
+    onChangeTimeSlot?: (timeSlot: TimeSlot, isFormDirty: boolean) => void;
+}
+declare const TopTabs: React.FC<TopTabsProps>;
+export default TopTabs;

package/dist/src/lib/components/TafLayout/TopTabs/index.d.ts

@@ -0,0 +1 @@
+export { default as TopTabs } from './TopTabs';

package/dist/src/lib/components/TafLayout/utils.d.ts

@@ -0,0 +1,47 @@
+import type { AxiosError } from 'axios';
+import type { TFunction } from 'i18next';
+import type { AutoTAFlocations, Taf, TafConfig, TafConfigLocation, TafConfigLocations, TafConfigLocationFixedPeriod, TafConfigLocationDynamicPeriod, TafFromBackend, TafFromFrontEnd, TafStatus, TimeSlot, ForecastType } from '../../types';
+export declare const isTafConfigLocationFixedPeriod: (location: TafConfigLocation) => location is TafConfigLocationFixedPeriod;
+export declare const isTafConfigLocationDynamicPeriod: (location: TafConfigLocation) => location is TafConfigLocationDynamicPeriod;
+export declare const getLocationSetting: (location: string, locationSettings: TafConfigLocations) => TafConfigLocation;
+export declare const sortTafsOnLocation: (tafList?: TafFromBackend[], locationOrder?: string[]) => TafFromBackend[];
+export declare const sortTafsOnIssueDate: (tafList?: TafFromBackend[]) => TafFromBackend[];
+export declare const getBaseTime: (baseTime: string, location: string, tafConfig: TafConfig) => {
+    currentBaseTime: Date;
+    nextBaseTime: Date;
+};
+/**
+ * If we don't have a taf to get the baseTime from, we calculate it based on the current time and the activity_period from the config.
+ * @param tafConfig
+ * @returns
+ */
+export declare const calculateBaseTime: (tafConfig: TafConfig) => {
+    currentBaseTime: Date;
+    nextBaseTime: Date;
+};
+export declare const getTafTimeSlot: (baseTime: string, location: string, status: TafStatus, tafConfig: TafConfig) => TimeSlot;
+interface TafTimeSlots {
+    current: TafFromBackend[];
+    upcoming: TafFromBackend[];
+    expired: TafFromBackend[];
+}
+export declare const sortTafTimeSlots: (tafList: TafFromBackend[], tafConfig: TafConfig) => TafTimeSlots;
+export declare const muiTabA11yProps: (index: number) => {
+    id: string;
+    "aria-controls": string;
+};
+export declare const getNewTafLocationIndex: (tafLocations: TafFromBackend[], previousTafLocationUUID: string) => number;
+export declare const getPreviousTaf: (tafList: TafFromBackend[], currentTaf: TafFromBackend) => Taf;
+export declare const getAutoTafLocations: (autoTAFlocations: AutoTAFlocations | undefined) => AutoTAFlocations | null;
+export declare const scrollToPosition: (scrollRef: React.RefObject<HTMLElement | null>, activeLocation: string) => void;
+export declare const formatBaseTime: (time: Date) => string;
+export declare const getSnackbarMessage: (tafFromFrontEnd: TafFromFrontEnd, isAutoSaved: boolean, t: TFunction, forecastType?: ForecastType) => string;
+export interface TafError {
+    type: 'CANCELLED' | 'SERVER' | 'WARNING';
+    title: string;
+    message?: string;
+    testId?: string;
+}
+export declare const isWarning: (error: TafError) => boolean;
+export declare const parseErrorMessage: (error: AxiosError | Error, params: TafFromFrontEnd, t: TFunction, forecastType?: ForecastType) => TafError;
+export {};

package/dist/src/lib/components/TafModule/TafModule.d.ts

@@ -0,0 +1,9 @@
+import type { FC } from 'react';
+import type { TafModuleProviderProps } from './TafModuleProvider';
+import type { ForecastType } from '../../types';
+export declare const getCurrentDate: () => string;
+declare const Wrapper: FC<TafModuleProviderProps & {
+    isAutoTafEnabled?: boolean;
+    forecastType?: ForecastType;
+}>;
+export default Wrapper;

package/dist/src/lib/components/TafModule/TafModuleProvider.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import type { FieldValues, UseFieldArrayReturn } from 'react-hook-form';
+import type { BaseTaf, TafActions } from '../../types';
+type ValidateFormPromise = () => Promise<void | BaseTaf>;
+interface TafModuleMethods {
+    onPreventCloseView?: (shouldPreventClose: boolean) => void;
+}
+interface TafModuleContextState {
+    onValidateForm: ValidateFormPromise;
+    registerValidateForm: (promiseToRegister: ValidateFormPromise) => void;
+    tafAction: TafActions;
+    setTafAction: (action: TafActions) => void;
+    onPreventCloseView: (shouldPreventClose: boolean) => void;
+    useFieldArrayMethods: UseFieldArrayReturn<FieldValues, string>;
+}
+declare const TafModuleContext: React.Context<TafModuleContextState>;
+export declare const useTafModuleContext: () => Partial<TafModuleContextState>;
+export declare const useTafModuleState: ({ onPreventCloseView, }: TafModuleMethods) => TafModuleContextState;
+export interface TafModuleProviderProps extends TafModuleMethods {
+    children?: React.ReactNode;
+}
+export declare const TafModuleProvider: React.FC<TafModuleProviderProps>;
+export default TafModuleContext;

package/dist/src/lib/components/TafModule/index.d.ts

@@ -0,0 +1 @@
+export { default as TafModule } from './TafModule';

package/dist/src/lib/components/TafRemarkField/TafRemarkField.d.ts

@@ -0,0 +1,7 @@
+import type { FC } from 'react';
+export interface TafRemarkFieldProps {
+    disabled?: boolean;
+    isEditor?: boolean;
+}
+declare const TafRemarkField: FC<TafRemarkFieldProps>;
+export default TafRemarkField;

package/dist/src/lib/components/TafRemarkField/index.d.ts

@@ -0,0 +1 @@
+export { default as TafRemarkField } from './TafRemarkField';

package/dist/src/lib/components/TafWrapper/TafConfigWrapper.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { TafConfig, ForecastType } from '../../types';
+interface TafConfigWrapperContext {
+    tafConfig?: TafConfig;
+}
+export declare const TafConfigContext: React.Context<TafConfigWrapperContext>;
+export declare const useTafConfigContext: () => Partial<TafConfigWrapperContext>;
+interface TafConfigWrapperProps {
+    children?: React.ReactNode;
+    forecastType?: ForecastType;
+}
+declare const TafConfigWrapper: React.FC<TafConfigWrapperProps>;
+export default TafConfigWrapper;

package/dist/src/lib/components/TafWrapper/TafWrapper.d.ts

@@ -0,0 +1,3 @@
+import type { TafModuleProviderProps } from '../TafModule/TafModuleProvider';
+declare const TafWrapper: React.FC<TafModuleProviderProps>;
+export default TafWrapper;

package/dist/src/lib/components/TafWrapper/index.d.ts

@@ -0,0 +1 @@
+export { default as TafWrapper } from './TafWrapper';

package/dist/src/lib/types.d.ts

@@ -0,0 +1,173 @@
+import type { WeatherPhenomena } from './utils/weatherPhenomena';
+export interface Visibility {
+    range: number;
+    unit: string;
+}
+export interface Wind {
+    direction: number | string;
+    speed: number | string;
+    gust?: number | string;
+    unit: 'KT';
+}
+export type NSW = 'NSW';
+export interface Weather {
+    weather1: WeatherPhenomena | NSW;
+    weather2?: WeatherPhenomena | NSW;
+    weather3?: WeatherPhenomena | NSW;
+}
+export type CloudCoverage = 'FEW' | 'SCT' | 'BKN' | 'OVC';
+export type CloudType = 'CB' | 'TCU';
+export interface Cloud {
+    coverage: CloudCoverage;
+    height: number | null;
+    type?: CloudType;
+}
+export type NSC = 'NSC';
+export interface VerticalVisibility {
+    verticalVisibility: number;
+}
+export interface Clouds {
+    cloud1: Cloud | VerticalVisibility | NSC;
+    cloud2?: Cloud;
+    cloud3?: Cloud;
+    cloud4?: Cloud;
+}
+export type TafDate = string;
+export interface Valid {
+    start: TafDate;
+    end?: TafDate;
+}
+export interface BaseForecast {
+    valid: Valid;
+    visibility?: Visibility;
+    wind?: Wind;
+    weather?: Weather;
+    cloud?: Clouds;
+    cavOK?: boolean;
+}
+export type Change = 'TEMPO' | 'BECMG' | 'FM';
+export interface ChangeGroup extends BaseForecast {
+    change: Change;
+    probability?: 'PROB30' | 'PROB40';
+}
+export type MessageType = 'ORG' | 'AMD' | 'COR' | 'CNL';
+export type NafLocation = 'EHAK' | 'EHFD' | 'EHDV' | 'EHHW' | 'EHKV' | 'EHMG' | 'EHMA' | 'EHQN' | 'EHPG';
+export type Location = 'EHAM' | 'EHRD' | 'EHGG' | 'EHBK' | 'EHLE' | 'TNCB' | NafLocation;
+export type ForecastType = 'TAF' | 'NAF';
+export interface BaseTaf {
+    validDateStart: TafDate;
+    validDateEnd: TafDate;
+    baseTime: TafDate;
+    previousId?: string;
+    previousValidDateStart?: TafDate;
+    previousValidDateEnd?: TafDate;
+    location: Location;
+    baseForecast: BaseForecast;
+    changeGroups?: ChangeGroup[];
+    messageType: MessageType;
+    remark?: string;
+    uuid: string;
+    issueDate?: TafDate;
+}
+export type TafStatus = 'NEW' | 'DRAFT' | 'DRAFT_AMENDED' | 'DRAFT_CORRECTED' | 'PUBLISHED' | 'CORRECTED' | 'AMENDED' | 'CANCELLED' | 'EXPIRED' | 'AUTO';
+export type TafActions = 'NEW' | 'DRAFT' | 'DRAFT_AMEND' | 'DRAFT_CORRECT' | 'PUBLISH' | 'CANCEL' | 'CORRECT' | 'AMEND' | 'CLOSE' | 'CLEAR';
+export type TafCanbe = 'DRAFTED' | 'DISCARDED' | 'PUBLISHED' | 'CANCELLED' | 'AMENDED' | 'CORRECTED';
+export interface Taf extends BaseTaf {
+    status: TafStatus;
+}
+export interface BaseForecastFormData {
+    valid: string;
+    visibility?: string;
+    wind?: string;
+    weather?: WeatherStrings;
+    cloud?: CloudStrings;
+    cavOK?: boolean;
+}
+export interface ChangeGroupFormData extends BaseForecastFormData {
+    probability?: string;
+    change: string;
+}
+export interface TafFormData {
+    IS_DRAFT?: boolean;
+    validDateStart: string;
+    validDateEnd: string;
+    baseTime: string;
+    previousId?: string;
+    previousValidDateStart?: string;
+    previousValidDateEnd?: string;
+    location: Location;
+    baseForecast: BaseForecastFormData;
+    changeGroups?: ChangeGroupFormData[];
+    messageType: MessageType;
+    uuid: string;
+    issueDate?: string;
+    status: TafStatus;
+    remark?: string;
+}
+/**
+ * Type with TAF info from the backend
+ */
+export interface TafFromBackend {
+    taf: Taf;
+    creationDate: TafDate;
+    canbe: TafCanbe[];
+    editor: string;
+    forecastType: ForecastType;
+}
+/**
+ * Type with TAF info sent to the backend
+ */
+export interface TafFromFrontEnd {
+    taf: Taf;
+    changeStatusTo?: TafStatus;
+    editor?: string;
+}
+/**
+ * TAF (json) settings (libs/taf/src/lib/utils/tafConfig.json)
+ */
+export type TafConfigLocation = TafConfigLocationFixedPeriod | TafConfigLocationDynamicPeriod;
+export interface TafConfigLocationFixedPeriod {
+    validity_duration: number;
+    activity_period: number;
+    label: string;
+}
+export interface TafConfigLocationDynamicPeriod {
+    valid_durations: number[];
+    valid_start_times: number[];
+    label: string;
+}
+export type TafConfigLocations = Record<string, TafConfigLocation>;
+export type AutoTAFlocations = string[];
+export interface TafConfig {
+    location_indicator_mwo: string;
+    locations: TafConfigLocations;
+    locationOrder: string[];
+    autoTAFlocations?: AutoTAFlocations;
+    shouldEnableRemark?: boolean;
+    forecastType: ForecastType;
+}
+export type TimeSlot = 'UPCOMING' | 'ACTIVE' | 'EXPIRED';
+export interface AdverseWeatherTAC {
+    tac: {
+        text: string;
+        type?: string;
+    }[][];
+}
+export type TAC = string | AdverseWeatherTAC;
+export interface CloudStrings {
+    cloud1: string;
+    cloud2?: string;
+    cloud3?: string;
+    cloud4?: string;
+}
+export interface WeatherStrings {
+    weather1: string;
+    weather2?: string;
+    weather3?: string;
+}
+export interface ConfigKey {
+    key: string;
+    size: number;
+    minSize?: number;
+    maxSize?: number;
+}

package/dist/src/lib/utils/dateFormats.d.ts

@@ -0,0 +1,2 @@
+export declare const DATE_FORMAT_ISSUE_TIME = "ddHHmm'Z";
+export declare const DATE_FORMAT_BASE_TIME = "HH:mm dd MMM";

package/dist/src/lib/utils/i18n.d.ts

@@ -0,0 +1,6 @@
+import i18n from 'i18next';
+import type { UseTranslationResponse } from 'react-i18next';
+export declare const TAF_NAMESPACE = "taf";
+export declare const initTafI18n: () => void;
+export declare const translateInTestsAndStories: (key: string, params?: Record<string, string | number> | undefined) => string;
+export declare const useTafTranslation: () => UseTranslationResponse<typeof TAF_NAMESPACE, typeof i18n>;

package/dist/src/lib/utils/mockdata/fakeTafConfig.d.ts

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

package/dist/src/lib/utils/mockdata/fakeTafList.d.ts

@@ -0,0 +1,26 @@
+import type { TafFromBackend } from '../../types';
+export declare const MOCK_USERNAME = "user.name";
+export declare const fakeTafList: TafFromBackend[];
+export declare const fakeNewTaf: TafFromBackend;
+export declare const fakeNewFixedTaf: TafFromBackend;
+export declare const fakeExpiredTaf: TafFromBackend;
+export declare const fakePublishedTaf: TafFromBackend;
+export declare const fakePublishedFixedTaf: TafFromBackend;
+export declare const fakePublishedTafWithoutChangeGroups: TafFromBackend;
+export declare const fakeCancelledTaf: TafFromBackend;
+export declare const fakeDraftTaf: TafFromBackend;
+export declare const fakeDraftFixedTaf: TafFromBackend;
+export declare const fakeDraftAmendmentTaf: TafFromBackend;
+export declare const fakeDraftCorrectedTaf: TafFromBackend;
+export declare const fakeDraftAmendmentFixedTaf: TafFromBackend;
+export declare const previousTafForfakeDraftAmendmentFixedTaf: TafFromBackend;
+export declare const fakeAmendmentTaf: TafFromBackend;
+export declare const fakeCorrectedTaf: TafFromBackend;
+export declare const fakeAmendmentFixedTaf: TafFromBackend;
+export declare const fakeCancelledFixedTaf: TafFromBackend;
+export declare const fakeFixedTafList: TafFromBackend[];
+export declare const fakePublishedTafWithChangeGroups: TafFromBackend;
+export declare const fakeDraftTafWithSameDates: TafFromBackend;
+export declare const fakeDraftTafWithSameDatesFixed: TafFromBackend;
+export declare const fakeDraftTafWithFM: TafFromBackend;
+export declare const fakeCurrentTaf: TafFromBackend;

package/dist/src/lib/utils/mockdata/naf/fakeNafConfig.d.ts

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

package/dist/src/lib/utils/mockdata/naf/fakeNafList.d.ts

@@ -0,0 +1,12 @@
+import type { TafFromBackend } from '../../../types';
+export declare const MOCK_USERNAME = "user.name";
+export declare const fakeNafList: TafFromBackend[];
+export declare const fakeFixedNaf: TafFromBackend;
+export declare const fakeLastInDayNaf: TafFromBackend;
+export declare const fakeNewFixedNaf: TafFromBackend;
+export declare const fakeDraftFixedNaf: TafFromBackend;
+export declare const fakePublishedFixedNaf: TafFromBackend;
+export declare const fakeDraftAmendmentFixedNaf: TafFromBackend;
+export declare const fakeAmendmentFixedNaf: TafFromBackend;
+export declare const fakeCancelledFixedNaf: TafFromBackend;
+export declare const fakeFixedNafList: TafFromBackend[];

package/dist/src/lib/utils/taf-api/api.d.ts

@@ -0,0 +1,7 @@
+import type { Credentials } from '@opengeoweb/authentication';
+import type { TAC, Taf, TafConfig, TafFromBackend, TafFromFrontEnd, ForecastType } from '../../types';
+export declare const getTafList: (auth: Credentials, forecastType?: ForecastType) => Promise<TafFromBackend[]>;
+export declare const postTaf: (auth: Credentials, data: TafFromFrontEnd) => Promise<Response>;
+export declare const patchTaf: (auth: Credentials, data: TafFromFrontEnd, force?: boolean) => Promise<Response>;
+export declare const getTAC: (auth: Credentials, data: Taf, forecastType?: ForecastType) => Promise<TAC>;
+export declare const getTafConfig: (auth: Credentials, forecastType?: ForecastType) => Promise<TafConfig>;

package/dist/src/lib/utils/taf-api/fakeApi.d.ts

@@ -0,0 +1,4 @@
+import type { AdverseWeatherTAC } from '../../types';
+export declare const fakeTafTac = "TAF EHAM 0812/0918 20020G35KT 0500 SN BKN040 BECMG 0814/0816 0700 BKN001=";
+export declare const fakeTafTacJson: AdverseWeatherTAC;
+export declare const tafEndPoints: import("msw").HttpHandler[];

package/dist/src/lib/utils/taf-api/hooks.d.ts

@@ -0,0 +1,25 @@
+import type { UseMutationResult, UseQueryResult } from '@tanstack/react-query';
+import type { TafError } from '../../components/TafLayout/utils';
+import type { TAC, Taf, TafFromBackend, TafFromFrontEnd, TafConfig, ForecastType } from '../../types';
+export declare const useTafList: (type?: ForecastType, disabled?: boolean) => UseQueryResult<TafFromBackend[]>;
+export declare const useTafConfig: (type?: ForecastType, disabled?: boolean) => UseQueryResult<TafConfig>;
+type PostReturnType<T> = UseMutationResult<Response | null, Error, T>;
+interface PostTafProps {
+    tafData: TafFromFrontEnd;
+    isAutoSaved: boolean;
+    setError: React.Dispatch<React.SetStateAction<TafError | null>>;
+}
+export declare const usePostTaf: (forecastType?: ForecastType) => PostReturnType<PostTafProps>;
+type PatchReturnType<T> = UseMutationResult<Response | null, Error, T>;
+interface PatchTafProps {
+    tafData: TafFromFrontEnd;
+    setError: React.Dispatch<React.SetStateAction<TafError | null>>;
+    force?: boolean;
+}
+export declare const usePatchTaf: (forecastType?: ForecastType) => PatchReturnType<PatchTafProps>;
+type GetTACReturnType<T> = UseMutationResult<TAC, Error, T>;
+interface GetTACProps {
+    tafData: Taf;
+}
+export declare const useGetTAC: (forecastType?: ForecastType) => GetTACReturnType<GetTACProps>;
+export {};

package/dist/src/lib/utils/utils.d.ts

@@ -0,0 +1 @@
+export declare const getCurrentUrlLocation: (url: string, appUrl: string) => string;