more-apartments-astro-integration 1.0.1

package/dist/index.mjs

@@ -0,0 +1,964 @@
+import { z } from 'zod';
+
+// src/client.ts
+var PaginationLinksSchema = z.object({
+  first: z.string().nullable(),
+  last: z.string().nullable(),
+  prev: z.string().nullable(),
+  next: z.string().nullable()
+});
+var PaginationMetaSchema = z.object({
+  current_page: z.number(),
+  from: z.number().nullable(),
+  last_page: z.number(),
+  links: z.array(z.object({
+    url: z.string().nullable(),
+    label: z.string(),
+    active: z.boolean()
+  })),
+  path: z.string(),
+  per_page: z.number(),
+  to: z.number().nullable(),
+  total: z.number()
+});
+var PaginatedResponseSchema = (dataSchema) => z.object({
+  data: z.array(dataSchema),
+  links: PaginationLinksSchema,
+  meta: PaginationMetaSchema
+});
+var ApiErrorSchema = z.object({
+  message: z.string(),
+  errors: z.record(z.array(z.string())).optional()
+});
+var PropertyImageSchema = z.object({
+  id: z.number(),
+  url: z.string(),
+  alt: z.string().optional()
+});
+var PropertySchema = z.object({
+  id: z.number(),
+  external_id: z.number().optional(),
+  name: z.string(),
+  slug: z.string(),
+  // Descriptions
+  short_description: z.string().nullable(),
+  description: z.string(),
+  area_description: z.string().nullable(),
+  arrival_description: z.string().nullable(),
+  // Property type & capacity
+  type: z.string().nullable(),
+  max_persons: z.number().nullable(),
+  bedrooms: z.number().nullable(),
+  bathrooms: z.number().nullable(),
+  toilets: z.number().nullable(),
+  size: z.number().nullable(),
+  floor: z.number().nullable(),
+  // Location
+  street: z.string().nullable(),
+  zipcode: z.string().nullable(),
+  area: z.string().nullable(),
+  city: z.string(),
+  country: z.string(),
+  latitude: z.number(),
+  longitude: z.number(),
+  // Beds
+  single_bed: z.number().nullable(),
+  double_bed: z.number().nullable(),
+  single_sofa: z.number().nullable(),
+  double_sofa: z.number().nullable(),
+  single_bunk: z.number().nullable(),
+  // Amenities - Outdoor
+  balcony: z.boolean(),
+  terrace: z.boolean(),
+  view: z.string().nullable(),
+  // Amenities - Climate
+  airco: z.boolean(),
+  fans: z.boolean(),
+  heating: z.boolean(),
+  // Amenities - Connectivity
+  internet: z.string().nullable(),
+  internet_connection: z.string().nullable(),
+  tv: z.string().nullable(),
+  tv_connection: z.string().nullable(),
+  dvd: z.boolean(),
+  computer: z.boolean(),
+  printer: z.boolean(),
+  // Amenities - Kitchen
+  dishwasher: z.boolean(),
+  oven: z.boolean(),
+  microwave: z.boolean(),
+  fridge: z.boolean(),
+  freezer: z.boolean(),
+  toaster: z.boolean(),
+  kettle: z.boolean(),
+  coffeemachine: z.boolean(),
+  // Amenities - Laundry
+  washingmachine: z.boolean(),
+  dryer: z.boolean(),
+  iron: z.boolean(),
+  // Amenities - Bathroom
+  bathtub: z.boolean(),
+  jacuzzi: z.boolean(),
+  shower_regular: z.boolean(),
+  shower_steam: z.boolean(),
+  hairdryer: z.boolean(),
+  // Amenities - Recreation
+  swimmingpool: z.string().nullable(),
+  sauna: z.string().nullable(),
+  // Amenities - General
+  parking: z.string().nullable(),
+  entresol: z.boolean(),
+  wheelchair_friendly: z.boolean(),
+  smoking_allowed: z.boolean(),
+  pets_allowed: z.boolean(),
+  // Supplies
+  supplies_coffee: z.boolean(),
+  supplies_tea: z.boolean(),
+  supplies_milk: z.boolean(),
+  supplies_sugar: z.boolean(),
+  supplies_dishwasher_tablets: z.boolean(),
+  // Services
+  service_linen: z.boolean(),
+  service_towels: z.boolean(),
+  // Costs & Policies
+  cleaning_costs: z.number().nullable(),
+  deposit_costs: z.number().nullable(),
+  min_rate: z.number().nullable(),
+  minimal_nights: z.number().nullable(),
+  maximal_nights: z.number().nullable(),
+  // Check-in/out
+  check_in: z.string().nullable(),
+  check_out: z.string().nullable(),
+  // Media
+  images: z.array(z.object({
+    id: z.number(),
+    url: z.string(),
+    thumb_url: z.string(),
+    alt: z.string()
+  })).optional(),
+  // Metadata
+  status: z.string().nullable(),
+  provider_name: z.string().nullable(),
+  created_at: z.string(),
+  updated_at: z.string()
+});
+var AvailableDay = z.object({
+  available: z.boolean(),
+  morning_available: z.boolean(),
+  date: z.string(),
+  day: z.number()
+});
+var AvailabilitySchema = z.object({
+  days: z.record(z.string(), AvailableDay)
+});
+var PropertySearchParamsSchema = z.object({
+  // Date filters
+  arrival: z.string().optional(),
+  departure: z.string().optional(),
+  // Guest capacity
+  guests: z.number().optional(),
+  // General search (deprecated in favor of direct column filters)
+  destination: z.string().optional(),
+  segment: z.string().optional(),
+  // DEPRECATED: use city/area instead
+  // Direct column filters (preferred for headless instances)
+  city: z.string().optional(),
+  area: z.string().optional(),
+  propertyType: z.string().optional(),
+  bedrooms: z.number().optional(),
+  bathrooms: z.number().optional(),
+  maxPersons: z.number().optional(),
+  elevator: z.boolean().optional(),
+  parking: z.boolean().optional(),
+  balcony: z.boolean().optional()
+});
+var PropertySearchResultSchema = z.object({
+  data: z.array(PropertySchema)
+});
+var PropertyPageSettingsSchema = z.object({
+  routing: z.object({
+    base_url: z.string()
+  }),
+  index: z.object({
+    seo: z.object({
+      title: z.string(),
+      description: z.string(),
+      openGraphTitle: z.string().optional(),
+      tags: z.array(z.string()).optional()
+    })
+  }),
+  show: z.object({
+    hero: z.object({
+      provider: z.boolean().optional(),
+      address: z.boolean().optional()
+    }).optional(),
+    cancellation_policy: z.object({
+      description: z.string()
+    }).optional(),
+    related_properties: z.object({
+      title: z.string()
+    }).optional()
+  }).optional()
+});
+var PageSchema = z.object({
+  id: z.string(),
+  slug: z.string(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  content: z.string().nullable(),
+  sections: z.array(z.any()),
+  seo: z.object({
+    title: z.string(),
+    description: z.string(),
+    image: z.string().nullable()
+  }),
+  route_name: z.string()
+});
+var PostSchema = z.object({
+  id: z.string(),
+  slug: z.string(),
+  title: z.string(),
+  description: z.string().nullable(),
+  content: z.string().nullable(),
+  excerpt: z.string().nullable(),
+  author: z.string().nullable(),
+  date: z.string(),
+  // ISO date string
+  image: z.string().nullable(),
+  tags: z.array(z.string()),
+  reading_time: z.string().nullable(),
+  sections: z.array(z.any()),
+  seo: z.object({
+    title: z.string(),
+    description: z.string(),
+    image: z.string().nullable()
+  }),
+  route_name: z.string()
+});
+var CategorySchema = z.object({
+  slug: z.string(),
+  name: z.string(),
+  title: z.string(),
+  description: z.string().nullable(),
+  content: z.string().nullable(),
+  segments: z.union([z.array(z.string()), z.number()]).optional()
+});
+var CategorySegmentSchema = z.object({
+  name: z.string(),
+  slug: z.string(),
+  title: z.string(),
+  description: z.string().nullable(),
+  tags: z.array(z.string()).optional(),
+  sections: z.array(z.any()),
+  content: z.string().nullable(),
+  image: z.string()
+});
+var MainSettingsSchema = z.object({
+  site: z.object({
+    name: z.string(),
+    domain: z.string(),
+    locale: z.string()
+  }),
+  contact: z.object({
+    email: z.string(),
+    phone: z.string().optional()
+  }),
+  social: z.object({
+    facebook: z.string().optional(),
+    instagram: z.string().optional()
+  }).optional(),
+  mail: z.object({
+    from: z.object({
+      address: z.string(),
+      name: z.string()
+    }),
+    contact_form_to: z.string()
+  }).optional(),
+  pms: z.object({
+    property_providers: z.array(z.object({
+      name: z.string(),
+      system: z.string(),
+      api_key: z.string().optional(),
+      base_url: z.string().optional(),
+      discount: z.number().optional(),
+      enabled: z.boolean().optional()
+    }))
+  }).optional(),
+  pricing: z.object({
+    vat: z.number(),
+    tourist_tax: z.object({
+      type: z.string(),
+      value: z.number()
+    })
+  }).optional(),
+  discount: z.number().optional()
+});
+var ThemeSettingsSchema = z.object({
+  logo: z.object({
+    path: z.string(),
+    height: z.number().optional()
+  }).optional(),
+  favicon_path: z.string().optional(),
+  colors: z.object({
+    primary: z.string(),
+    secondary: z.string()
+  }),
+  layout: z.object({
+    homepage_style: z.string().optional(),
+    navigation: z.object({
+      variant: z.string().optional(),
+      items: z.array(z.any()),
+      buttons: z.array(z.any()).optional()
+    }).optional(),
+    footer: z.object({
+      blog_title: z.string().optional(),
+      contact_title: z.string().optional(),
+      categories: z.array(z.any()).optional()
+    }).optional()
+  }).optional()
+});
+var PropertySettingsSchema = z.object({
+  routing: z.object({
+    base_url: z.string()
+  }),
+  seo: z.object({
+    title: z.string(),
+    description: z.string(),
+    openGraphTitle: z.string().optional(),
+    tags: z.array(z.string()).optional()
+  }).optional(),
+  index: z.object({
+    seo: z.object({
+      title: z.string(),
+      description: z.string(),
+      openGraphTitle: z.string().optional(),
+      tags: z.array(z.string()).optional()
+    })
+  }),
+  show: z.object({
+    hero: z.object({
+      provider: z.boolean().optional(),
+      address: z.boolean().optional()
+    }).optional(),
+    cancellation_policy: z.object({
+      description: z.string()
+    }).optional(),
+    related_properties: z.object({
+      title: z.string()
+    }).optional()
+  }).optional()
+});
+var BookingSettingsSchema = z.object({
+  booking_confirmation: z.object({
+    sections: z.object({
+      arrival_description: z.boolean().optional()
+    }).optional(),
+    content: z.object({
+      body: z.string().optional(),
+      help: z.string().optional()
+    }).optional()
+  }).optional()
+});
+var BookingRequestSchema = z.object({
+  property_id: z.number(),
+  check_in: z.string(),
+  check_out: z.string(),
+  guests: z.number(),
+  first_name: z.string(),
+  last_name: z.string(),
+  email: z.string().email(),
+  phone: z.string().optional(),
+  notes: z.string().optional(),
+  total_amount: z.number(),
+  payment_method: z.enum(["stripe", "cash", "bank_transfer"]).optional()
+});
+var BookingResponseSchema = z.object({
+  id: z.string(),
+  property_id: z.number(),
+  check_in: z.string(),
+  check_out: z.string(),
+  guests: z.number(),
+  status: z.enum(["pending", "confirmed", "cancelled", "completed"]),
+  total_amount: z.number(),
+  payment_status: z.enum(["pending", "paid", "refunded"]),
+  confirmation_code: z.string(),
+  created_at: z.string(),
+  updated_at: z.string()
+});
+var MoreApartmentsConfigSchema = z.object({
+  baseUrl: z.string().optional(),
+  apiKey: z.string().optional(),
+  instance: z.string().optional(),
+  timeout: z.number().optional(),
+  retry: z.object({
+    attempts: z.number(),
+    delay: z.number()
+  }).optional(),
+  cache: z.object({
+    enabled: z.boolean(),
+    ttl: z.number()
+  }).optional()
+});
+
+// src/client.ts
+var MoreApartmentsClient = class {
+  config;
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Clear all cached data
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      entries: this.cache.size,
+      size: Array.from(this.cache.values()).reduce((total, entry) => {
+        return total + JSON.stringify(entry.data).length;
+      }, 0)
+    };
+  }
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl?.replace(/\/$/, "") || "",
+      apiKey: config.apiKey || "",
+      instance: config.instance || "",
+      timeout: config.timeout || 3e4,
+      retry: {
+        attempts: config.retry?.attempts || 3,
+        delay: config.retry?.delay || 1e3
+      },
+      cache: {
+        enabled: config.cache?.enabled ?? true,
+        ttl: config.cache?.ttl || 3e5
+        // 5 minutes default
+      }
+    };
+  }
+  async fetchWithRetry(url, options = {}, schema) {
+    const cacheKey = `${options.method || "GET"}:${url}`;
+    if (this.config.cache?.enabled && (!options.method || options.method === "GET")) {
+      const cached = this.cache.get(cacheKey);
+      if (cached && this.config.cache?.ttl && Date.now() - cached.timestamp < this.config.cache.ttl) {
+        return cached.data;
+      }
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      ...this.config.apiKey && { "Authorization": `Bearer ${this.config.apiKey}` },
+      ...this.config.instance && { "X-Instance": this.config.instance },
+      ...options.headers
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt < (this.config.retry?.attempts ?? 3); attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+          controller.abort();
+        }, this.config.timeout);
+        const response = await fetch(url, {
+          ...options,
+          headers,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const error = await response.json().catch(() => ({ message: response.statusText }));
+          throw new Error(error.message || `HTTP ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (schema) {
+          const result = schema.safeParse(data);
+          if (!result.success) {
+            throw new Error(`Invalid response format: ${result.error.message}`);
+          }
+          const validatedData = result.data;
+          if (this.config.cache?.enabled && (!options.method || options.method === "GET")) {
+            this.cache.set(cacheKey, { data: validatedData, timestamp: Date.now() });
+          }
+          return validatedData;
+        }
+        if (this.config.cache?.enabled && (!options.method || options.method === "GET")) {
+          this.cache.set(cacheKey, { data, timestamp: Date.now() });
+        }
+        return data;
+      } catch (error) {
+        lastError = error;
+        if (attempt < (this.config.retry?.attempts ?? 3) - 1) {
+          await new Promise((resolve) => setTimeout(resolve, (this.config.retry?.delay ?? 1e3) * (attempt + 1)));
+        }
+      }
+    }
+    throw lastError || new Error("Request failed");
+  }
+  // Property endpoints
+  async getProperties(params) {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.append("page", params.page.toString());
+    if (params?.per_page) queryParams.append("per_page", params.per_page.toString());
+    const url = `${this.config.baseUrl}/api/v1/properties${queryParams.toString() ? "?" + queryParams.toString() : ""}`;
+    return this.fetchWithRetry(url, {}, PaginatedResponseSchema(PropertySchema));
+  }
+  async getProperty(propertyIdOrSlug) {
+    const url = `${this.config.baseUrl}/api/v1/properties/${propertyIdOrSlug}`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: PropertySchema }));
+    return response.data;
+  }
+  // Availability endpoints
+  async getAvailability(propertySlug, startDate, endDate) {
+    const queryParams = new URLSearchParams({
+      start_date: startDate,
+      end_date: endDate
+    });
+    const url = `${this.config.baseUrl}/api/v1/properties/${propertySlug}/availability?${queryParams}`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: AvailabilitySchema }));
+    return response.data;
+  }
+  // Content endpoints
+  async getPages() {
+    const url = `${this.config.baseUrl}/api/v1/pages`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: z.array(PageSchema) }));
+    return response.data;
+  }
+  async getPage(slug) {
+    const url = `${this.config.baseUrl}/api/v1/pages/${slug}`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: PageSchema }));
+    return response.data;
+  }
+  async getPosts(params) {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.append("page", params.page.toString());
+    if (params?.per_page) queryParams.append("per_page", params.per_page.toString());
+    if (params?.tag) queryParams.append("tag", params.tag);
+    const url = `${this.config.baseUrl}/api/v1/posts${queryParams.toString() ? "?" + queryParams.toString() : ""}`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: z.array(PostSchema) }));
+    return response.data;
+  }
+  async getPost(slug) {
+    const url = `${this.config.baseUrl}/api/v1/posts/${slug}`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: PostSchema }));
+    return response.data;
+  }
+  async getLocations() {
+    const url = `${this.config.baseUrl}/api/v1/locations`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: z.array(z.string()) }));
+    return response.data;
+  }
+  async getCategories() {
+    const url = `${this.config.baseUrl}/api/v1/categories`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: z.array(CategorySchema) }));
+    return response.data;
+  }
+  async getCategory(slug) {
+    const url = `${this.config.baseUrl}/api/v1/categories/${slug}`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: CategorySchema }));
+    return response.data;
+  }
+  async getCategorySegments(slug) {
+    const url = `${this.config.baseUrl}/api/v1/categories/${slug}/segments`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: z.array(CategorySegmentSchema) }));
+    return response.data;
+  }
+  async getCategorySegment(slug, segment) {
+    const url = `${this.config.baseUrl}/api/v1/categories/${slug}/segments/${segment}`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: CategorySegmentSchema }));
+    return response.data;
+  }
+  // Settings endpoints
+  async getMainSettings() {
+    const url = `${this.config.baseUrl}/api/v1/settings/main`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: MainSettingsSchema }));
+    return response.data;
+  }
+  async getThemeSettings() {
+    const url = `${this.config.baseUrl}/api/v1/settings/theme`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: ThemeSettingsSchema }));
+    return response.data;
+  }
+  async getPropertySettings() {
+    const url = `${this.config.baseUrl}/api/v1/settings/properties`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: PropertySettingsSchema }));
+    return response.data;
+  }
+  async getBookingSettings() {
+    const url = `${this.config.baseUrl}/api/v1/settings/booking`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: BookingSettingsSchema }));
+    return response.data;
+  }
+  // Booking endpoints
+  async createBooking(booking) {
+    const url = `${this.config.baseUrl}/api/v1/bookings`;
+    const response = await this.fetchWithRetry(
+      url,
+      {
+        method: "POST",
+        body: JSON.stringify(booking)
+      },
+      z.object({ data: BookingResponseSchema })
+    );
+    return response.data;
+  }
+  async getBooking(bookingId) {
+    const url = `${this.config.baseUrl}/api/v1/bookings/${bookingId}`;
+    const response = await this.fetchWithRetry(url, {}, z.object({ data: BookingResponseSchema }));
+    return response.data;
+  }
+  /**
+   * Search properties with advanced filtering
+   */
+  async searchProperties(params) {
+    const searchParams = new URLSearchParams();
+    if (params.arrival) searchParams.set("arrival", params.arrival);
+    if (params.departure) searchParams.set("departure", params.departure);
+    if (params.guests) searchParams.set("guests", params.guests.toString());
+    if (params.destination) searchParams.set("destination", params.destination);
+    if (params.segment) searchParams.set("segment", params.segment);
+    if (params.city) searchParams.set("city", params.city);
+    if (params.area) searchParams.set("area", params.area);
+    if (params.propertyType) searchParams.set("property_type", params.propertyType);
+    if (params.bedrooms !== void 0) searchParams.set("bedrooms", params.bedrooms.toString());
+    if (params.bathrooms !== void 0) searchParams.set("bathrooms", params.bathrooms.toString());
+    if (params.maxPersons !== void 0) searchParams.set("max_persons", params.maxPersons.toString());
+    if (params.elevator !== void 0) searchParams.set("elevator", params.elevator ? "1" : "0");
+    if (params.parking !== void 0) searchParams.set("parking", params.parking ? "1" : "0");
+    if (params.balcony !== void 0) searchParams.set("balcony", params.balcony ? "1" : "0");
+    const url = `${this.config.baseUrl}/api/v1/properties/search?${searchParams.toString()}`;
+    const response = await this.fetchWithRetry(url, {}, PropertySearchResultSchema);
+    return response.data;
+  }
+};
+
+// src/utils/images.ts
+function getPrimaryImageUrl(property, fallbackUrl) {
+  if (property.images && property.images.length > 0) {
+    return property.images[0].url;
+  }
+  if (fallbackUrl) {
+    return fallbackUrl;
+  }
+  throw new Error(`Property "${property.name}" (ID: ${property.id}) has no images`);
+}
+function getThumbnailUrl(property, fallbackUrl) {
+  if (property.images && property.images.length > 0) {
+    return property.images[0].thumb_url;
+  }
+  if (fallbackUrl) {
+    return fallbackUrl;
+  }
+  throw new Error(`Property "${property.name}" (ID: ${property.id}) has no thumbnail images`);
+}
+function getAllImageUrls(property) {
+  return property.images?.map((img) => img.url) || [];
+}
+function getAllThumbnailUrls(property) {
+  return property.images?.map((img) => img.thumb_url) || [];
+}
+function getImageWithAlt(property, index = 0) {
+  const image = property.images?.[index];
+  if (!image?.url) {
+    throw new Error(`Property "${property.name}" (ID: ${property.id}) has no image at index ${index}`);
+  }
+  return {
+    url: image.url,
+    alt: image.alt || property.name
+  };
+}
+function getImage(property, index = 0) {
+  return property.images?.[index] || null;
+}
+function hasImages(property) {
+  return !!(property.images && Array.isArray(property.images) && property.images.length > 0);
+}
+function getImageCount(property) {
+  return Array.isArray(property.images) ? property.images.length : 0;
+}
+
+// src/index.ts
+function moreApartmentsIntegration(options) {
+  return {
+    name: "@shelfwood/more-apartments-astro-integration",
+    hooks: {
+      "astro:config:setup": async ({
+        config: astroConfig,
+        updateConfig,
+        injectScript,
+        injectRoute,
+        logger
+      }) => {
+        let apiKey = options.apiKey;
+        let apiKeySource = "environment variable";
+        if (options.instancePath && !apiKey) {
+          try {
+            const fs = await import('fs');
+            const path = await import('path');
+            const resolvedInstancePath = path.resolve(process.cwd(), options.instancePath);
+            const devKeyPath = path.join(resolvedInstancePath, ".dev-api-key");
+            if (fs.existsSync(devKeyPath)) {
+              apiKey = fs.readFileSync(devKeyPath, "utf-8").trim();
+              apiKeySource = `${path.basename(resolvedInstancePath)}/.dev-api-key`;
+              logger.info(`\u2713 Using development API key from ${apiKeySource}`);
+            } else {
+              logger.warn(`Instance directory configured but .dev-api-key not found. Run: php artisan dev:generate-api-key --instance=${path.basename(resolvedInstancePath)}`);
+            }
+          } catch (error) {
+            logger.debug(`Could not read .dev-api-key: ${error}`);
+          }
+        } else if (apiKey) {
+          logger.info(`\u2713 Using API key from ${apiKeySource}`);
+        } else {
+          logger.warn("\u26A0\uFE0F  No API key configured. Set MORE_APARTMENTS_API_KEY or configure instancePath for auto-discovery");
+        }
+        const clientOptions = { ...options, apiKey };
+        new MoreApartmentsClient(clientOptions);
+        if (options.virtualModules !== false) {
+          updateConfig({
+            vite: {
+              plugins: [
+                {
+                  name: "more-apartments-virtual-modules",
+                  resolveId(id) {
+                    if (id === "virtual:more-apartments/client") {
+                      return "\0virtual:more-apartments/client";
+                    }
+                    if (id === "virtual:more-apartments/config") {
+                      return "\0virtual:more-apartments/config";
+                    }
+                  },
+                  load(id) {
+                    if (id === "\0virtual:more-apartments/client") {
+                      const clientConfig = {
+                        baseUrl: options.baseUrl,
+                        instance: options.instance
+                        // Never include apiKey in client-side code
+                      };
+                      return `
+                        import { MoreApartmentsClient } from '@shelfwood/more-apartments-astro-integration';
+
+                        const config = ${JSON.stringify(clientConfig)};
+                        export const client = new MoreApartmentsClient(config);
+                        export default client;
+                      `;
+                    }
+                    if (id === "\0virtual:more-apartments/config") {
+                      const clientConfig = {
+                        baseUrl: options.baseUrl,
+                        instance: options.instance
+                      };
+                      return `export default ${JSON.stringify(clientConfig)};`;
+                    }
+                  }
+                }
+              ]
+            }
+          });
+          logger.info("Virtual modules configured for More Apartments API");
+        }
+        if (options.injectClient !== false) {
+          injectScript(
+            "before-hydration",
+            `
+              window.__moreApartments = {
+                baseUrl: '${options.baseUrl}',
+                instance: '${options.instance || ""}',
+                // apiKey intentionally excluded for security
+              };
+            `
+          );
+          logger.info("Global More Apartments client injected (client-side safe config)");
+        }
+        if (options.addApiRoutes !== false) {
+          const routePrefix = options.apiRoutePrefix || "/api/apartments";
+          injectRoute({
+            pattern: `${routePrefix}/properties`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/properties.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/properties/[id]`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/property.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/properties/[id]/availability`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/availability.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/pages`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/pages.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/pages/[slug]`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/page.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/posts`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/posts.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/posts/[slug]`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/post.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/settings/[type]`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/settings.js"
+          });
+          injectRoute({
+            pattern: `${routePrefix}/bookings`,
+            entrypoint: "@shelfwood/more-apartments-astro-integration/routes/bookings.js"
+          });
+          logger.info(`API proxy routes added at ${routePrefix}`);
+        }
+      },
+      "astro:config:done": ({ config: finalConfig, logger }) => {
+        logger.info("More Apartments integration configured successfully");
+      },
+      "astro:server:setup": async ({ server, logger }) => {
+        server.middlewares.use((req, res, next) => {
+          if (req.url?.startsWith("/api/apartments")) {
+            logger.debug(`API request: ${req.method} ${req.url}`);
+          }
+          next();
+        });
+        logger.info(`Instance path config: ${options.instancePath || "not set"}`);
+        if (options.instancePath) {
+          const path = await import('path');
+          const chokidar = await import('chokidar');
+          const resolvedPath = path.resolve(process.cwd(), options.instancePath);
+          logger.info(`Watching instance directory: ${resolvedPath}`);
+          const watcher = chokidar.watch(resolvedPath, {
+            ignored: /(^|[\/\\])\../,
+            // ignore dotfiles
+            persistent: true,
+            ignoreInitial: true
+          });
+          watcher.on("change", (filePath) => {
+            logger.info(`Instance file changed: ${path.relative(resolvedPath, filePath)}`);
+            server.ws.send({
+              type: "full-reload",
+              path: "*"
+            });
+          });
+          watcher.on("add", (filePath) => {
+            logger.info(`Instance file added: ${path.relative(resolvedPath, filePath)}`);
+            server.ws.send({
+              type: "full-reload",
+              path: "*"
+            });
+          });
+          watcher.on("unlink", (filePath) => {
+            logger.info(`Instance file removed: ${path.relative(resolvedPath, filePath)}`);
+            server.ws.send({
+              type: "full-reload",
+              path: "*"
+            });
+          });
+          server.httpServer?.on("close", () => {
+            watcher.close();
+          });
+        }
+      },
+      "astro:build:done": ({ logger }) => {
+        logger.info("More Apartments integration build complete");
+      }
+    }
+  };
+}
+async function fetchProperties(client, params) {
+  try {
+    return await client.getProperties(params);
+  } catch (error) {
+    console.error("Error fetching properties:", error);
+    return { data: [], links: {}, meta: {} };
+  }
+}
+async function fetchProperty(client, idOrSlug) {
+  try {
+    return await client.getProperty(idOrSlug);
+  } catch (error) {
+    console.error("Error fetching property:", error);
+    return null;
+  }
+}
+async function fetchAvailability(client, propertySlug, startDate, endDate) {
+  try {
+    return await client.getAvailability(propertySlug, startDate, endDate);
+  } catch (error) {
+    console.error("Error fetching availability:", error);
+    return null;
+  }
+}
+async function fetchPages(client) {
+  try {
+    return await client.getPages();
+  } catch (error) {
+    console.error("Error fetching pages:", error);
+    return [];
+  }
+}
+async function fetchPage(client, slug) {
+  try {
+    return await client.getPage(slug);
+  } catch (error) {
+    console.error("Error fetching page:", error);
+    return null;
+  }
+}
+async function fetchPosts(client, params) {
+  try {
+    return await client.getPosts(params);
+  } catch (error) {
+    console.error("Error fetching posts:", error);
+    return { data: [], links: {}, meta: {} };
+  }
+}
+async function fetchPost(client, slug) {
+  try {
+    return await client.getPost(slug);
+  } catch (error) {
+    console.error("Error fetching post:", error);
+    return null;
+  }
+}
+async function fetchSettings(client, type) {
+  try {
+    switch (type) {
+      case "main":
+        return await client.getMainSettings();
+      case "theme":
+        return await client.getThemeSettings();
+      case "properties":
+        return await client.getPropertySettings();
+      case "booking":
+        return await client.getBookingSettings();
+      default:
+        throw new Error(`Unknown settings type: ${type}`);
+    }
+  } catch (error) {
+    console.error(`Error fetching ${type} settings:`, error);
+    return null;
+  }
+}
+function generateBookingUrl(propertyExternalId, arrival, departure, guests, baseUrl) {
+  const bookingBaseUrl = baseUrl || import.meta.env.PUBLIC_LARAVEL_BOOKING_URL || "http://prj-more-apartments.test/booking/initiate";
+  const params = new URLSearchParams({
+    property_external_id: propertyExternalId.toString(),
+    arrival,
+    departure,
+    guests: guests.toString()
+  });
+  return `${bookingBaseUrl}?${params.toString()}`;
+}
+async function searchProperties(client, params) {
+  try {
+    return await client.searchProperties(params);
+  } catch (error) {
+    console.error("Error searching properties:", error);
+    return [];
+  }
+}
+
+export { ApiErrorSchema, AvailabilitySchema, AvailableDay, BookingRequestSchema, BookingResponseSchema, BookingSettingsSchema, CategorySchema, CategorySegmentSchema, MainSettingsSchema, MoreApartmentsClient, MoreApartmentsConfigSchema, PageSchema, PaginatedResponseSchema, PaginationLinksSchema, PaginationMetaSchema, PostSchema, PropertyImageSchema, PropertyPageSettingsSchema, PropertySchema, PropertySearchParamsSchema, PropertySearchResultSchema, PropertySettingsSchema, ThemeSettingsSchema, moreApartmentsIntegration as default, fetchAvailability, fetchPage, fetchPages, fetchPost, fetchPosts, fetchProperties, fetchProperty, fetchSettings, generateBookingUrl, getAllImageUrls, getAllThumbnailUrls, getImage, getImageCount, getImageWithAlt, getPrimaryImageUrl, getThumbnailUrl, hasImages, searchProperties };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map