@ox-content/islands 0.3.0-alpha.11

package/dist/index-Bc2Aw38x.d.ts

@@ -0,0 +1,177 @@
+//#region src/types.d.ts
+/**
+ * Island Architecture Types
+ *
+ * Framework-agnostic type definitions for the Island system.
+ */
+/**
+ * Loading strategy for islands.
+ *
+ * - `eager`: Hydrate immediately on page load
+ * - `idle`: Hydrate when the browser is idle (requestIdleCallback)
+ * - `visible`: Hydrate when the element becomes visible (IntersectionObserver)
+ * - `media`: Hydrate when a media query matches
+ */
+type LoadStrategy = "eager" | "idle" | "visible" | "media";
+/**
+ * Island configuration extracted from data attributes.
+ */
+interface IslandConfig {
+  /** Unique island identifier */
+  id: string;
+  /** Component name to hydrate */
+  component: string;
+  /** Loading strategy */
+  load: LoadStrategy;
+  /** Media query for 'media' load strategy */
+  mediaQuery?: string;
+  /** Component props (JSON serialized in data-ox-props) */
+  props: Record<string, unknown>;
+}
+/**
+ * Hydration function signature.
+ *
+ * Called when an island should be hydrated.
+ * Returns an optional cleanup function.
+ */
+type HydrateFunction = (element: HTMLElement, props: Record<string, unknown>) => void | (() => void);
+/**
+ * Component registry mapping component names to hydrate functions.
+ */
+type ComponentRegistry = Map<string, HydrateFunction>;
+/**
+ * Options for initializing islands.
+ */
+interface InitIslandsOptions {
+  /** Root margin for IntersectionObserver (visible strategy). Default: "200px" */
+  rootMargin?: string;
+  /** Threshold for IntersectionObserver. Default: 0 */
+  threshold?: number;
+  /** Timeout for idle callback fallback in ms. Default: 200 */
+  idleTimeout?: number;
+  /** Custom selector for finding islands. Default: "[data-ox-island]" */
+  selector?: string;
+  /** Called when an island starts hydrating */
+  onHydrateStart?: (element: HTMLElement, config: IslandConfig) => void;
+  /** Called when an island finishes hydrating */
+  onHydrateEnd?: (element: HTMLElement, config: IslandConfig) => void;
+  /** Called when hydration fails */
+  onHydrateError?: (element: HTMLElement, config: IslandConfig, error: Error) => void;
+}
+/**
+ * Island instance tracking.
+ */
+interface IslandInstance {
+  element: HTMLElement;
+  config: IslandConfig;
+  cleanup?: () => void;
+  hydrated: boolean;
+}
+/**
+ * Island controller returned by initIslands.
+ */
+interface IslandController {
+  /** All tracked island instances */
+  instances: IslandInstance[];
+  /** Manually hydrate a specific island */
+  hydrate: (element: HTMLElement) => void;
+  /** Destroy all islands and cleanup */
+  destroy: () => void;
+}
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+//#region src/runtime.d.ts
+/**
+ * Initialize islands with a hydration function.
+ *
+ * This is the main entry point for the island system.
+ * Pass a hydrate function that knows how to mount your components.
+ *
+ * @example Vue
+ * ```ts
+ * import { initIslands } from '@ox-content/islands';
+ * import { createApp, h } from 'vue';
+ * import Counter from './Counter.vue';
+ *
+ * const components = { Counter };
+ *
+ * initIslands((el, props) => {
+ *   const name = el.dataset.oxIsland!;
+ *   const Component = components[name];
+ *   if (!Component) return;
+ *
+ *   const app = createApp({ render: () => h(Component, props) });
+ *   app.mount(el);
+ *
+ *   return () => app.unmount();
+ * });
+ * ```
+ *
+ * @example React
+ * ```ts
+ * import { initIslands } from '@ox-content/islands';
+ * import { createRoot } from 'react-dom/client';
+ * import Counter from './Counter';
+ *
+ * const components = { Counter };
+ *
+ * initIslands((el, props) => {
+ *   const name = el.dataset.oxIsland!;
+ *   const Component = components[name];
+ *   if (!Component) return;
+ *
+ *   const root = createRoot(el);
+ *   root.render(<Component {...props} />);
+ *
+ *   return () => root.unmount();
+ * });
+ * ```
+ *
+ * @example Vanilla JS
+ * ```ts
+ * import { initIslands } from '@ox-content/islands';
+ *
+ * initIslands((el, props) => {
+ *   const name = el.dataset.oxIsland!;
+ *
+ *   if (name === 'Counter') {
+ *     let count = props.initial || 0;
+ *     const button = el.querySelector('button')!;
+ *     const handler = () => {
+ *       count++;
+ *       button.textContent = String(count);
+ *     };
+ *     button.addEventListener('click', handler);
+ *     return () => button.removeEventListener('click', handler);
+ *   }
+ * });
+ * ```
+ */
+declare function initIslands(hydrate: HydrateFunction, options?: InitIslandsOptions): IslandController;
+/**
+ * Create a deferred hydration wrapper.
+ *
+ * Returns a function that can be called to hydrate islands later.
+ * Useful for frameworks that need to register components first.
+ *
+ * @example
+ * ```ts
+ * const deferredInit = createDeferredInit();
+ *
+ * // Later, after components are ready
+ * const components = await loadComponents();
+ * deferredInit((el, props) => {
+ *   const Component = components[el.dataset.oxIsland!];
+ *   // ...
+ * });
+ * ```
+ */
+declare function createDeferredInit(options?: InitIslandsOptions): (hydrate: HydrateFunction) => IslandController;
+/**
+ * Check if islands are supported in the current environment.
+ */
+declare function isIslandsSupported(): boolean;
+//# sourceMappingURL=runtime.d.ts.map
+//#endregion
+export { type ComponentRegistry, type HydrateFunction, type InitIslandsOptions, type IslandConfig, type IslandController, type IslandInstance, type LoadStrategy, createDeferredInit, initIslands, isIslandsSupported };
+//# sourceMappingURL=index-Bc2Aw38x.d.ts.map

package/dist/index-Bc2Aw38x.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Bc2Aw38x.d.ts","names":[],"sources":["../src/types.ts","../src/runtime.ts"],"sourcesContent":[],"mappings":";;AAcA;AAKA;;;;;AAmBA;;;;;AAQA;AAA6B,KAhCjB,YAAA,GAgCiB,OAAA,GAAA,MAAA,GAAA,SAAA,GAAA,OAAA;;;;AAKZ,UAhCA,YAAA,CAgCkB;EAAA;MAUN,MAAA;;WAEF,EAAA,MAAA;;MAEE,EAxCrB,YAwCqB;;YAA0C,CAAA,EAAA,MAAA;EAAK;EAM3D,KAAA,EA1CR,MA0CQ,CAAA,MAAc,EAAA,OAAA,CAAA;;;;;AAU/B;;;AAIqB,KA/CT,eAAA,GA+CS,CAAA,OAAA,EA9CV,WA8CU,EAAA,KAAA,EA7CZ,MA6CY,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,GAAA,IAAA,GAAA,CAAA,GAAA,GAAA,IAAA,CAAA;;;;KAvCT,iBAAA,GAAoB,YAAY;ACqI5C;;;AAEY,UDlIK,kBAAA,CCkIL;;EACO,UAAA,CAAA,EAAA,MAAA;EA2JH;EAAkB,SAAA,CAAA,EAAA,MAAA;;aAErB,CAAA,EAAA,MAAA;;EAAoC,QAAA,CAAA,EAAA,MAAA;EAOjC;6BD7Ra,qBAAqB;;2BAEvB,qBAAqB;;6BAEnB,qBAAqB,qBAAqB;;;;;UAMtD,cAAA;WACN;UACD;;;;;;;UAQO,gBAAA;;aAEJ;;qBAEQ;;;;;;;AA/CrB;;;;;AAQA;;;;;AAKA;;;;;;;;;;AAoBA;;;;;AAUA;;;;;;;;ACkGA;;;;;;AA8JA;;;;;;AASA;;;;;;;;;;;;;;;;;;;;;iBAvKgB,WAAA,UACL,2BACC,qBACT;;;;;;;;;;;;;;;;;;;iBA2Ja,kBAAA,WACJ,+BACC,oBAAoB;;;;iBAOjB,kBAAA,CAAA"}

package/dist/index.js

@@ -0,0 +1,261 @@
+//#region src/runtime.ts
+const defaultOptions = {
+	rootMargin: "200px",
+	threshold: 0,
+	idleTimeout: 200,
+	selector: "[data-ox-island]"
+};
+/**
+* Parse island configuration from element attributes.
+*/
+function parseIslandConfig(element) {
+	const component = element.dataset.oxIsland || "";
+	const load = element.dataset.oxLoad || "eager";
+	const mediaQuery = element.dataset.oxMedia;
+	let props = {};
+	try {
+		const propsJson = element.dataset.oxProps;
+		if (propsJson) props = JSON.parse(propsJson);
+	} catch (e) {
+		console.warn("[ox-islands] Failed to parse props for", element, e);
+	}
+	return {
+		id: element.id || `island-${Math.random().toString(36).slice(2, 9)}`,
+		component,
+		load,
+		mediaQuery,
+		props
+	};
+}
+/**
+* Observe element visibility using IntersectionObserver.
+*/
+function observeVisibility(element, callback, options) {
+	const observer = new IntersectionObserver((entries) => {
+		if (entries[0].isIntersecting) {
+			observer.disconnect();
+			callback();
+		}
+	}, {
+		rootMargin: options.rootMargin,
+		threshold: options.threshold
+	});
+	observer.observe(element);
+	return () => observer.disconnect();
+}
+/**
+* Observe media query changes.
+*/
+function observeMedia(query, callback) {
+	const mql = matchMedia(query);
+	if (mql.matches) {
+		callback();
+		return () => {};
+	}
+	const handler = () => {
+		if (mql.matches) {
+			mql.removeEventListener("change", handler);
+			callback();
+		}
+	};
+	mql.addEventListener("change", handler);
+	return () => mql.removeEventListener("change", handler);
+}
+/**
+* Schedule callback for browser idle time.
+*/
+function scheduleIdle(callback, timeout) {
+	if ("requestIdleCallback" in window) {
+		const id = requestIdleCallback(callback, { timeout });
+		return () => cancelIdleCallback(id);
+	}
+	const id = setTimeout(callback, timeout);
+	return () => clearTimeout(id);
+}
+/**
+* Initialize islands with a hydration function.
+*
+* This is the main entry point for the island system.
+* Pass a hydrate function that knows how to mount your components.
+*
+* @example Vue
+* ```ts
+* import { initIslands } from '@ox-content/islands';
+* import { createApp, h } from 'vue';
+* import Counter from './Counter.vue';
+*
+* const components = { Counter };
+*
+* initIslands((el, props) => {
+*   const name = el.dataset.oxIsland!;
+*   const Component = components[name];
+*   if (!Component) return;
+*
+*   const app = createApp({ render: () => h(Component, props) });
+*   app.mount(el);
+*
+*   return () => app.unmount();
+* });
+* ```
+*
+* @example React
+* ```ts
+* import { initIslands } from '@ox-content/islands';
+* import { createRoot } from 'react-dom/client';
+* import Counter from './Counter';
+*
+* const components = { Counter };
+*
+* initIslands((el, props) => {
+*   const name = el.dataset.oxIsland!;
+*   const Component = components[name];
+*   if (!Component) return;
+*
+*   const root = createRoot(el);
+*   root.render(<Component {...props} />);
+*
+*   return () => root.unmount();
+* });
+* ```
+*
+* @example Vanilla JS
+* ```ts
+* import { initIslands } from '@ox-content/islands';
+*
+* initIslands((el, props) => {
+*   const name = el.dataset.oxIsland!;
+*
+*   if (name === 'Counter') {
+*     let count = props.initial || 0;
+*     const button = el.querySelector('button')!;
+*     const handler = () => {
+*       count++;
+*       button.textContent = String(count);
+*     };
+*     button.addEventListener('click', handler);
+*     return () => button.removeEventListener('click', handler);
+*   }
+* });
+* ```
+*/
+function initIslands(hydrate, options) {
+	const opts = {
+		...defaultOptions,
+		...options
+	};
+	const instances = [];
+	const cleanups = [];
+	/**
+	* Hydrate a single island element.
+	*/
+	function hydrateIsland(element, config) {
+		const instance = instances.find((i) => i.element === element);
+		if (instance?.hydrated) return;
+		try {
+			opts.onHydrateStart?.(element, config);
+			element.classList.add("ox-island-loading");
+			const cleanup = hydrate(element, config.props);
+			element.dataset.oxHydrated = "true";
+			element.classList.remove("ox-island-loading");
+			if (instance) {
+				instance.cleanup = cleanup || void 0;
+				instance.hydrated = true;
+			} else instances.push({
+				element,
+				config,
+				cleanup: cleanup || void 0,
+				hydrated: true
+			});
+			opts.onHydrateEnd?.(element, config);
+		} catch (error) {
+			element.classList.remove("ox-island-loading");
+			element.classList.add("ox-island-error");
+			element.dataset.oxError = error instanceof Error ? error.message : String(error);
+			opts.onHydrateError?.(element, config, error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	/**
+	* Schedule hydration based on load strategy.
+	*/
+	function scheduleHydration(element, config) {
+		switch (config.load) {
+			case "eager":
+				hydrateIsland(element, config);
+				break;
+			case "idle": {
+				const cancel = scheduleIdle(() => hydrateIsland(element, config), opts.idleTimeout);
+				cleanups.push(cancel);
+				break;
+			}
+			case "visible": {
+				const cancel = observeVisibility(element, () => hydrateIsland(element, config), {
+					rootMargin: opts.rootMargin,
+					threshold: opts.threshold
+				});
+				cleanups.push(cancel);
+				break;
+			}
+			case "media":
+				if (config.mediaQuery) {
+					const cancel = observeMedia(config.mediaQuery, () => hydrateIsland(element, config));
+					cleanups.push(cancel);
+				} else hydrateIsland(element, config);
+				break;
+			default: hydrateIsland(element, config);
+		}
+	}
+	document.querySelectorAll(opts.selector).forEach((element) => {
+		const config = parseIslandConfig(element);
+		instances.push({
+			element,
+			config,
+			hydrated: false
+		});
+		scheduleHydration(element, config);
+	});
+	return {
+		instances,
+		hydrate(element) {
+			hydrateIsland(element, parseIslandConfig(element));
+		},
+		destroy() {
+			cleanups.forEach((cleanup) => cleanup());
+			cleanups.length = 0;
+			instances.forEach((instance) => {
+				if (instance.cleanup) instance.cleanup();
+			});
+			instances.length = 0;
+		}
+	};
+}
+/**
+* Create a deferred hydration wrapper.
+*
+* Returns a function that can be called to hydrate islands later.
+* Useful for frameworks that need to register components first.
+*
+* @example
+* ```ts
+* const deferredInit = createDeferredInit();
+*
+* // Later, after components are ready
+* const components = await loadComponents();
+* deferredInit((el, props) => {
+*   const Component = components[el.dataset.oxIsland!];
+*   // ...
+* });
+* ```
+*/
+function createDeferredInit(options) {
+	return (hydrate) => initIslands(hydrate, options);
+}
+/**
+* Check if islands are supported in the current environment.
+*/
+function isIslandsSupported() {
+	return typeof window !== "undefined" && typeof document !== "undefined" && typeof IntersectionObserver !== "undefined" && typeof MutationObserver !== "undefined";
+}
+
+//#endregion
+export { createDeferredInit, initIslands, isIslandsSupported };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/runtime.ts"],"sourcesContent":["/**\n * Island Architecture Runtime\n *\n * Framework-agnostic Island controller using pure Vanilla JavaScript.\n * No framework dependencies - works with Vue, React, Svelte, or plain JS.\n */\n\nimport type {\n  HydrateFunction,\n  InitIslandsOptions,\n  IslandConfig,\n  IslandInstance,\n  IslandController,\n  LoadStrategy,\n} from \"./types\";\n\nconst defaultOptions: Required<Omit<InitIslandsOptions, \"onHydrateStart\" | \"onHydrateEnd\" | \"onHydrateError\">> & InitIslandsOptions = {\n  rootMargin: \"200px\",\n  threshold: 0,\n  idleTimeout: 200,\n  selector: \"[data-ox-island]\",\n};\n\n/**\n * Parse island configuration from element attributes.\n */\nfunction parseIslandConfig(element: HTMLElement): IslandConfig {\n  const component = element.dataset.oxIsland || \"\";\n  const load = (element.dataset.oxLoad as LoadStrategy) || \"eager\";\n  const mediaQuery = element.dataset.oxMedia;\n\n  let props: Record<string, unknown> = {};\n  try {\n    const propsJson = element.dataset.oxProps;\n    if (propsJson) {\n      props = JSON.parse(propsJson);\n    }\n  } catch (e) {\n    console.warn(\"[ox-islands] Failed to parse props for\", element, e);\n  }\n\n  return {\n    id: element.id || `island-${Math.random().toString(36).slice(2, 9)}`,\n    component,\n    load,\n    mediaQuery,\n    props,\n  };\n}\n\n/**\n * Observe element visibility using IntersectionObserver.\n */\nfunction observeVisibility(\n  element: HTMLElement,\n  callback: () => void,\n  options: { rootMargin: string; threshold: number },\n): () => void {\n  const observer = new IntersectionObserver(\n    (entries) => {\n      if (entries[0].isIntersecting) {\n        observer.disconnect();\n        callback();\n      }\n    },\n    {\n      rootMargin: options.rootMargin,\n      threshold: options.threshold,\n    },\n  );\n\n  observer.observe(element);\n\n  return () => observer.disconnect();\n}\n\n/**\n * Observe media query changes.\n */\nfunction observeMedia(query: string, callback: () => void): () => void {\n  const mql = matchMedia(query);\n\n  if (mql.matches) {\n    callback();\n    return () => {};\n  }\n\n  const handler = () => {\n    if (mql.matches) {\n      mql.removeEventListener(\"change\", handler);\n      callback();\n    }\n  };\n\n  mql.addEventListener(\"change\", handler);\n\n  return () => mql.removeEventListener(\"change\", handler);\n}\n\n/**\n * Schedule callback for browser idle time.\n */\nfunction scheduleIdle(callback: () => void, timeout: number): () => void {\n  if (\"requestIdleCallback\" in window) {\n    const id = requestIdleCallback(callback, { timeout });\n    return () => cancelIdleCallback(id);\n  }\n\n  // Fallback for Safari and older browsers\n  const id = setTimeout(callback, timeout);\n  return () => clearTimeout(id);\n}\n\n/**\n * Initialize islands with a hydration function.\n *\n * This is the main entry point for the island system.\n * Pass a hydrate function that knows how to mount your components.\n *\n * @example Vue\n * ```ts\n * import { initIslands } from '@ox-content/islands';\n * import { createApp, h } from 'vue';\n * import Counter from './Counter.vue';\n *\n * const components = { Counter };\n *\n * initIslands((el, props) => {\n *   const name = el.dataset.oxIsland!;\n *   const Component = components[name];\n *   if (!Component) return;\n *\n *   const app = createApp({ render: () => h(Component, props) });\n *   app.mount(el);\n *\n *   return () => app.unmount();\n * });\n * ```\n *\n * @example React\n * ```ts\n * import { initIslands } from '@ox-content/islands';\n * import { createRoot } from 'react-dom/client';\n * import Counter from './Counter';\n *\n * const components = { Counter };\n *\n * initIslands((el, props) => {\n *   const name = el.dataset.oxIsland!;\n *   const Component = components[name];\n *   if (!Component) return;\n *\n *   const root = createRoot(el);\n *   root.render(<Component {...props} />);\n *\n *   return () => root.unmount();\n * });\n * ```\n *\n * @example Vanilla JS\n * ```ts\n * import { initIslands } from '@ox-content/islands';\n *\n * initIslands((el, props) => {\n *   const name = el.dataset.oxIsland!;\n *\n *   if (name === 'Counter') {\n *     let count = props.initial || 0;\n *     const button = el.querySelector('button')!;\n *     const handler = () => {\n *       count++;\n *       button.textContent = String(count);\n *     };\n *     button.addEventListener('click', handler);\n *     return () => button.removeEventListener('click', handler);\n *   }\n * });\n * ```\n */\nexport function initIslands(\n  hydrate: HydrateFunction,\n  options?: InitIslandsOptions,\n): IslandController {\n  const opts = { ...defaultOptions, ...options };\n  const instances: IslandInstance[] = [];\n  const cleanups: (() => void)[] = [];\n\n  /**\n   * Hydrate a single island element.\n   */\n  function hydrateIsland(element: HTMLElement, config: IslandConfig): void {\n    // Find existing instance\n    const instance = instances.find((i) => i.element === element);\n    if (instance?.hydrated) return;\n\n    try {\n      opts.onHydrateStart?.(element, config);\n\n      // Mark as loading\n      element.classList.add(\"ox-island-loading\");\n\n      // Call the hydrate function\n      const cleanup = hydrate(element, config.props);\n\n      // Mark as hydrated\n      element.dataset.oxHydrated = \"true\";\n      element.classList.remove(\"ox-island-loading\");\n\n      // Update instance\n      if (instance) {\n        instance.cleanup = cleanup || undefined;\n        instance.hydrated = true;\n      } else {\n        instances.push({\n          element,\n          config,\n          cleanup: cleanup || undefined,\n          hydrated: true,\n        });\n      }\n\n      opts.onHydrateEnd?.(element, config);\n    } catch (error) {\n      element.classList.remove(\"ox-island-loading\");\n      element.classList.add(\"ox-island-error\");\n      element.dataset.oxError = error instanceof Error ? error.message : String(error);\n\n      opts.onHydrateError?.(element, config, error instanceof Error ? error : new Error(String(error)));\n    }\n  }\n\n  /**\n   * Schedule hydration based on load strategy.\n   */\n  function scheduleHydration(element: HTMLElement, config: IslandConfig): void {\n    switch (config.load) {\n      case \"eager\":\n        hydrateIsland(element, config);\n        break;\n\n      case \"idle\": {\n        const cancel = scheduleIdle(\n          () => hydrateIsland(element, config),\n          opts.idleTimeout,\n        );\n        cleanups.push(cancel);\n        break;\n      }\n\n      case \"visible\": {\n        const cancel = observeVisibility(\n          element,\n          () => hydrateIsland(element, config),\n          { rootMargin: opts.rootMargin, threshold: opts.threshold },\n        );\n        cleanups.push(cancel);\n        break;\n      }\n\n      case \"media\": {\n        if (config.mediaQuery) {\n          const cancel = observeMedia(config.mediaQuery, () =>\n            hydrateIsland(element, config),\n          );\n          cleanups.push(cancel);\n        } else {\n          // No media query specified, fall back to eager\n          hydrateIsland(element, config);\n        }\n        break;\n      }\n\n      default:\n        hydrateIsland(element, config);\n    }\n  }\n\n  // Find and process all island elements\n  const elements = document.querySelectorAll<HTMLElement>(opts.selector);\n\n  elements.forEach((element) => {\n    const config = parseIslandConfig(element);\n\n    // Track instance\n    instances.push({\n      element,\n      config,\n      hydrated: false,\n    });\n\n    // Schedule hydration\n    scheduleHydration(element, config);\n  });\n\n  // Return controller\n  return {\n    instances,\n\n    hydrate(element: HTMLElement): void {\n      const config = parseIslandConfig(element);\n      hydrateIsland(element, config);\n    },\n\n    destroy(): void {\n      // Cancel pending hydrations\n      cleanups.forEach((cleanup) => cleanup());\n      cleanups.length = 0;\n\n      // Cleanup hydrated instances\n      instances.forEach((instance) => {\n        if (instance.cleanup) {\n          instance.cleanup();\n        }\n      });\n      instances.length = 0;\n    },\n  };\n}\n\n/**\n * Create a deferred hydration wrapper.\n *\n * Returns a function that can be called to hydrate islands later.\n * Useful for frameworks that need to register components first.\n *\n * @example\n * ```ts\n * const deferredInit = createDeferredInit();\n *\n * // Later, after components are ready\n * const components = await loadComponents();\n * deferredInit((el, props) => {\n *   const Component = components[el.dataset.oxIsland!];\n *   // ...\n * });\n * ```\n */\nexport function createDeferredInit(\n  options?: InitIslandsOptions,\n): (hydrate: HydrateFunction) => IslandController {\n  return (hydrate: HydrateFunction) => initIslands(hydrate, options);\n}\n\n/**\n * Check if islands are supported in the current environment.\n */\nexport function isIslandsSupported(): boolean {\n  return (\n    typeof window !== \"undefined\" &&\n    typeof document !== \"undefined\" &&\n    typeof IntersectionObserver !== \"undefined\" &&\n    typeof MutationObserver !== \"undefined\"\n  );\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@ox-content/islands",
+  "version": "0.3.0-alpha.11",
+  "description": "Framework-agnostic Island Architecture for ox-content",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./runtime": {
+      "import": "./dist/runtime.js",
+      "types": "./dist/runtime.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@typescript/native-preview": "^7.0.0-dev.20250601",
+    "tsdown": "^0.12.0",
+    "typescript": "^5.7.0"
+  },
+  "keywords": [
+    "islands",
+    "island-architecture",
+    "partial-hydration",
+    "ox-content",
+    "framework-agnostic"
+  ],
+  "license": "MIT",
+  "author": "ubugeeei",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ubugeeei/ox-content.git",
+    "directory": "npm/ox-content-islands"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsgo --noEmit"
+  }
+}