smart-glide-react 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,241 @@
+import React from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/** Named responsive presets available on the Laravel backend. */
+type ResponsivePreset = 'hero' | 'thumbnails' | 'square' | 'portrait' | 'hd' | 'fhd' | 'retina' | (string & {});
+/** Named image profiles available on the Laravel backend. */
+type ImageProfile = 'default' | 'thumbnail' | 'hero' | 'portrait' | 'square' | 'profile_photo' | 'cover' | 'background' | (string & {});
+/** Response shape returned by the `/img-data` API. */
+interface SmartGlideData {
+    src: string;
+    srcset?: string | null;
+    sizes?: string | null;
+    widths?: number[];
+    blurDataUrl?: string | null;
+    schema?: Record<string, unknown> | null;
+}
+/** Options passed to `useSmartGlide` and lower-level helpers. */
+interface SmartGlideOptions {
+    /** Relative path of the image (e.g. `"products/phone.jpg"`). */
+    path: string;
+    /**
+     * Base URL of your Laravel app (e.g. `"https://api.example.com"`).
+     * Defaults to the `NEXT_PUBLIC_SMART_GLIDE_URL` / `VITE_SMART_GLIDE_URL`
+     * environment variable when omitted.
+     */
+    baseUrl?: string;
+    /** Named or custom compression profile (default: `"default"`). */
+    profile?: ImageProfile;
+    /**
+     * Responsive breakpoints:
+     *  - `"hero"` — named preset
+     *  - `[640, 960, 1280]` — custom widths
+     *  - `false` — disable srcset
+     */
+    responsive?: ResponsivePreset | number[] | false;
+    /** Fetch the blurred Base64 LQIP from the server. Enables `blurDataUrl`. */
+    blurPlaceholder?: boolean;
+    /** Request JSON-LD `ImageObject` data from the server. */
+    schema?: boolean;
+    /** Extra Glide transformation params (w, h, fit, focus, q…). */
+    params?: Record<string, string | number>;
+    /**
+     * Additional fetch options forwarded to the underlying `fetch()` call.
+     * (e.g. `{ next: { revalidate: 3600 } }` for Next.js ISR)
+     */
+    fetchOptions?: RequestInit;
+}
+/** Props accepted by the `<SmartGlideImage>` component. */
+interface SmartGlideImageProps extends SmartGlideOptions {
+    /** Alt text — required for accessibility and SEO. */
+    alt: string;
+    /**
+     * Mark this image as a Largest Contentful Paint candidate.
+     * Sets `fetchpriority="high"` + `loading="eager"`.
+     */
+    priority?: boolean;
+    /**
+     * Show a blurred low-quality placeholder while the full image loads.
+     */
+    placeholder?: 'blur' | 'empty';
+    /** Inline aspect-ratio hint (e.g. `"16 / 9"`, `"1"`, `"4 / 3"`). */
+    aspectRatio?: string;
+    /** Width attribute for layout stability. */
+    width?: number;
+    /** Height attribute for layout stability. */
+    height?: number;
+    /** CSS class name. */
+    className?: string;
+    /** Inline styles. */
+    style?: React.CSSProperties;
+    /** Callback fired when the image fully loads. */
+    onLoad?: React.ReactEventHandler<HTMLImageElement>;
+    /** Callback fired on image error. */
+    onError?: React.ReactEventHandler<HTMLImageElement>;
+}
+
+/**
+ * A full-featured, SEO-optimised `<img>` component backed by Laravel Smart Glide.
+ *
+ * @example
+ * <SmartGlideImage
+ *   path="products/phone.jpg"
+ *   alt="Awesome Phone"
+ *   profile="hero"
+ *   responsive="retina"
+ * />
+ *
+ * @example
+ * <SmartGlideImage
+ *   path="home/hero.jpg"
+ *   alt="Hero banner"
+ *   profile="hero"
+ *   priority
+ *   placeholder="blur"
+ *   blurPlaceholder
+ *   schema
+ *   width={1600}
+ *   height={900}
+ * />
+ */
+declare const SmartGlideImage: React.ForwardRefExoticComponent<SmartGlideImageProps & React.RefAttributes<HTMLImageElement>>;
+interface SmartGlidePictureSource {
+    media?: string;
+    widths?: number[];
+    responsive?: string | number[];
+    params?: Record<string, string | number>;
+    type?: string;
+}
+interface SmartGlidePictureProps extends SmartGlideImageProps {
+    sources?: SmartGlidePictureSource[];
+}
+/**
+ * `<picture>` component with multiple `<source>` breakpoints
+ * plus a Smart Glide powered `<img>` fallback.
+ */
+declare const SmartGlidePicture: React.ForwardRefExoticComponent<SmartGlidePictureProps & React.RefAttributes<HTMLImageElement>>;
+interface SmartGlideBackgroundProps extends SmartGlideOptions {
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    'aria-label'?: string;
+}
+/**
+ * CSS background-image container backed by Smart Glide.
+ */
+declare const SmartGlideBackground: React.FC<SmartGlideBackgroundProps>;
+
+interface SmartGlideConfig {
+    /** Base URL of your Laravel application (e.g. `"https://api.example.com"`). */
+    baseUrl?: string;
+    /** Delivery path prefix (default: `"/img"`). */
+    deliveryPath?: string;
+    /** Data API path prefix (default: `"/img-data"`). */
+    dataPath?: string;
+    /** Default image profile to apply when none is specified. */
+    defaultProfile?: string;
+    /** Default responsive set name or widths. */
+    defaultResponsive?: string | number[];
+    /** Emit JSON-LD `ImageObject` by default for all images. */
+    defaultSchema?: boolean;
+}
+declare function useSmartGlideConfig(): SmartGlideConfig;
+interface SmartGlideProviderProps {
+    config: SmartGlideConfig;
+    children: React.ReactNode;
+}
+/**
+ * Wrap your application (or part of it) with `<SmartGlideProvider>` to
+ * configure Smart Glide globally. Individual components/hooks can still
+ * override any option locally.
+ *
+ * @example
+ * // app/layout.tsx  (Next.js App Router)
+ * import { SmartGlideProvider } from 'smart-glide-react';
+ *
+ * export default function RootLayout({ children }) {
+ *   return (
+ *     <SmartGlideProvider config={{ baseUrl: process.env.NEXT_PUBLIC_API_URL }}>
+ *       {children}
+ *     </SmartGlideProvider>
+ *   );
+ * }
+ */
+declare function SmartGlideProvider({ config, children }: SmartGlideProviderProps): react_jsx_runtime.JSX.Element;
+
+interface UseSmartGlideResult {
+    /** Final signed delivery URL (ready for `<img src>`). */
+    src: string;
+    /** Responsive srcset string. */
+    srcset: string | null;
+    /** Sizes attribute. */
+    sizes: string | null;
+    /** Base64 LQIP blur data URI for placeholder. */
+    blurDataUrl: string | null;
+    /** JSON-LD ImageObject schema data. */
+    schema: Record<string, unknown> | null;
+    /** True while fetching from the API. */
+    isLoading: boolean;
+    /** Error if the fetch failed. */
+    error: Error | null;
+    /** Manually re-fetch the data. */
+    refetch: () => void;
+}
+/**
+ * Fetch Smart Glide image data from the Laravel API.
+ *
+ * @example
+ * const { src, srcset, sizes, blurDataUrl } = useSmartGlide({
+ *   path: 'products/phone.jpg',
+ *   profile: 'hero',
+ *   responsive: 'retina',
+ *   blurPlaceholder: true,
+ *   baseUrl: process.env.NEXT_PUBLIC_API_URL,
+ * });
+ */
+declare function useSmartGlide(options: SmartGlideOptions): UseSmartGlideResult;
+interface UseSmartGlideStaticResult {
+    src: string;
+    srcset: string;
+    sizes: string;
+}
+/**
+ * Build image URLs entirely client-side — no API fetch required.
+ * Ideal for Next.js App Router with `generateStaticParams` or ISR.
+ *
+ * NOTE: URLs generated here are **unsigned**. Use this only in development
+ * or when `SMART_GLIDE_SECURE=false` on your Laravel backend.
+ * For signed URLs, use `useSmartGlide` or server-side data fetching.
+ */
+declare function useSmartGlideStatic(options: SmartGlideOptions): UseSmartGlideStaticResult;
+
+/** Resolve the base URL from options or environment variables. */
+declare function resolveBaseUrl(baseUrl?: string): string;
+/** Resolve the delivery path prefix (default: `/img`). */
+declare function resolveDeliveryPath(deliveryPath?: string): string;
+/** Resolve the data API path prefix (default: `/img-data`). */
+declare function resolveDataPath(dataPath?: string): string;
+/** Build a single Smart Glide delivery URL (unsigned — for preview/dev). */
+declare function buildDeliveryUrl(path: string, params?: Record<string, string | number>, options?: {
+    baseUrl?: string;
+    deliveryPath?: string;
+}): string;
+/** Build the JSON data API URL for a given path. */
+declare function buildDataUrl(path: string, options: SmartGlideOptions & {
+    deliveryPath?: string;
+    dataPath?: string;
+}): string;
+declare function resolveWidths(responsive?: string | number[] | false | null): number[];
+/**
+ * Build srcset and sizes strings entirely client-side
+ * (no API call — for use with Next.js custom loader or static generation).
+ */
+declare function buildSrcSet(path: string, params?: Record<string, string | number>, widths?: number[], options?: {
+    baseUrl?: string;
+    deliveryPath?: string;
+}): {
+    srcset: string;
+    sizes: string;
+};
+
+export { type ImageProfile, type ResponsivePreset, SmartGlideBackground, type SmartGlideBackgroundProps, type SmartGlideConfig, type SmartGlideData, SmartGlideImage, type SmartGlideImageProps, type SmartGlideOptions, SmartGlidePicture, type SmartGlidePictureProps, type SmartGlidePictureSource, SmartGlideProvider, type SmartGlideProviderProps, type UseSmartGlideResult, type UseSmartGlideStaticResult, buildDataUrl, buildDeliveryUrl, buildSrcSet, resolveBaseUrl, resolveDataPath, resolveDeliveryPath, resolveWidths, useSmartGlide, useSmartGlideConfig, useSmartGlideStatic };

package/dist/index.js

@@ -0,0 +1,436 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components.tsx
+
+// src/url-builder.ts
+function resolveBaseUrl(baseUrl) {
+  if (baseUrl) return baseUrl.replace(/\/$/, "");
+  if (typeof process !== "undefined") {
+    const env = process.env.NEXT_PUBLIC_SMART_GLIDE_URL ?? process.env.VITE_SMART_GLIDE_URL ?? process.env.SMART_GLIDE_URL ?? "";
+    if (env) return env.replace(/\/$/, "");
+  }
+  return "";
+}
+function resolveDeliveryPath(deliveryPath) {
+  if (deliveryPath) return "/" + deliveryPath.replace(/^\/|\/$/g, "");
+  if (typeof process !== "undefined") {
+    const env = process.env.NEXT_PUBLIC_SMART_GLIDE_DELIVERY_PATH ?? "/img";
+    return "/" + env.replace(/^\/|\/$/g, "");
+  }
+  return "/img";
+}
+function resolveDataPath(dataPath) {
+  if (dataPath) return "/" + dataPath.replace(/^\/|\/$/g, "");
+  if (typeof process !== "undefined") {
+    const env = process.env.NEXT_PUBLIC_SMART_GLIDE_DATA_PATH ?? "/img-data";
+    return "/" + env.replace(/^\/|\/$/g, "");
+  }
+  return "/img-data";
+}
+function buildDeliveryUrl(path, params = {}, options = {}) {
+  const base = resolveBaseUrl(options.baseUrl);
+  const prefix = resolveDeliveryPath(options.deliveryPath);
+  const cleanPath = path.replace(/^\//, "");
+  const queryParams = Object.entries(params).filter(([, v]) => v !== void 0 && v !== "").map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+  return `${base}${prefix}/${cleanPath}${queryParams ? "?" + queryParams : ""}`;
+}
+function buildDataUrl(path, options) {
+  const base = resolveBaseUrl(options.baseUrl);
+  const prefix = resolveDataPath(options.dataPath);
+  const cleanPath = path.replace(/^\//, "");
+  const params = {};
+  if (options.profile) params.profile = options.profile;
+  if (options.blurPlaceholder) params.blur_placeholder = "1";
+  if (options.schema) params.schema = "1";
+  if (options.responsive === false) {
+    params.responsive = "0";
+  } else if (Array.isArray(options.responsive)) {
+    params.responsive = options.responsive.join(",");
+  } else if (options.responsive) {
+    params.responsive = options.responsive;
+  }
+  if (options.params) {
+    Object.entries(options.params).forEach(([k, v]) => {
+      params[k] = String(v);
+    });
+  }
+  const query = new URLSearchParams(params).toString();
+  return `${base}${prefix}/${cleanPath}${query ? "?" + query : ""}`;
+}
+var NAMED_SETS = {
+  hero: [640, 960, 1280, 1600, 1920],
+  thumbnails: [240, 320, 480],
+  square: [320, 480, 640],
+  portrait: [480, 768, 1024],
+  hd: [960, 1280, 1600],
+  fhd: [1280, 1600, 1920, 2560],
+  retina: [640, 960, 1280, 1920, 2560]
+};
+function resolveWidths(responsive) {
+  if (responsive === false) return [];
+  if (responsive === null || responsive === void 0) {
+    return NAMED_SETS.retina;
+  }
+  if (Array.isArray(responsive)) return responsive;
+  return NAMED_SETS[responsive] ?? NAMED_SETS.retina;
+}
+function buildSrcSet(path, params = {}, widths = NAMED_SETS.retina, options = {}) {
+  const entries = widths.map(
+    (w) => `${buildDeliveryUrl(path, { ...params, w }, options)} ${w}w`
+  );
+  const sizes = widths.map((w) => `(max-width: ${w}px) 100vw`).concat("100vw").join(", ");
+  return {
+    srcset: entries.join(", "),
+    sizes
+  };
+}
+
+// src/hooks.ts
+function useSmartGlide(options) {
+  const {
+    path,
+    baseUrl,
+    profile,
+    responsive,
+    blurPlaceholder,
+    schema,
+    params,
+    fetchOptions
+  } = options;
+  const [data, setData] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const fetchCounter = react.useRef(0);
+  const fetchData = react.useCallback(async () => {
+    const id = ++fetchCounter.current;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const url = buildDataUrl(path, { path, baseUrl, profile, responsive, blurPlaceholder, schema, params });
+      const response = await fetch(url, {
+        headers: { Accept: "application/json" },
+        ...fetchOptions
+      });
+      if (!response.ok) {
+        throw new Error(`Smart Glide API error: ${response.status} ${response.statusText}`);
+      }
+      const json = await response.json();
+      if (id === fetchCounter.current) {
+        setData(json);
+      }
+    } catch (err) {
+      if (id === fetchCounter.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (id === fetchCounter.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [path, baseUrl, profile, JSON.stringify(responsive), blurPlaceholder, schema, JSON.stringify(params)]);
+  react.useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  return {
+    src: data?.src ?? buildDeliveryUrl(path, params ?? {}, { baseUrl }),
+    srcset: data?.srcset ?? null,
+    sizes: data?.sizes ?? null,
+    blurDataUrl: data?.blurDataUrl ?? null,
+    schema: data?.schema ?? null,
+    isLoading,
+    error,
+    refetch: fetchData
+  };
+}
+function useSmartGlideStatic(options) {
+  const { path, baseUrl, profile, responsive, params } = options;
+  const glideParams = { ...params };
+  if (profile) glideParams.profile = profile;
+  const widths = resolveWidths(responsive);
+  const { srcset, sizes } = buildSrcSet(path, glideParams, widths, { baseUrl });
+  const src = buildDeliveryUrl(path, glideParams, { baseUrl });
+  return { src, srcset, sizes };
+}
+var BlurOverlay = ({ blurDataUrl, isVisible }) => /* @__PURE__ */ jsxRuntime.jsx(
+  "span",
+  {
+    "aria-hidden": "true",
+    style: {
+      position: "absolute",
+      inset: 0,
+      backgroundImage: `url(${blurDataUrl})`,
+      backgroundSize: "cover",
+      backgroundPosition: "center",
+      filter: "blur(20px)",
+      transform: "scale(1.05)",
+      transition: "opacity 0.4s ease",
+      opacity: isVisible ? 1 : 0,
+      pointerEvents: "none"
+    }
+  }
+);
+var SchemaScript = ({ schema }) => /* @__PURE__ */ jsxRuntime.jsx(
+  "script",
+  {
+    type: "application/ld+json",
+    dangerouslySetInnerHTML: { __html: JSON.stringify(schema) }
+  }
+);
+var SmartGlideImage = react.forwardRef(
+  function SmartGlideImage2(props, ref) {
+    const {
+      path,
+      baseUrl,
+      profile,
+      responsive,
+      blurPlaceholder: fetchBlur = false,
+      schema: emitSchema = false,
+      params,
+      fetchOptions,
+      priority = false,
+      placeholder = "empty",
+      aspectRatio,
+      alt,
+      width,
+      height,
+      className,
+      style,
+      onLoad,
+      onError
+    } = props;
+    const shouldFetchBlur = placeholder === "blur" || fetchBlur;
+    const { src, srcset, sizes, blurDataUrl, schema } = useSmartGlide({
+      path,
+      baseUrl,
+      profile,
+      responsive,
+      blurPlaceholder: shouldFetchBlur,
+      schema: emitSchema,
+      params,
+      fetchOptions
+    });
+    const [imgLoaded, setImgLoaded] = react.useState(false);
+    const showBlur = shouldFetchBlur && !!blurDataUrl && !imgLoaded;
+    const handleLoad = react.useCallback(
+      (e) => {
+        setImgLoaded(true);
+        onLoad?.(e);
+      },
+      [onLoad]
+    );
+    const handleError = react.useCallback(
+      (e) => {
+        setImgLoaded(true);
+        onError?.(e);
+      },
+      [onError]
+    );
+    const composedStyle = {
+      ...style,
+      ...aspectRatio ? { aspectRatio } : {}
+    };
+    if (shouldFetchBlur && blurDataUrl) {
+      return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "span",
+          {
+            style: {
+              position: "relative",
+              display: "inline-block",
+              overflow: "hidden",
+              width: width ? `${width}px` : void 0,
+              height: height ? `${height}px` : void 0,
+              aspectRatio
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(BlurOverlay, { blurDataUrl, isVisible: showBlur }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "img",
+                {
+                  ref,
+                  src,
+                  srcSet: srcset ?? void 0,
+                  sizes: sizes ?? void 0,
+                  alt,
+                  width,
+                  height,
+                  className,
+                  style: { ...composedStyle, display: "block", width: "100%", height: "100%", objectFit: "cover" },
+                  loading: priority ? "eager" : "lazy",
+                  fetchPriority: priority ? "high" : "auto",
+                  decoding: "async",
+                  onLoad: handleLoad,
+                  onError: handleError
+                }
+              )
+            ]
+          }
+        ),
+        schema && /* @__PURE__ */ jsxRuntime.jsx(SchemaScript, { schema })
+      ] });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "img",
+        {
+          ref,
+          src,
+          srcSet: srcset ?? void 0,
+          sizes: sizes ?? void 0,
+          alt,
+          width,
+          height,
+          className,
+          style: composedStyle,
+          loading: priority ? "eager" : "lazy",
+          fetchPriority: priority ? "high" : "auto",
+          decoding: "async",
+          onLoad,
+          onError
+        }
+      ),
+      emitSchema && schema && /* @__PURE__ */ jsxRuntime.jsx(SchemaScript, { schema })
+    ] });
+  }
+);
+SmartGlideImage.displayName = "SmartGlideImage";
+var SmartGlidePicture = react.forwardRef(
+  function SmartGlidePicture2(props, ref) {
+    const {
+      sources = [],
+      path,
+      baseUrl,
+      params,
+      alt,
+      profile,
+      blurPlaceholder,
+      schema,
+      fetchOptions,
+      priority,
+      placeholder,
+      aspectRatio,
+      width,
+      height,
+      className,
+      style,
+      onLoad,
+      onError
+    } = props;
+    return /* @__PURE__ */ jsxRuntime.jsxs("picture", { children: [
+      sources.map((source, i) => {
+        const widths = source.widths ?? resolveWidths(source.responsive);
+        const mergedParams = { ...params ?? {}, ...source.params ?? {} };
+        const { srcset } = buildSrcSet(path, mergedParams, widths, { baseUrl });
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          "source",
+          {
+            media: source.media,
+            srcSet: srcset,
+            type: source.type
+          },
+          i
+        );
+      }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        SmartGlideImage,
+        {
+          ref,
+          path,
+          baseUrl,
+          params,
+          alt,
+          profile,
+          blurPlaceholder,
+          schema,
+          fetchOptions,
+          priority,
+          placeholder,
+          aspectRatio,
+          width,
+          height,
+          className,
+          style,
+          onLoad,
+          onError
+        }
+      )
+    ] });
+  }
+);
+SmartGlidePicture.displayName = "SmartGlidePicture";
+var SmartGlideBackground = ({
+  path,
+  baseUrl,
+  profile,
+  responsive,
+  params,
+  blurPlaceholder: fetchBlur,
+  children,
+  className,
+  style,
+  "aria-label": ariaLabel
+}) => {
+  const glideParams = { ...params ?? {} };
+  if (profile) glideParams.profile = profile;
+  const widths = resolveWidths(responsive);
+  const primaryWidth = widths[widths.length - 1] ?? 1920;
+  const primarySrc = buildDeliveryUrl(path, { ...glideParams, w: primaryWidth }, { baseUrl });
+  const { blurDataUrl } = useSmartGlide({
+    path,
+    baseUrl,
+    profile,
+    responsive,
+    blurPlaceholder: !!fetchBlur,
+    params
+  });
+  const mediaStyles = widths.slice().reverse().map((w) => {
+    const url = buildDeliveryUrl(path, { ...glideParams, w }, { baseUrl });
+    return `@media (max-width: ${w}px) { .sg-bg-${w} { background-image: url('${url}'); } }`;
+  }).join("\n");
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    mediaStyles && /* @__PURE__ */ jsxRuntime.jsx("style", { dangerouslySetInnerHTML: { __html: mediaStyles } }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        role: "img",
+        "aria-label": ariaLabel,
+        className,
+        style: {
+          backgroundImage: blurDataUrl ? `url('${primarySrc}'), url('${blurDataUrl}')` : `url('${primarySrc}')`,
+          backgroundSize: "cover",
+          backgroundPosition: "center",
+          backgroundRepeat: "no-repeat",
+          ...style
+        },
+        children
+      }
+    )
+  ] });
+};
+var SmartGlideContext = react.createContext({});
+function useSmartGlideConfig() {
+  return react.useContext(SmartGlideContext);
+}
+function SmartGlideProvider({ config, children }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(SmartGlideContext.Provider, { value: config, children });
+}
+
+exports.SmartGlideBackground = SmartGlideBackground;
+exports.SmartGlideImage = SmartGlideImage;
+exports.SmartGlidePicture = SmartGlidePicture;
+exports.SmartGlideProvider = SmartGlideProvider;
+exports.buildDataUrl = buildDataUrl;
+exports.buildDeliveryUrl = buildDeliveryUrl;
+exports.buildSrcSet = buildSrcSet;
+exports.resolveBaseUrl = resolveBaseUrl;
+exports.resolveDataPath = resolveDataPath;
+exports.resolveDeliveryPath = resolveDeliveryPath;
+exports.resolveWidths = resolveWidths;
+exports.useSmartGlide = useSmartGlide;
+exports.useSmartGlideConfig = useSmartGlideConfig;
+exports.useSmartGlideStatic = useSmartGlideStatic;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map