accomadesc 0.0.13 → 0.1.0

package/dist/occuplan/state.svelte.js

@@ -0,0 +1,383 @@
+import { normalizeDate } from '../helpers/normalizeDate.ts';
+import { getEvents } from '../helpers/readICS.ts';
+import { DateTime } from 'luxon';
+import { DateTime as luxon } from 'luxon';
+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, 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 })
+                .plus({ month: monthToAdd });
+            return tDate;
+        }
+    }
+    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())
+                        .plus({ month: intValue })
+                        .plus({ month: monthToAdd });
+                    return tDate;
+                }
+            }
+            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())
+                        .minus({ month: intValue })
+                        .plus({ month: monthToAdd });
+                    return tDate;
+                }
+            }
+            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()).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;
+            }
+        }
+        catch (e) {
+            console.log('casting error', e);
+        }
+    }
+    //first month of current year ... default
+    return normalizeDate(DateTime.utc()).set({ month: 1 }).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);
+    constructor(iCalURL) {
+        this.iCalURL = iCalURL;
+        this.loadOccupations();
+    }
+    loadOccupations = async () => {
+        this.loading = true;
+        if (this.iCalURL) {
+            const eventsResult = await getEvents(this.iCalURL, this.eventsIncomingCallback);
+            this.loading = false;
+            return !eventsResult.error;
+        }
+        return false;
+    };
+    eventsIncomingCallback = (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];
+    };
+    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
+        return !this.occupations.find((o) => o.arrival < to && o.leave > from);
+    };
+    occupationStyle = (d, highlightWeekend = false, maxDate) => {
+        const valid = validDay(d);
+        if (!valid) {
+            return 'background-color: var(--occuplan-bg-color-invalid-days);';
+        }
+        const day = luxon.utc(d.year, d.month, d.day);
+        const outOfScope = day >= maxDate;
+        if (outOfScope) {
+            return 'background-color: var(--occuplan-bg-color-invalid-days);';
+        }
+        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-bg-color-weekend), ${f.bgColor}, ${f.bgColor});
+        `;
+            }
+            return `
+        background-color: ${f.bgColor};
+      `;
+        }
+        if (oEnds && oStarts) {
+            const sf = occupationTypeFormattingByOccupation(oStarts);
+            const ef = occupationTypeFormattingByOccupation(oEnds);
+            if (isWeekend && highlightWeekend) {
+                return `
+          background: radial-gradient(var(--occuplan-bg-color-weekend), var(--occuplan-bg-color-main), var(--occuplan-bg-color-main)), linear-gradient(90deg, ${ef.bgColor}, ${sf.bgColor});
+          `;
+            }
+            return `
+        background: linear-gradient(90deg, ${ef.bgColor}, ${sf.bgColor});
+        `;
+        }
+        if (oStarts) {
+            const sf = occupationTypeFormattingByOccupation(oStarts);
+            if (isWeekend && highlightWeekend) {
+                return `
+        background: radial-gradient( var(--occuplan-bg-color-weekend), var(--occuplan-bg-color-main), var(--occuplan-bg-color-main)), linear-gradient(90deg, var(--occuplan-bg-color-main), ${sf.bgColor});
+        `;
+            }
+            return `
+        background: linear-gradient(90deg, var(--occuplan-bg-color-main), ${sf.bgColor});
+        `;
+        }
+        if (oEnds) {
+            const ef = occupationTypeFormattingByOccupation(oEnds);
+            if (isWeekend && highlightWeekend) {
+                return `
+        background: radial-gradient( var(--occuplan-bg-color-weekend), var(--occuplan-bg-color-main), var(--occuplan-bg-color-main)), linear-gradient(90deg, ${ef.bgColor}, var(--occuplan-bg-color-main));
+        `;
+            }
+            return `
+        background: linear-gradient(90deg, ${ef.bgColor}, var(--occuplan-bg-color-main));
+        `;
+        }
+        if (isWeekend && highlightWeekend) {
+            return `
+        background: radial-gradient(var(--occuplan-bg-color-weekend), var(--occuplan-bg-color-main), var(--occuplan-bg-color-main));
+      `;
+        }
+        return `
+        background-color: var(--occuplan-bg-color-main);
+      `;
+    };
+}
+let _instances = {};
+export const getOccupationState = (url) => {
+    const currentInstance = _instances[url];
+    if (currentInstance)
+        return currentInstance;
+    const newInstance = new OccupationState(url);
+    _instances[url] = newInstance;
+    return _instances[url];
+};

package/dist/svg/ExtLinkSVG.svelte.d.ts

@@ -1,5 +1,6 @@
-declare const ExtLinkSvg: import("svelte").Component<{
+interface Props {
     size?: string;
-}, {}, "">;
+}
+declare const ExtLinkSvg: import("svelte").Component<Props, {}, "">;
 type ExtLinkSvg = ReturnType<typeof ExtLinkSvg>;
 export default ExtLinkSvg;

package/dist/svg/LinkSVG.svelte.d.ts

@@ -1,5 +1,6 @@
-declare const LinkSvg: import("svelte").Component<{
+interface Props {
     size?: string;
-}, {}, "">;
+}
+declare const LinkSvg: import("svelte").Component<Props, {}, "">;
 type LinkSvg = ReturnType<typeof LinkSvg>;
 export default LinkSvg;

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 import { type Dinero, type DineroSnapshot } from 'dinero.js';
 import type { DateTime } from 'luxon';
 import type { I18n } from 'occuplan';
+import type { FirstMonth } from './occuplan/state.svelte.ts';
 export interface GridPhoto {
     photo: Photo;
     zoomed: boolean;
@@ -23,7 +24,15 @@ export interface Calendar {
     content: CalendarContent;
 }
 export interface CalendarContent {
-    calUrl: string;
+    url: string;
+    toggleGridOffset?: number;
+    gridMonthNumbers?: number;
+    gridFirstMonth?: FirstMonth;
+    gridMaxWidth?: string;
+    toggleRowsOffset?: number;
+    rowsMonthNumbers?: number;
+    rowsFirstMonth?: FirstMonth;
+    rowsMaxWidth?: string;
 }
 export interface CalendarAvailable {
     id: string;
@@ -31,10 +40,30 @@ export interface CalendarAvailable {
     content: CalendarAvailableContent;
 }
 export interface CalendarAvailableContent {
-    calUrl: string;
+    url: string;
     search: number[];
     maxFutureDate?: string;
 }
+export interface CalendarGrid {
+    id: string;
+    kind: 'calendar-grid';
+    content: CalendarGridContent;
+}
+export interface CalendarGridContent {
+    url: string;
+    maxYear?: number;
+    minYear?: number;
+}
+export interface CalendarRows {
+    id: string;
+    kind: 'calendar-rows';
+    content: CalendarRowsContent;
+}
+export interface CalendarRowsContent {
+    url: string;
+    maxYear?: number;
+    minYear?: number;
+}
 export interface Text {
     id: string;
     kind: 'text';
@@ -55,7 +84,6 @@ export interface WeatherContent {
     header1: string;
     header2: string;
     location: string;
-    currenLang: string;
 }
 export interface Photo {
     id: string;
@@ -195,7 +223,46 @@ export interface AccoDescriptionContent {
     textFontSize?: string;
     headerFontSize?: string;
 }
-export type Block = Text | Photo | PhotoGallery | Calendar | CalendarAvailable | Pricing | PricingShort | AmenitiesCore | Weather | LeafletMap | AccoCard | AccoDescription | undefined;
+export interface ContactForm {
+    id: string;
+    kind: 'contact-form';
+    content: ContactFormContent;
+}
+export interface ContactFormContent {
+    userID: string;
+    endpoint: string;
+    nameLabel: string;
+    emailLabel: string;
+    questionLabel: string;
+    submitText: string;
+    successfullySentText: string;
+    sentErroredText: string;
+    maxCharsAllowed?: number;
+    explainer?: string;
+}
+export interface BookingRequest {
+    id: string;
+    kind: 'booking-request';
+    content: BookingRequestContent;
+}
+export interface BookingRequestContent {
+    endpoint: string;
+    userID: string;
+    acco: Acco;
+    calUrl: string;
+    nameLabel: string;
+    emailLabel: string;
+    dateEntryLabel: string;
+    submitText: string;
+    successfullySentText: string;
+    sentErroredText: string;
+    invalidText: string;
+    messageLabel: string;
+    numberOfNightsLabel: string;
+    maxCharsAllowed?: number;
+    explainer?: string;
+}
+export type Block = Text | Photo | PhotoGallery | Calendar | CalendarAvailable | CalendarGrid | CalendarRows | Pricing | PricingShort | AmenitiesCore | Weather | LeafletMap | AccoCard | AccoDescription | ContactForm | BookingRequest | undefined;
 export interface Section {
     id: string;
     header?: string;
@@ -221,6 +288,10 @@ export declare const isWeather: (b: Block) => b is Weather;
 export declare const isAmenitiesCore: (b: Block) => b is AmenitiesCore;
 export declare const isCalendarAvailable: (b: Block) => b is CalendarAvailable;
 export declare const isCalendar: (b: Block) => b is Calendar;
+export declare const isCalendarGrid: (b: Block) => b is CalendarGrid;
+export declare const isCalendarRows: (b: Block) => b is CalendarRows;
 export declare const isPricing: (b: Block) => b is Pricing;
 export declare const isPricingShort: (b: Block) => b is PricingShort;
 export declare const isAccoDescription: (b: Block) => b is AccoDescription;
+export declare const isContactForm: (b: Block) => b is ContactForm;
+export declare const isBookingRequest: (b: Block) => b is BookingRequest;

package/dist/types.js

@@ -52,6 +52,16 @@ export const isCalendar = (b) => {
         return false;
     return b.kind === 'calendar';
 };
+export const isCalendarGrid = (b) => {
+    if (!b)
+        return false;
+    return b.kind === 'calendar-grid';
+};
+export const isCalendarRows = (b) => {
+    if (!b)
+        return false;
+    return b.kind === 'calendar-rows';
+};
 export const isPricing = (b) => {
     if (!b)
         return false;
@@ -67,3 +77,13 @@ export const isAccoDescription = (b) => {
         return false;
     return b.kind === 'acco-description';
 };
+export const isContactForm = (b) => {
+    if (!b)
+        return false;
+    return b.kind === 'contact-form';
+};
+export const isBookingRequest = (b) => {
+    if (!b)
+        return false;
+    return b.kind === 'booking-request';
+};

package/package.json

@@ -1,62 +1,65 @@
 {
-  "name": "accomadesc",
-  "version": "0.0.13",
-  "files": [
-    "dist",
-    "!dist/**/*.test.*",
-    "!dist/**/*.spec.*"
-  ],
-  "sideEffects": [
-    "**/*.css"
-  ],
-  "license": "MIT",
-  "svelte": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "svelte": "./dist/index.js"
-    }
-  },
-  "peerDependencies": {
-    "svelte": "^5.0.0"
-  },
-  "devDependencies": {
-    "@sveltejs/adapter-auto": "^3.3.1",
-    "@sveltejs/kit": "^2.8.1",
-    "@sveltejs/package": "^2.3.7",
-    "@sveltejs/vite-plugin-svelte": "^4.0.0",
-    "@types/luxon": "^3.4.2",
-    "prettier": "^3.3.3",
-    "prettier-plugin-svelte": "^3.2.8",
-    "publint": "^0.2.12",
-    "svelte": "^5.1.16",
-    "svelte-check": "^4.0.7",
-    "typescript": "^5.6.3",
-    "vite": "^5.4.11",
-    "vitest": "^2.1.5"
-  },
-  "dependencies": {
-    "@dinero.js/currencies": "2.0.0-alpha.14",
-    "@fontsource/raleway": "^5.1.0",
-    "@twicpics/components": "^0.31.1",
-    "@types/leaflet": "^1.9.14",
-    "dinero.js": "2.0.0-alpha.14",
-    "leaflet": "^1.9.4",
-    "luxon": "^3.5.0",
-    "occuplan": "^0.3.16"
-  },
-  "scripts": {
-    "dev": "vite dev",
-    "build": "vite build && npm run package",
-    "preview": "vite preview",
-    "package": "svelte-kit sync && svelte-package && publint",
-    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
-    "test:unit": "vitest",
-    "test": "npm run test:unit -- --run",
-    "format": "prettier --write .",
-    "lint": "prettier --check ."
-  }
-}
+	"name": "accomadesc",
+	"version": "0.1.0",
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build && npm run package",
+		"preview": "vite preview",
+		"package": "svelte-kit sync && svelte-package && publint",
+		"prepublishOnly": "npm run package",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+		"test:unit": "vitest",
+		"test": "npm run test:unit -- --run",
+		"format": "prettier --write .",
+		"lint": "prettier --check ."
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"sideEffects": [
+		"**/*.css"
+	],
+	"license": "MIT",
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js"
+		}
+	},
+	"peerDependencies": {
+		"@sveltejs/kit": "^2.15.2",
+		"svelte": "^5.0.0"
+	},
+	"devDependencies": {
+		"@sveltejs/adapter-auto": "^3.3.1",
+		"@sveltejs/kit": "^2.15.2",
+		"@sveltejs/package": "^2.3.7",
+		"@sveltejs/vite-plugin-svelte": "^5.0.3",
+		"@types/luxon": "^3.4.2",
+		"prettier": "^3.4.2",
+		"prettier-plugin-svelte": "^3.3.2",
+		"publint": "^0.3.1",
+		"svelte": "^5.17.3",
+		"svelte-check": "^4.1.3",
+		"typescript": "^5.7.3",
+		"vite": "^6.0.7",
+		"vitest": "^2.1.8"
+	},
+	"dependencies": {
+		"@dinero.js/currencies": "2.0.0-alpha.14",
+		"@fontsource/raleway": "^5.1.1",
+		"@twicpics/components": "^0.31.1",
+		"@types/leaflet": "^1.9.16",
+		"dinero.js": "2.0.0-alpha.14",
+		"leaflet": "^1.9.4",
+		"luxon": "^3.5.0",
+		"occuplan": "^0.3.17",
+		"squirrelly": "^9.1.0"
+	}
+}