accomadesc 0.3.42 → 0.4.1

package/dist/occusplan-link/state.svelte.d.ts

@@ -0,0 +1,92 @@
+import { DateTime, type MonthNumbers, type WeekdayNumbers } from 'luxon';
+export interface AvailableSpans {
+    [key: number]: DateTime | null;
+}
+export interface Occupation {
+    arrival: DateTime;
+    leave: DateTime;
+    type: OccupationType;
+}
+export type OccupationCallback = (occupation: Occupation) => void;
+export type WeekdayLabels = {
+    [key in WeekdayNumbers]: string;
+};
+export type MonthLabels = {
+    [key in MonthNumbers]: string;
+};
+export type OccupationType = 'one' | 'two' | 'three';
+export declare const OCCUPATION_STATE = "occupation-state";
+export declare const occupationTypeFormattingByOccupation: (o?: Occupation) => {
+    fontColor: string;
+    bgColor: string;
+};
+export declare const occupationTypeFormatting: (t?: OccupationType) => {
+    fontColor: string;
+    bgColor: string;
+};
+export interface DayHelper {
+    day: number;
+    month: MonthNumbers;
+    year: number;
+}
+export declare const firstMonthValid: (value: string | number) => boolean;
+export declare const realFirstMonth: (firstMonth: FirstMonth, firstMonthYear: number, numberOfMonth: number, page: number) => DateTime;
+export interface OccuplanTranslations {
+    arrivalLabel?: string;
+    leaveLabel?: string;
+    header?: string;
+    footer?: string;
+    weekendLabel?: string;
+    weekdayLabels?: WeekdayLabels;
+    monthLabels?: MonthLabels;
+    monthHeaderFormat?: string;
+    datePickerDateFormat?: string;
+    numberOfNights?: string;
+    nextPage?: string;
+    prevPage?: string;
+    typeLabels?: Record<OccupationType, string>;
+}
+export type NextMonthNumbers = '+1' | '+2' | '+3' | '+4' | '+5' | '+6' | '+7' | '+8' | '+9' | '+10' | '+11' | '+12';
+export type PrevMonthNumbers = '-1' | '-2' | '-3' | '-4' | '-5' | '-6' | '-7' | '-8' | '-9' | '-10' | '-11' | '-12';
+export type FirstMonth = MonthNumbers | NextMonthNumbers | PrevMonthNumbers | 0;
+export interface OccuplanMiscProps {
+    url: string;
+    debug?: boolean;
+    gridNumberOfMonths?: number;
+    gridFirstMonth?: FirstMonth;
+    gridMaxWidth?: string;
+    rowsNumberOfMonths?: number;
+    rowsFirstMonth?: FirstMonth;
+    rowsMaxWidth?: string;
+    minDate?: DateTime;
+    maxDate?: DateTime;
+    toggleGridOffset?: number;
+    toggleRowsOffset?: number;
+}
+export declare const defaultWeekendLabel = "Weekend";
+export declare const defaultWeekdayLabels: WeekdayLabels;
+export declare const defaultMonthLabels: MonthLabels;
+export declare const defaultMonthHeaderFormat = "{{month}} / {{year}}";
+export declare class OccupationState {
+    iCalURL: string;
+    occupiedDays: Record<string, boolean>;
+    occupations: Occupation[];
+    loading: boolean;
+    debug: boolean;
+    constructor(iCalURL: string, debug?: boolean);
+    loadOccupations: () => Promise<boolean>;
+    private eventsIncomingCallback;
+    private dayKey;
+    private updateOccupiedDays;
+    firstFree: (maxFutureDate: DateTime) => DateTime;
+    earliestRequestStart: (currentEnd: DateTime | undefined) => DateTime | undefined;
+    latestRequestEnd: (maxFutureDate: DateTime, currentStart: DateTime | undefined) => DateTime | undefined;
+    calcAvailability: (search: number[], maxFutureDate: DateTime) => AvailableSpans;
+    dayOccupied: (day: DateTime) => boolean;
+    startingOccupation: (d: DateTime) => Occupation | undefined;
+    endingOccupation: (d: DateTime) => Occupation | undefined;
+    fullOccupation: (d: DateTime) => Occupation | undefined;
+    validRequest: (from: DateTime, to: DateTime) => boolean;
+    occupationStyle: (d: DayHelper, highlightWeekend: boolean | undefined, maxDate: DateTime) => string;
+}
+export declare const getOccupationState: (url: string, debug?: boolean) => OccupationState;

package/dist/occusplan-link/state.svelte.js

@@ -0,0 +1,424 @@
+import { normalizeDate } from '../helpers/normalizeDate.js';
+import { getEvents } from '../helpers/readICS.js';
+import { DateTime } from 'luxon';
+import { DateTime as luxon } from 'luxon';
+import { getContext, setContext } from 'svelte';
+export const OCCUPATION_STATE = 'occupation-state';
+export const occupationTypeFormattingByOccupation = (o) => {
+    return occupationTypeFormatting(o?.type);
+};
+export const occupationTypeFormatting = (t) => {
+    switch (t) {
+        case 'one':
+            return {
+                fontColor: 'var(--occupation-type-1-font-color)',
+                bgColor: 'var(--occupation-type-1-bg-color)',
+            };
+        case 'two':
+            return {
+                fontColor: 'var(--occupation-type-2-font-color)',
+                bgColor: 'var(--occupation-type-2-bg-color)',
+            };
+        case 'three':
+            return {
+                fontColor: 'var(--occupation-type-3-font-color)',
+                bgColor: 'var(--occupation-type-3-bg-color)',
+            };
+        default:
+            return {
+                fontColor: 'var(--occupation-type-1-font-color)',
+                bgColor: 'var(--occupation-type-1-bg-color)',
+            };
+    }
+};
+export const firstMonthValid = (value) => {
+    if (typeof value === 'number') {
+        const intValue = value;
+        return intValue >= 0 && intValue <= 12;
+    }
+    else if (value.length > 1) {
+        //check + sign
+        if (value[0] == '+') {
+            const toParse = value.slice(1);
+            try {
+                const intValue = parseInt(toParse);
+                if (intValue >= 0 && intValue <= 12) {
+                    return true;
+                }
+            }
+            catch (e) {
+                console.log('casting error', e);
+            }
+            //check - sign
+        }
+        else if (value[0] == '-') {
+            const toParse = value.slice(1);
+            try {
+                const intValue = parseInt(toParse);
+                if (intValue >= 0 && intValue <= 12) {
+                    return true;
+                }
+            }
+            catch (e) {
+                console.log('casting error', e);
+            }
+        }
+    }
+    try {
+        const intValue = parseInt(value);
+        if (intValue >= 0 && intValue <= 12) {
+            return true;
+        }
+    }
+    catch (e) {
+        console.log('casting error', e);
+    }
+    return false;
+};
+export const realFirstMonth = (firstMonth, firstMonthYear, numberOfMonth, page) => {
+    const monthToAdd = page * numberOfMonth;
+    if (typeof firstMonth === 'number') {
+        const intValue = firstMonth;
+        if (intValue >= 1 && intValue <= 12) {
+            const tDate = normalizeDate(DateTime.utc())
+                .set({ month: intValue, year: firstMonthYear })
+                .plus({ month: monthToAdd });
+            return tDate;
+        }
+        else {
+            return normalizeDate(DateTime.utc()).plus(monthToAdd);
+        }
+    }
+    else if (typeof firstMonth === 'string' && firstMonth.length > 1) {
+        //check + sign
+        if (firstMonth[0] == '+') {
+            const toParse = firstMonth.slice(1);
+            try {
+                const intValue = parseInt(toParse);
+                if (intValue >= 1 && intValue <= 12) {
+                    const tDate = normalizeDate(DateTime.utc())
+                        .set({ year: firstMonthYear })
+                        .plus({ month: intValue })
+                        .plus({ month: monthToAdd });
+                    return tDate;
+                }
+                else {
+                    return normalizeDate(DateTime.utc()).plus(monthToAdd);
+                }
+            }
+            catch (e) {
+                console.log('casting error', e);
+            }
+            //check - sign
+        }
+        else if (firstMonth[0] == '-') {
+            const toParse = firstMonth.slice(1);
+            try {
+                const intValue = parseInt(toParse);
+                if (intValue >= 0 && intValue <= 12) {
+                    const tDate = normalizeDate(DateTime.utc())
+                        .set({ year: firstMonthYear })
+                        .minus({ month: intValue })
+                        .plus({ month: monthToAdd });
+                    return tDate;
+                }
+                else {
+                    return normalizeDate(DateTime.utc()).plus(monthToAdd);
+                }
+            }
+            catch (e) {
+                console.log('casting error', e);
+            }
+        }
+    }
+    if (typeof firstMonth == 'string') {
+        try {
+            const intValue = parseInt(firstMonth);
+            //current dynamic month
+            if (intValue == 0) {
+                return normalizeDate(DateTime.utc())
+                    .set({ year: firstMonthYear })
+                    .plus({ month: monthToAdd });
+            }
+            //static month of current year
+            if (intValue >= 1 && intValue <= 12) {
+                const tDate = normalizeDate(DateTime.utc())
+                    .set({ month: intValue })
+                    .plus({ month: monthToAdd });
+                return tDate;
+            }
+            else {
+                return normalizeDate(DateTime.utc()).set({ year: firstMonthYear }).plus(monthToAdd);
+            }
+        }
+        catch (e) {
+            console.log('casting error', e);
+        }
+    }
+    //first month of current year ... default
+    return normalizeDate(DateTime.utc())
+        .set({ month: 1, year: firstMonthYear })
+        .plus({ month: monthToAdd });
+};
+const validDay = (d) => {
+    const today = luxon.utc();
+    const m = luxon.local(d.year, d.month, d.day);
+    if (m < today) {
+        return false;
+    }
+    return d.day <= m.endOf('month').day;
+};
+export const defaultWeekendLabel = 'Weekend';
+export const defaultWeekdayLabels = {
+    1: 'Mo',
+    2: 'Tu',
+    3: 'We',
+    4: 'Th',
+    5: 'Fr',
+    6: 'Sa',
+    7: 'Su',
+};
+export const defaultMonthLabels = {
+    1: 'Jan',
+    2: 'Feb',
+    3: 'Mar',
+    4: 'Apr',
+    5: 'May',
+    6: 'Jun',
+    7: 'Jul',
+    8: 'Aug',
+    9: 'Sep',
+    10: 'Oct',
+    11: 'Nov',
+    12: 'Dec',
+};
+export const defaultMonthHeaderFormat = '{{month}} / {{year}}';
+export class OccupationState {
+    iCalURL;
+    occupiedDays = $state({});
+    occupations = $state([]);
+    loading = $state(false);
+    debug = $state(false);
+    constructor(iCalURL, debug = false) {
+        this.debug = debug;
+        if (this.debug)
+            console.log('Constructing OState with CalUrl: ', iCalURL);
+        this.iCalURL = iCalURL;
+        //this.loadOccupations();
+    }
+    loadOccupations = async () => {
+        if (this.debug)
+            console.log('(Re)Loading Occupations');
+        this.loading = true;
+        if (this.iCalURL) {
+            const eventsResult = await getEvents(this.iCalURL, this.eventsIncomingCallback);
+            this.loading = false;
+            return !eventsResult.error;
+        }
+        return false;
+    };
+    eventsIncomingCallback = (o) => {
+        if (this.debug)
+            console.log('Occupation incoming: ', o);
+        this.occupations.push(o);
+        this.updateOccupiedDays(o);
+    };
+    dayKey = (d) => {
+        return `${d.year}-${d.month}-${d.day}`;
+    };
+    updateOccupiedDays = (o) => {
+        let startDate = o.arrival;
+        let endDate = o.leave;
+        if (o.arrival > o.leave) {
+            startDate = o.leave;
+            endDate = o.arrival;
+        }
+        let cDate = startDate;
+        while (cDate < endDate) {
+            const key = this.dayKey(cDate);
+            this.occupiedDays[key] = true;
+            cDate = cDate.plus({ days: 1 });
+        }
+        //console.log(this.occupiedDays);
+    };
+    firstFree = (maxFutureDate) => {
+        let day = normalizeDate();
+        while (this.dayOccupied(day) && day < maxFutureDate) {
+            day = day.plus({ day: 1 });
+        }
+        return day;
+    };
+    earliestRequestStart = (currentEnd) => {
+        if (!currentEnd)
+            return;
+        let day = normalizeDate(currentEnd).minus({ day: 1 });
+        while (day > normalizeDate() && !this.dayOccupied(day)) {
+            day = day.minus({ day: 1 });
+        }
+        return day;
+    };
+    latestRequestEnd = (maxFutureDate, currentStart) => {
+        if (!currentStart)
+            return;
+        let day = normalizeDate(currentStart);
+        while (day < maxFutureDate && !this.dayOccupied(day)) {
+            day = day.plus({ day: 1 });
+        }
+        return day;
+    };
+    calcAvailability = (search, maxFutureDate) => {
+        let av = search.reduce((acc, num) => {
+            acc[num] = null;
+            return acc;
+        }, {});
+        let foundFirst = false;
+        let firstDate;
+        let consecutive = 0;
+        let d = normalizeDate(luxon.utc());
+        while (d <= maxFutureDate) {
+            const key = `${d.year}-${d.month}-${d.day}`;
+            if (this.occupiedDays[key]) {
+                foundFirst = false;
+                consecutive = 0;
+            }
+            else {
+                if (foundFirst) {
+                    consecutive++;
+                    search.forEach((n) => {
+                        if (consecutive >= n && av[n] == null) {
+                            av[n] = firstDate;
+                        }
+                    });
+                    let foundAll = true;
+                    search.forEach((num) => {
+                        if (!av[num]) {
+                            foundAll = false;
+                        }
+                    });
+                    if (foundAll)
+                        break;
+                }
+                else {
+                    foundFirst = true;
+                    firstDate = d;
+                }
+            }
+            d = d.plus({ day: 1 });
+        }
+        return av;
+    };
+    dayOccupied = (day) => {
+        const key = this.dayKey(day);
+        return this.occupiedDays[key] ?? false;
+    };
+    startingOccupation = (d) => {
+        const startOfDay = d.startOf('day');
+        const endOfDay = d.endOf('day');
+        return this.occupations.find((o) => o.arrival > startOfDay && o.arrival < endOfDay);
+    };
+    endingOccupation = (d) => {
+        const startOfDay = d.startOf('day');
+        const endOfDay = d.endOf('day');
+        return this.occupations.find((o) => o.leave > startOfDay && o.leave < endOfDay);
+    };
+    fullOccupation = (d) => {
+        const startOfDay = d.startOf('day');
+        const endOfDay = d.endOf('day');
+        return this.occupations.find((o) => o.arrival < startOfDay && o.leave > endOfDay);
+    };
+    validRequest = (from, to) => {
+        //TODO take min nights into account
+        const found = this.occupations.find((o) => o.arrival < to && o.leave > from);
+        return !found;
+    };
+    occupationStyle = (d, highlightWeekend = false, maxDate) => {
+        const valid = validDay(d);
+        if (!valid) {
+            return 'background-color: var(--occuplan-invalid-days-bg-color); color: var(--occuplan-invalid-days-font-color);';
+        }
+        const day = luxon.utc(d.year, d.month, d.day);
+        const outOfScope = day >= maxDate;
+        if (outOfScope) {
+            return 'background-color: var(--occuplan-invalid-days-bg-color); color: var(--occuplan-invalid-days-font-color);';
+        }
+        const o = this.fullOccupation(day);
+        const oStarts = this.startingOccupation(day);
+        const oEnds = this.endingOccupation(day);
+        const isWeekend = [6, 7].includes(day.weekday);
+        if (o) {
+            const f = occupationTypeFormattingByOccupation(o);
+            if (highlightWeekend && isWeekend) {
+                return `
+          background: radial-gradient(var(--occuplan-weekend-bg-color), ${f.bgColor}, ${f.bgColor});
+          color: ${f.fontColor};
+        `;
+            }
+            return `
+        background-color: ${f.bgColor};
+        color: ${f.fontColor};
+      `;
+        }
+        if (oEnds && oStarts) {
+            const sf = occupationTypeFormattingByOccupation(oStarts);
+            const ef = occupationTypeFormattingByOccupation(oEnds);
+            if (isWeekend && highlightWeekend) {
+                return `
+          color: ${ef.fontColor};
+          background: radial-gradient(var(--occuplan-weekend-bg-color), transparent, transparent), linear-gradient(90deg, ${ef.bgColor}, ${sf.bgColor});
+          `;
+            }
+            return `
+        background: linear-gradient(90deg, ${ef.bgColor}, ${sf.bgColor});
+        color: ${ef.fontColor};
+        `;
+        }
+        if (oStarts) {
+            const sf = occupationTypeFormattingByOccupation(oStarts);
+            if (isWeekend && highlightWeekend) {
+                return `
+          color: var(--occuplan-main-font-color);
+          background: 
+            radial-gradient(var(--occuplan-weekend-bg-color), transparent, transparent), linear-gradient(90deg, var(--occuplan-main-bg-color), ${sf.bgColor});
+          `;
+            }
+            return `
+        background: linear-gradient(90deg, var(--occuplan-main-bg-color), ${sf.bgColor});
+        color: var(--occuplan-main-font-color);
+        `;
+        }
+        if (oEnds) {
+            const ef = occupationTypeFormattingByOccupation(oEnds);
+            if (isWeekend && highlightWeekend) {
+                return `
+        background: 
+          radial-gradient(var(--occuplan-weekend-bg-color), transparent, transparent), linear-gradient(90deg, ${ef.bgColor}, var(--occuplan-main-bg-color));
+        color: ${ef.fontColor};
+        `;
+            }
+            return `
+        background: linear-gradient(90deg, ${ef.bgColor}, var(--occuplan-main-bg-color));
+        color: ${ef.fontColor};
+        `;
+        }
+        if (isWeekend && highlightWeekend) {
+            return `
+        background: radial-gradient(var(--occuplan-weekend-bg-color), var(--occuplan-main-bg-color), var(--occuplan-main-bg-color));
+        color: var(--occuplan-main-font-color);
+      `;
+        }
+        return `
+        background-color: var(--occuplan-main-bg-color);
+        color: var(--occuplan-main-font-color);
+      `;
+    };
+}
+export const getOccupationState = (url, debug = false) => {
+    if (debug)
+        console.log('Get OState /w url', url);
+    const stateID = `i-${url}-${OCCUPATION_STATE}`;
+    let _instance = getContext(stateID);
+    if (_instance)
+        return _instance;
+    setContext(stateID, new OccupationState(url, debug));
+    return getContext(stateID);
+};

package/dist/svg/LogoSVG.svelte

@@ -77,4 +77,3 @@
     ></svg
   ></svg
 >
-

package/dist/types.d.ts

@@ -361,7 +361,7 @@ export interface PageProps {
     header?: string;
     showFooter?: boolean;
     footerRef?: string;
-    isToS?: string;
+    isToS?: boolean;
     fixedHamburger?: boolean;
     navbarOverHamburger?: boolean;
     disableLinks?: boolean;
@@ -398,7 +398,7 @@ export interface I18nFacade {
     calendarTranslation?: OccuplanTranslations;
     translateFunc?: (ref: string) => string;
     translateWithLangFunc?: (ref: string, lang: string) => string;
-    formatFunc?: (formatter: string, props: Record<string, any>) => string;
+    formatFunc?: (formatter: string, props: Record<string, unknown>) => string;
     formatMoneyFunc?: (d: number) => string;
     formatDateFunc?: (d: DateTime | string) => string;
     updateCurrentLang?: (lang: string) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "accomadesc",
-  "version": "0.3.42",
+  "version": "0.4.1",
   "files": [
     "dist",
     "!dist/**/*.test.*",
@@ -29,18 +29,24 @@
     "@sveltejs/kit": "^2.50.0",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^5.1.1",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/svelte": "^5.3.1",
     "@types/luxon": "^3.7.1",
+    "@types/node": "^25.0.9",
+    "@vitest/ui": "^4.0.17",
     "gdpr-cooco-banner": "^0.0.13",
+    "jsdom": "^27.4.0",
     "prettier": "^3.8.0",
     "prettier-plugin-svelte": "^3.4.1",
     "publint": "^0.3.16",
-    "svelte": "^5.46.4",
+    "svelte": "^5.47.0",
     "svelte-check": "^4.3.5",
     "typescript": "^5.9.3",
-    "vite": "^6.4.1"
+    "vite": "^6.4.1",
+    "vitest": "^4.0.17"
   },
   "dependencies": {
-    "@dinero.js/currencies": "2.0.0-alpha.14",
     "@fontsource/raleway": "^5.2.8",
     "@twicpics/components": "^0.31.4",
     "@types/leaflet": "^1.9.21",