Rorkで作る引き寄せ・運勢系アプリ — 3日で離脱される日課アプリを立て直す日替わり配信設計

// src/lib/dailyFortune.ts
// 日付ベースで決定論的に運勢を返す擬似乱数
 
/**
 * Mulberry32: 軽量な決定論的擬似乱数
 * 同じシードからは同じシーケンスが返る性質を利用する
 */
function mulberry32(seed: number): () => number {
  return function () {
    seed |= 0;
    seed = (seed + 0x6d2b79f5) | 0;
    let t = seed;
    t = Math.imul(t ^ (t >>> 15), t | 1);
    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}
 
/**
 * 文字列を32bit整数のハッシュに変換する (FNV-1a)
 * userId と日付文字列をシードに変換するために使う
 */
function hash32(input: string): number {
  let h = 0x811c9dc5;
  for (let i = 0; i < input.length; i++) {
    h ^= input.charCodeAt(i);
    h = Math.imul(h, 0x01000193);
  }
  return h >>> 0;
}
 
export type FortuneResult = {
  date: string;        // "2026-05-11"
  rank: number;        // 1-12 (1が大吉、12が凶)
  rankLabel: string;   // "大吉" など
  themeId: string;     // テーマ別の固有ID（恋愛・仕事・健康など）
  message: string;     // メッセージ本文
};
 
const RANK_LABELS = [
  "大吉", "中吉", "吉", "小吉", "末吉", "半吉",
  "平", "末小吉", "下吉", "小凶", "末凶", "凶",
] as const;
 
export function generateDailyFortune(
  userId: string,
  dateISO: string, // "2026-05-11"
  messages: { themeId: string; rankMin: number; rankMax: number; body: string }[],
): FortuneResult {
  const seed = hash32(`${userId}:${dateISO}`);
  const rand = mulberry32(seed);
 
  // 12段階の運勢ランク（重み付きで「大吉」「凶」を出にくくする）
  const rankRoll = rand();
  let rank = 7;
  if (rankRoll < 0.05) rank = 1;
  else if (rankRoll < 0.20) rank = 2;
  else if (rankRoll < 0.55) rank = Math.floor(rand() * 4) + 3; // 3-6
  else if (rankRoll < 0.85) rank = Math.floor(rand() * 4) + 6; // 6-9
  else if (rankRoll < 0.97) rank = Math.floor(rand() * 2) + 9; // 9-10
  else rank = 12;
 
  // ランクに合うメッセージ群から1件選ぶ
  const candidates = messages.filter(
    (m) => rank >= m.rankMin && rank <= m.rankMax,
  );
  const picked = candidates[Math.floor(rand() * candidates.length)] ?? messages[0];
 
  return {
    date: dateISO,
    rank,
    rankLabel: RANK_LABELS[rank - 1] ?? "吉",
    themeId: picked.themeId,
    message: picked.body,
  };
}

// src/lib/dateInUserTimezone.ts
// ユーザーのローカルタイムゾーンで「今日」を返す
 
export function todayInUserTimezone(now: Date = new Date()): string {
  // Intl.DateTimeFormat を使ってローカルタイムゾーンでフォーマット
  const fmt = new Intl.DateTimeFormat("en-CA", {
    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
    year: "numeric",
    month: "2-digit",
    day: "2-digit",
  });
  // "2026-05-11" 形式（en-CA は YYYY-MM-DD 区切り）
  return fmt.format(now);
}

// src/lib/dailyFortuneBag.ts
// 周期内は重複しない日替わり配信（決定論・オフライン・履歴の保存なし）
// mulberry32 / hash32 / RANK_LABELS は dailyFortune.ts から再利用します
 
const RANK_WEIGHTS = [3, 7, 10, 11, 12, 12, 13, 11, 9, 6, 4, 2]; // 合計 100
const RANK_TO_BAND = [0, 0, 0, 1, 1, 1, 2, 2, 3, 3, 3, 3] as const; // rank 1-12 → 帯
 
/** 0-1 の乱数から 1-12 のランクを決める（境目で二重に供給しない） */
function pickRank(r: number): number {
  let acc = 0;
  for (let i = 0; i < RANK_WEIGHTS.length; i++) {
    acc += RANK_WEIGHTS[i] / 100;
    if (r < acc) return i + 1;
  }
  return RANK_WEIGHTS.length;
}
 
/** シード付き Fisher-Yates。同じシードからは必ず同じ並びが返る */
function shuffleWithSeed<T>(pool: readonly T[], seed: number): T[] {
  const a = pool.slice();
  const rand = mulberry32(seed);
  for (let i = a.length - 1; i > 0; i--) {
    const j = Math.floor(rand() * (i + 1));
    [a[i], a[j]] = [a[j], a[i]];
  }
  return a;
}
 
const EPOCH_UTC = Date.UTC(2026, 0, 1);
 
/** ローカル日付 "YYYY-MM-DD" を通し番号に直す */
function dayIndex(dateISO: string): number {
  const [y, m, d] = dateISO.split("-").map(Number);
  return Math.round((Date.UTC(y, m - 1, d) - EPOCH_UTC) / 86400000);
}
 
type BagMessage = { themeId: string; band: 0 | 1 | 2 | 3; body: string };
 
export function generateDailyFortuneV2(
  userId: string,
  dateISO: string, // todayInUserTimezone() の戻り値をそのまま渡す
  messages: readonly BagMessage[],
): FortuneResult {
  const day = dayIndex(dateISO);
 
  // ランクと文言でシードを分ける（片方を変えてももう片方がずれない）
  const rank = pickRank(mulberry32(hash32(`${userId}:rank:${day}`))());
  const band = RANK_TO_BAND[rank - 1];
 
  const pool = messages.filter((m) => m.band === band);
  if (pool.length === 0) throw new Error(`band ${band} のメッセージが空です`);
 
  const cycle = Math.floor(day / pool.length);
  // EPOCH より前の日付でも負にならないように剰余を正規化します
  const position = ((day % pool.length) + pool.length) % pool.length;
 
  const bag = shuffleWithSeed(pool, hash32(`${userId}:bag:${band}:${cycle}`));
  const picked = bag[position];
 
  return {
    date: dateISO,
    rank,
    rankLabel: RANK_LABELS[rank - 1] ?? "吉",
    themeId: picked.themeId,
    message: picked.body,
  };
}

// src/lib/scheduleDailyNotification.ts
// expo-notifications を使った日次のローカル通知スケジュール
 
import * as Notifications from "expo-notifications";
 
type DailyNotificationConfig = {
  hour: number;   // 0-23
  minute: number; // 0-59
  title: string;
  body: string;
  identifier: string;
};
 
/**
 * 既存のスケジュールを破棄して、新しい日次通知を登録する
 * 「毎日 hour:minute」に通知が届く
 */
export async function scheduleDailyNotification(
  config: DailyNotificationConfig,
): Promise<void> {
  // 権限確認
  const { status } = await Notifications.getPermissionsAsync();
  if (status !== "granted") {
    const req = await Notifications.requestPermissionsAsync();
    if (req.status !== "granted") {
      console.warn("通知権限が得られませんでした");
      return;
    }
  }
 
  // 既存の同一識別子スケジュールを破棄
  await Notifications.cancelScheduledNotificationAsync(config.identifier);
 
  // 新しい日次トリガーを登録
  await Notifications.scheduleNotificationAsync({
    identifier: config.identifier,
    content: {
      title: config.title,
      body: config.body,
      sound: "default",
    },
    trigger: {
      hour: config.hour,
      minute: config.minute,
      repeats: true,
    },
  });
}
 
// 利用例: 朝7:15に「今日の運勢が届きました」通知
// await scheduleDailyNotification({
//   hour: 7,
//   minute: 15,
//   title: "今日の運勢が届きました",
//   body: "今日のあなたへのメッセージを開いてみてください",
//   identifier: "morning-fortune",
// });

// src/lib/rearmDailyNotifications.ts
// 14日分のローリングウィンドウで日替わり文言の通知を積み直す
 
import * as Notifications from "expo-notifications";
 
const WINDOW_DAYS = 14;
const PREFIX = "daily-fortune-";
const FALLBACK_ID = "daily-fortune-fallback";
 
type Copy = { title: string; body: string };
 
/** ローカル時刻ベースで "YYYY-MM-DD" を作る（UTC 基準にしない） */
function localISO(d: Date): string {
  const p = (n: number) => String(n).padStart(2, "0");
  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
}
 
export async function rearmDailyNotifications(
  hour: number,
  minute: number,
  copyForDate: (dateISO: string) => Copy,
): Promise<number> {
  // 自分が積んだ分だけを外す（他機能の通知を巻き込まない）
  const pending = await Notifications.getAllScheduledNotificationsAsync();
  await Promise.all(
    pending
      .filter((n) => n.identifier.startsWith(PREFIX))
      .map((n) => Notifications.cancelScheduledNotificationAsync(n.identifier)),
  );
 
  const now = new Date();
  let scheduled = 0;
 
  for (let i = 1; i <= WINDOW_DAYS; i++) {
    const fireAt = new Date(now);
    fireAt.setDate(fireAt.getDate() + i);
    fireAt.setHours(hour, minute, 0, 0);
 
    const dateISO = localISO(fireAt);
    const { title, body } = copyForDate(dateISO);
 
    await Notifications.scheduleNotificationAsync({
      identifier: `${PREFIX}${dateISO}`,
      content: { title, body, data: { dateISO } },
      // date トリガーなので、日付ごとに文言を変えられる
      trigger: { type: "date", date: fireAt } as Notifications.NotificationTriggerInput,
    });
    scheduled++;
  }
 
  // 15日以上開かれなかった場合の保険。ここだけは文言固定でよい
  await Notifications.cancelScheduledNotificationAsync(FALLBACK_ID).catch(() => {});
  await Notifications.scheduleNotificationAsync({
    identifier: FALLBACK_ID,
    content: {
      title: "今日のメッセージが届いています",
      body: "しばらく開いていないうちに、新しい言葉が溜まっています",
    },
    trigger: { hour, minute, repeats: true } as Notifications.NotificationTriggerInput,
  });
 
  return scheduled;
}

// src/hooks/useNotificationRearm.ts
import { useEffect } from "react";
import { AppState } from "react-native";
import * as Notifications from "expo-notifications";
 
export function useNotificationRearm(rearm: () => Promise<number>) {
  useEffect(() => {
    void rearm(); // 起動時
 
    const sub = AppState.addEventListener("change", (state) => {
      if (state === "active") void rearm();
    });
    // 通知タップ経由の起動もここを通す
    const tapSub = Notifications.addNotificationResponseReceivedListener(() => {
      void rearm();
    });
 
    return () => {
      sub.remove();
      tapSub.remove();
    };
  }, [rearm]);
}

// ios/FortuneWidget/FortuneWidget.swift
// WidgetKit を使ったロック画面ウィジェット最小実装
 
import WidgetKit
import SwiftUI
 
struct FortuneEntry: TimelineEntry {
    let date: Date
    let rankLabel: String  // "大吉" など
    let firstLine: String  // "今日は新しい縁が動き出します..."
}
 
struct FortuneProvider: TimelineProvider {
    func placeholder(in context: Context) -> FortuneEntry {
        FortuneEntry(date: Date(), rankLabel: "吉", firstLine: "今日のあなたへのメッセージ")
    }
 
    func getSnapshot(in context: Context, completion: @escaping (FortuneEntry) -> Void) {
        completion(placeholder(in: context))
    }
 
    func getTimeline(in context: Context, completion: @escaping (Timeline<FortuneEntry>) -> Void) {
        // App Group経由でホストアプリから今日の運勢を取得
        let defaults = UserDefaults(suiteName: "group.your.bundle.id")
        let rankLabel = defaults?.string(forKey: "todayRankLabel") ?? "吉"
        let firstLine = defaults?.string(forKey: "todayFirstLine") ?? "アプリを開いてメッセージを受け取ろう"
 
        let entry = FortuneEntry(date: Date(), rankLabel: rankLabel, firstLine: firstLine)
 
        // 明日の0:30に更新
        let tomorrow = Calendar.current.date(byAdding: .day, value: 1, to: Date())!
        let nextUpdate = Calendar.current.date(bySettingHour: 0, minute: 30, second: 0, of: tomorrow)!
        let timeline = Timeline(entries: [entry], policy: .after(nextUpdate))
        completion(timeline)
    }
}
 
struct FortuneWidgetEntryView: View {
    var entry: FortuneProvider.Entry
 
    var body: some View {
        VStack(alignment: .leading, spacing: 4) {
            Text(entry.rankLabel)
                .font(.system(size: 18, weight: .bold))
                .foregroundColor(.primary)
            Text(entry.firstLine)
                .font(.system(size: 12))
                .lineLimit(2)
                .foregroundColor(.secondary)
        }
        .padding(8)
    }
}
 
@main
struct FortuneWidget: Widget {
    let kind: String = "FortuneWidget"
 
    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: FortuneProvider()) { entry in
            FortuneWidgetEntryView(entry: entry)
        }
        .configurationDisplayName("今日の運勢")
        .description("ロック画面で今日の運勢を確認できます")
        .supportedFamilies([.systemSmall, .accessoryRectangular])
    }
}

// src/lib/formatPrice.ts
// ユーザーのロケールに合わせて価格を表示する
 
export function formatLocalizedPrice(
  amountInJpy: number,
  locale: string = Intl.DateTimeFormat().resolvedOptions().locale,
): string {
  // ストア取引はJPY建てだが、表示だけはローカル通貨換算した目安に置き換える
  // 公平な為替レートはストアが返すものを使う想定。ここではフォールバック表示
  const fmt = new Intl.NumberFormat(locale, {
    style: "currency",
    currency: "JPY",
  });
  return fmt.format(amountInJpy);
}

// src/lib/avoidRecentRepeats.ts
// 過去30日分のテーマ重複を避けてピックする
 
import AsyncStorage from "@react-native-async-storage/async-storage";
 
const HISTORY_KEY = "fortune-history-v1";
const HISTORY_DAYS = 30;
 
type HistoryEntry = { date: string; themeId: string };
 
export async function pickNonRepeating(
  candidates: { themeId: string; body: string }[],
  rand: () => number,
  today: string,
): Promise<{ themeId: string; body: string }> {
  const raw = await AsyncStorage.getItem(HISTORY_KEY);
  const history: HistoryEntry[] = raw ? JSON.parse(raw) : [];
 
  // 30日より古いエントリを切り捨て
  const cutoff = new Date(today);
  cutoff.setDate(cutoff.getDate() - HISTORY_DAYS);
  const recent = history.filter((h) => new Date(h.date) >= cutoff);
  const recentThemes = new Set(recent.map((h) => h.themeId));
 
  // 直近30日に登場していない候補のみに絞る
  const fresh = candidates.filter((c) => !recentThemes.has(c.themeId));
  const pool = fresh.length > 0 ? fresh : candidates;
  const picked = pool[Math.floor(rand() * pool.length)];
 
  // 履歴に追記して保存
  recent.push({ date: today, themeId: picked.themeId });
  await AsyncStorage.setItem(HISTORY_KEY, JSON.stringify(recent));
 
  return picked;
}