Skip to content

🐸 Rybbit - open-source and privacy-friendly alternative to Google Analytics that is 10x more intuitive.

10.4 KB
Raw Blame
import { Filter, FilterParameter, TimeBucket } from "@rybbit/shared";
import { DateTime } from "luxon";
import { create } from "zustand";
import { persist } from "zustand/middleware";
import { Comparison, DEFAULT_COMPARISON, Time } from "../components/DateSelector/types";
import { LITE_DASHBOARD } from "./const";
import { getDashboardTimeForRange, getStoredDashboardDefaultTime } from "./defaultTimeRange";
import {
  canGoForward as canGoForwardFrom,
  getBucketForTime,
  hasRangeTimes,
  recalculateTimeForTimezone,
  resolveComparison,
  shiftTimeBackward,
  shiftTimeForward,
} from "./time";

// The lite dashboard is backed by hourly materialized views, so anything finer
// than an hour has no underlying data. Clamp auto-selected buckets up to "hour".
const SUB_HOUR_BUCKETS: TimeBucket[] = ["minute", "five_minutes", "ten_minutes", "fifteen_minutes"];
const clampBucketForLite = (bucket: TimeBucket): TimeBucket =>
  LITE_DASHBOARD && SUB_HOUR_BUCKETS.includes(bucket) ? "hour" : bucket;

// Get system timezone
const getSystemTimezone = () =>
  typeof window !== "undefined" ? Intl.DateTimeFormat().resolvedOptions().timeZone : "UTC";

export type StatType = "pageviews" | "sessions" | "users" | "pages_per_session" | "bounce_rate" | "session_duration";

const getTimeState = (
  time: Time,
  comparison: Comparison = DEFAULT_COMPARISON
): Pick<Store, "time" | "previousTime" | "bucket" | "comparison"> => {
  // Resolve the zone lazily: this runs during store creation (before useStore
  // exists), and only range-with-times values actually need the zone.
  const zone = hasRangeTimes(time) ? getTimezone() : "UTC";
  return {
    time,
    comparison,
    previousTime: resolveComparison(time, comparison, zone),
    bucket: clampBucketForLite(getBucketForTime(time, zone)),
  };
};

type Store = {
  site: string;
  setSite: (site: string) => void;
  privateKey: string | null;
  setPrivateKey: (privateKey: string | null) => void;
  setSiteContext: (site: string, privateKey: string | null) => void;
  time: Time;
  /** The window the comparison line is drawn from; null when comparison is off. */
  previousTime: Time | null;
  setTime: (time: Time, changeBucket?: boolean) => void;
  comparison: Comparison;
  setComparison: (comparison: Comparison) => void;
  bucket: TimeBucket;
  setBucket: (bucket: TimeBucket) => void;
  selectedStat: StatType;
  setSelectedStat: (stat: StatType) => void;
  filters: Filter[];
  setFilters: (filters: Filter[]) => void;
  /** The saved segment whose filters are part of `filters`; null when none is applied. */
  segmentId: number | null;
  setSegmentId: (segmentId: number | null) => void;
  timezone: string;
  setTimezone: (timezone: string) => void;
};

type PersistedStore = Pick<Store, "timezone">;

const getUrlParams = () => (typeof window !== "undefined" ? new URLSearchParams(globalThis.location.search) : null);

// Presets resolve in the selected timezone: "Today" is a different calendar day
// in Los Angeles than in a Tokyo browser for part of every day.
const getDefaultTime = (): Time => getStoredDashboardDefaultTime(getTimezone());

const getDefaultTimeState = () => getTimeState(getDefaultTime());

// The store is created during both server rendering and the browser's first
// render. Keep that initial state independent of localStorage so React hydrates
// the same markup; client-side URL/default-range initialization runs afterward.
const getInitialTimeState = () => getTimeState(getDashboardTimeForRange("today", "UTC"));

const getSiteStateForUrl = (state: Store, site: string, privateKey?: string | null): Partial<Store> => {
  const urlParams = getUrlParams();
  const hasTimeInUrl = urlParams?.has("timeMode") || urlParams?.has("wellKnown");
  const hasBucketInUrl = urlParams?.has("bucket");
  const hasStatInUrl = urlParams?.has("stat");
  const hasFiltersInUrl = urlParams?.has("filters");
  const hasSegmentInUrl = urlParams?.has("segment");
  const defaultTimeState = getDefaultTimeState();

  return {
    site,
    ...(privateKey !== undefined ? { privateKey } : {}),
    time: hasTimeInUrl ? state.time : defaultTimeState.time,
    previousTime: hasTimeInUrl ? state.previousTime : defaultTimeState.previousTime,
    comparison: hasTimeInUrl ? state.comparison : defaultTimeState.comparison,
    bucket: hasBucketInUrl ? state.bucket : defaultTimeState.bucket,
    selectedStat: hasStatInUrl ? state.selectedStat : "users",
    filters: hasFiltersInUrl ? state.filters : [],
    segmentId: hasSegmentInUrl ? state.segmentId : null,
  };
};

export const useStore = create<Store, [["zustand/persist", PersistedStore]]>(
  persist<Store, [], [], PersistedStore>(
    (set, get) => ({
      site: "",
      setSite: site => {
        set(state => getSiteStateForUrl(state, site));
      },
      privateKey: null,
      setPrivateKey: privateKey => set({ privateKey }),
      setSiteContext: (site, privateKey) => {
        set(state => getSiteStateForUrl(state, site, privateKey));
      },
      ...getInitialTimeState(),
      setTime: (time, changeBucket = true) => {
        const nextTimeState = getTimeState(time, get().comparison);

        if (changeBucket) {
          set(nextTimeState);
        } else {
          set({ time, previousTime: nextTimeState.previousTime });
        }
      },
      // A comparison is stored as the choice, not as the window it resolves to,
      // so stepping the date selector carries it along instead of stranding the
      // dashboard on the period it was picked in.
      setComparison: comparison => set(getTimeState(get().time, comparison)),
      setBucket: bucket => set({ bucket }),
      selectedStat: "users",
      setSelectedStat: stat => set({ selectedStat: stat }),
      filters: [],
      setFilters: filters => set({ filters }),
      segmentId: null,
      setSegmentId: segmentId => set({ segmentId }),
      timezone: "system",
      setTimezone: newTimezone => {
        const state = get();
        const resolvedTz = newTimezone === "system" ? getSystemTimezone() : newTimezone;
        const newTime = recalculateTimeForTimezone(state.time, resolvedTz);

        // If time should be recalculated (has wellKnown), update via setTime
        if (newTime) {
          set({ timezone: newTimezone });
          // Use setTime to properly recalculate previousTime and bucket
          get().setTime(newTime);
        } else {
          set({ timezone: newTimezone });
        }
      },
    }),
    {
      name: "rybbit-store",
      partialize: state => ({ timezone: state.timezone }),
    }
  )
);

// Helper to get actual timezone value (resolves "system" to actual timezone)
export const getTimezone = () => {
  const { timezone } = useStore.getState();
  return timezone === "system" ? getSystemTimezone() : timezone;
};

// Reactive form of getTimezone: re-renders when the user switches timezone.
export const useTimezone = () => {
  const timezone = useStore(state => state.timezone);
  return timezone === "system" ? getSystemTimezone() : timezone;
};

// Whether a comparison window exists at all — false only when the user has
// turned the comparison off, which is what hides every delta and dotted line.
export const useComparisonEnabled = () => useStore(state => state.previousTime !== null);

// Helper to convert a DateTime to the user's selected timezone
export const toUserTimezone = (dt: DateTime): DateTime => {
  return dt.setZone(getTimezone());
};

export const resetStore = () => {
  const { setSite, setPrivateKey, setTime, setSelectedStat, setFilters, setSegmentId, setComparison } =
    useStore.getState();
  setSite("");
  setPrivateKey(null);
  setComparison(DEFAULT_COMPARISON);
  setTime(getDefaultTime());
  setSelectedStat("users");
  setFilters([]);
  setSegmentId(null);
};

export const goBack = () => {
  const { time, setTime } = useStore.getState();
  const next = shiftTimeBackward(time, getTimezone());
  if (next) {
    setTime(next, false);
  }
};

export const goForward = () => {
  const { time, setTime } = useStore.getState();
  const next = shiftTimeForward(time, getTimezone());
  if (next) {
    // Historical quirk kept as-is: forward day steps recalculate the bucket,
    // every other mode keeps the current one (matching goBack).
    setTime(next, next.mode === "day");
  }
};

export const addFilter = (filter: Filter) => {
  const { filters, setFilters } = useStore.getState();
  const filterExists = filters.findIndex(
    f => f.parameter === filter.parameter && f.type === filter.type
    // JSON.stringify(f.value) === JSON.stringify(filter.value)
  );
  if (filterExists === -1) {
    setFilters([...filters, filter]);
  } else {
    setFilters(filters.map((f, i) => (i === filterExists ? filter : f)));
  }
};

export const removeFilter = (filter: Filter) => {
  const { filters, setFilters } = useStore.getState();
  setFilters(filters.filter(f => f !== filter));
};

export const updateFilter = (filter: Filter, index: number) => {
  const { filters, setFilters } = useStore.getState();
  setFilters(filters.map((f, i) => (i === index ? filter : f)));
};

const filterKey = (filter: Filter) => JSON.stringify([filter.parameter, filter.type, filter.value]);

/**
 * Applies a saved segment: its filters go first, ad-hoc filters that are not
 * already part of it follow, and the filters of the segment being replaced
 * (if any) are dropped. Every report keeps reading `filters`, so nothing
 * else in the dashboard learns what a segment is.
 */
export const applySegment = (
  segment: { segmentId: number; filters: Filter[] },
  replacing: Filter[] = []
) => {
  const { filters, setFilters, setSegmentId } = useStore.getState();
  const dropped = new Set(replacing.map(filterKey));
  const segmentKeys = new Set(segment.filters.map(filterKey));
  const adHoc = filters.filter(f => !dropped.has(filterKey(f)) && !segmentKeys.has(filterKey(f)));
  setFilters([...segment.filters, ...adHoc]);
  setSegmentId(segment.segmentId);
};

/** Removes an applied segment and the filters it contributed; ad-hoc filters stay. */
export const clearSegment = (segmentFilters: Filter[]) => {
  const { filters, setFilters, setSegmentId } = useStore.getState();
  const segmentKeys = new Set(segmentFilters.map(filterKey));
  setFilters(filters.filter(f => !segmentKeys.has(filterKey(f))));
  setSegmentId(null);
};

export const getFilteredFilters = (parameters: FilterParameter[]) => {
  const { filters } = useStore.getState();
  return filters.filter(f => parameters.includes(f.parameter));
};

export const canGoForward = (time: Time) => canGoForwardFrom(time, getTimezone());

export const canGoBack = (time: Time) => shiftTimeBackward(time, getTimezone()) !== null;