@stackonward/cli 1.2.1 → 1.3.1

package/dist/resources/templates/nuxt/app/i18n/locales/en.json

@@ -1,5 +1,129 @@
 {
   "common": {
     "close": "Close"
+  },
+  "site": {
+    "region": "Site",
+    "home": "Home",
+    "backToTop": "Back to top",
+    "skipToContent": "Skip to content",
+    "openMarketingSite": "View site",
+    "description": "A premium product media workspace for generating product images, campaign sets, and short-form ad videos."
+  },
+  "actions": {
+    "start": "Start creating",
+    "signIn": "Sign in"
+  },
+  "navigation": {
+    "primary": "Primary navigation",
+    "mobilePrimary": "Mobile primary navigation",
+    "application": "Application navigation",
+    "toggle": "Toggle navigation",
+    "toggleSidebar": "Toggle sidebar",
+    "groups": {
+      "production": "Production"
+    },
+    "items": {
+      "product": "Product",
+      "solutions": "Solutions",
+      "resources": "Resources",
+      "workspace": "Creative workspace",
+      "workspaceBoard": "Workspace board",
+      "designSystem": "Design system",
+      "playbook": "Playbook",
+      "creativePlaybook": "Creative playbook",
+      "contentHub": "Content hub",
+      "overview": "Overview",
+      "company": "Company",
+      "pricing": "Pricing",
+      "blog": "Blog",
+      "terms": "Terms",
+      "privacy": "Privacy",
+      "cookies": "Cookies"
+    },
+    "descriptions": {
+      "workspace": "Application shell for production workflows",
+      "designSystem": "Tokens, components, checkout, identity, video, and infinite-scroll examples",
+      "playbook": "Content detail shell for product education and SEO",
+      "privacy": "Static policy page"
+    }
+  },
+  "language": {
+    "current": "Current language: {language}",
+    "select": "Select language"
+  },
+  "theme": {
+    "current": "Current theme: {theme}",
+    "select": "Select theme",
+    "system": "System",
+    "light": "Light",
+    "dark": "Dark"
+  },
+  "consent": {
+    "region": "Analytics preferences",
+    "title": "Your analytics choice",
+    "message": "We use necessary storage for your choices and optional analytics to understand how the site is used. Analytics stays off unless you allow it.",
+    "policy": "Read the cookie policy",
+    "decline": "Decline analytics",
+    "allow": "Allow analytics",
+    "close": "Close analytics settings",
+    "settings": "Cookie settings",
+    "storageUnavailable": "This browser did not allow us to read your saved choice. Analytics remains off until you choose for this session.",
+    "storageCleanupFailed": "An invalid or expired saved choice could not be removed. Analytics remains off.",
+    "storageCleared": "Your previous analytics choice was removed. We will ask again on your next visit.",
+    "sessionOnly": "Your choice applies to this visit, but the browser did not allow us to save it."
+  },
+  "footer": {
+    "navigation": "Footer navigation",
+    "legal": "Legal navigation",
+    "copyright": "© {year} {site}"
+  },
+  "content": {
+    "related": "Related",
+    "relatedRegion": "Related content",
+    "updated": "Updated {date}"
+  },
+  "notifications": {
+    "region": "Notifications",
+    "dismiss": "Dismiss notification"
+  },
+  "legal": {
+    "cookies": {
+      "title": "Cookie and storage policy",
+      "description": "How this site stores preferences and uses optional analytics.",
+      "updated": "September 13, 2026",
+      "introTitle": "How storage works on this site",
+      "intro": "We use browser storage and cookies to remember choices you request. Optional analytics remains disabled until you allow it in the analytics settings.",
+      "inventoryTitle": "Storage inventory",
+      "inventoryDescription": "The table lists the storage configured by this site. Analytics entries are created only when analytics is configured and you allow it.",
+      "name": "Name",
+      "category": "Category",
+      "purpose": "Purpose",
+      "provider": "Provider",
+      "retention": "Retention",
+      "categories": {
+        "necessary": "Necessary",
+        "preferences": "Preferences",
+        "analytics": "Analytics"
+      },
+      "choicesTitle": "Your choices",
+      "choices": "You can allow or decline optional analytics when the banner appears. Use Cookie settings in the footer to review or withdraw that choice later. Theme and language storage records the presentation options you select.",
+      "changesTitle": "Changes to this policy",
+      "changes": "We will update this page when the storage categories, purposes, providers, or retention periods materially change. A material analytics-policy change requires a new choice.",
+      "contactTitle": "Questions",
+      "contact": "Use the contact details in the privacy policy if you have questions about this storage inventory.",
+      "storage": {
+        "consentPurpose": "Records whether you allowed or declined optional analytics.",
+        "consentRetention": "180 days from your latest choice.",
+        "themePurpose": "Remembers the system, light, or dark appearance you selected.",
+        "localePurpose": "Remembers the language you selected.",
+        "localeRetention": "Up to one year.",
+        "analyticsPurpose": "Distinguishes visits and measures aggregate site usage after analytics is allowed.",
+        "analyticsRetention": "Up to two years, subject to the configured Google Analytics retention settings.",
+        "persistent": "Until you clear site storage or change the preference.",
+        "firstParty": "This site",
+        "google": "Google Analytics"
+      }
+    }
   }
 }

package/dist/resources/templates/nuxt/app/pages/legal/cookies.vue

@@ -0,0 +1,68 @@
+<script setup lang="ts">
+const site = useSiteShell();
+const { t } = useI18n();
+
+useSeo({
+  title: t("legal.cookies.title"),
+  description: t("legal.cookies.description"),
+  canonicalPath: site.value.consent.policyPath,
+});
+</script>
+
+<template>
+  <StaticPage
+    :title="t('legal.cookies.title')"
+    :description="t('legal.cookies.description')"
+    :updated-at="t('legal.cookies.updated')"
+  >
+    <section>
+      <h2>{{ t("legal.cookies.introTitle") }}</h2>
+      <p>{{ t("legal.cookies.intro") }}</p>
+    </section>
+
+    <section>
+      <h2>{{ t("legal.cookies.inventoryTitle") }}</h2>
+      <p>{{ t("legal.cookies.inventoryDescription") }}</p>
+      <div class="storage-inventory">
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">{{ t("legal.cookies.name") }}</th>
+              <th scope="col">{{ t("legal.cookies.category") }}</th>
+              <th scope="col">{{ t("legal.cookies.purpose") }}</th>
+              <th scope="col">{{ t("legal.cookies.provider") }}</th>
+              <th scope="col">{{ t("legal.cookies.retention") }}</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="item in site.storageDisclosures" :key="item.name">
+              <th scope="row">
+                <code>{{ item.name }}</code>
+              </th>
+              <td>{{ t(`legal.cookies.categories.${item.category}`) }}</td>
+              <td>{{ t(item.purposeKey) }}</td>
+              <td>{{ t(item.providerKey) }}</td>
+              <td>{{ t(item.retentionKey) }}</td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+    </section>
+
+    <section>
+      <h2>{{ t("legal.cookies.choicesTitle") }}</h2>
+      <p>{{ t("legal.cookies.choices") }}</p>
+      <ConsentSettingsButton />
+    </section>
+
+    <section>
+      <h2>{{ t("legal.cookies.changesTitle") }}</h2>
+      <p>{{ t("legal.cookies.changes") }}</p>
+    </section>
+
+    <section>
+      <h2>{{ t("legal.cookies.contactTitle") }}</h2>
+      <p>{{ t("legal.cookies.contact") }}</p>
+    </section>
+  </StaticPage>
+</template>

package/dist/resources/templates/nuxt/nuxt.config.ts

@@ -1,6 +1,7 @@
 import { defineNuxtConfig } from "nuxt/config";
 
 const siteEnv = process.env.NUXT_PUBLIC_SITE_ENV || "development";
+const siteUrl = process.env.NUXT_PUBLIC_SITE_URL || "https://example.com";
 const gtmId = process.env.NUXT_PUBLIC_GTM_ID || "";
 
 export default defineNuxtConfig({
@@ -8,6 +9,21 @@ export default defineNuxtConfig({
   modules: ["@nuxt/eslint", "@stackonward/google-tag-manager-nuxt"],
   compatibilityDate: "2025-07-15",
   css: ["~/assets/css/site-shell.css"],
+  i18n: {
+    baseUrl: siteUrl,
+    defaultLocale: "en",
+    strategy: "prefix_except_default",
+    restructureDir: "app/i18n",
+    langDir: "locales",
+    locales: [{ code: "en", language: "en-US", name: "English", file: "en.json" }],
+    detectBrowserLanguage: {
+      useCookie: true,
+      cookieKey: "{{projectName}}_locale",
+      redirectOn: "root",
+      fallbackLocale: "en",
+      alwaysRedirect: false,
+    },
+  },
   components: [
     {
       path: "~/components",

package/dist/resources/templates/nuxt/package.json

@@ -29,9 +29,9 @@
   },
   "dependencies": {
     "@stackonward/api-client": "^0.0.2",
-    "@stackonward/google-tag-manager-nuxt": "^0.2.1",
+    "@stackonward/google-tag-manager-nuxt": "^0.2.3",
     "@stackonward/nuxt-layer-base": "^0.0.3",
-    "@stackonward/nuxt-site-shell": "^0.1.0"
+    "@stackonward/nuxt-site-shell": "^0.2.0"
   },
   "devDependencies": {
     "@commitlint/cli": "^21.2.2",

package/dist/resources/templates/nuxt/test/unit/consent.test.ts

@@ -0,0 +1,289 @@
+import { computed, ref } from "vue";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  ConsentLifecycleError,
+  createSiteConsentController,
+} from "../../app/composables/useConsent";
+import type { ConsentState, SiteShellConsentConfig } from "../../app/types/site-shell";
+
+class ControlledStorage implements Storage {
+  readonly values = new Map<string, string>();
+  failRead = false;
+  failWrite = false;
+  failClear = false;
+
+  get length(): number {
+    return this.values.size;
+  }
+
+  clear(): void {
+    this.values.clear();
+  }
+
+  getItem(key: string): string | null {
+    if (this.failRead) throw new Error("read failed");
+    return this.values.get(key) ?? null;
+  }
+
+  key(index: number): string | null {
+    return [...this.values.keys()][index] ?? null;
+  }
+
+  removeItem(key: string): void {
+    if (this.failClear) throw new Error("clear failed");
+    this.values.delete(key);
+  }
+
+  setItem(key: string, value: string): void {
+    if (this.failWrite) throw new Error("write failed");
+    this.values.set(key, value);
+  }
+}
+
+const storageKey = "sample-analytics-consent-v1";
+const config: SiteShellConsentConfig = {
+  enabled: true,
+  storageKey,
+  policyRevision: "1",
+  retentionDays: 180,
+  policyPath: "/legal/cookies",
+};
+
+function record(value: "accepted" | "rejected", expiresAt: number, policyRevision = "1"): string {
+  return JSON.stringify({
+    version: 1,
+    policyRevision,
+    value,
+    expiresAt: new Date(expiresAt).toISOString(),
+  });
+}
+
+describe("site consent controller", () => {
+  let storage: ControlledStorage;
+  let windowListeners: Map<string, Set<EventListener>>;
+  let documentListeners: Map<string, Set<EventListener>>;
+  let visibilityState: DocumentVisibilityState;
+  let analyticsState: "unknown" | "granted" | "denied";
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-09-13T00:00:00.000Z"));
+    storage = new ControlledStorage();
+    windowListeners = new Map();
+    documentListeners = new Map();
+    visibilityState = "visible";
+    vi.stubGlobal("window", {
+      localStorage: storage,
+      addEventListener(type: string, listener: EventListener) {
+        const listeners = windowListeners.get(type) ?? new Set<EventListener>();
+        listeners.add(listener);
+        windowListeners.set(type, listeners);
+      },
+      removeEventListener(type: string, listener: EventListener) {
+        windowListeners.get(type)?.delete(listener);
+      },
+    });
+    vi.stubGlobal("document", {
+      get visibilityState() {
+        return visibilityState;
+      },
+      addEventListener(type: string, listener: EventListener) {
+        const listeners = documentListeners.get(type) ?? new Set<EventListener>();
+        listeners.add(listener);
+        documentListeners.set(type, listeners);
+      },
+      removeEventListener(type: string, listener: EventListener) {
+        documentListeners.get(type)?.delete(listener);
+      },
+    });
+    analyticsState = "unknown";
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  function createController() {
+    const state = ref<ConsentState>({
+      decision: null,
+      ready: false,
+      settingsOpen: false,
+      persistence: "none",
+      error: null,
+    });
+    const controller = createSiteConsentController({
+      state,
+      config: computed(() => config),
+      analytics: {
+        available: () => true,
+        grant: () => {
+          analyticsState = "granted";
+        },
+        deny: () => {
+          analyticsState = "denied";
+        },
+        reset: () => {
+          analyticsState = "unknown";
+        },
+      },
+    });
+    return { controller, state };
+  }
+
+  function dispatch(type: "storage" | "visibilitychange", event: Event): void {
+    const listeners = type === "storage" ? windowListeners.get(type) : documentListeners.get(type);
+    for (const listener of listeners ?? []) listener(event);
+  }
+
+  it("restores, synchronizes, expires, and replaces the single deadline", () => {
+    const now = Date.now();
+    storage.setItem(storageKey, record("accepted", now + 2_000));
+    const { controller, state } = createController();
+
+    expect(controller.initialize()).toEqual({ status: "restored", value: "accepted" });
+    expect(controller.initialize()).toEqual({ status: "restored", value: "accepted" });
+    expect(analyticsState).toBe("granted");
+    expect(state.value.decision).toBe("accepted");
+    expect(vi.getTimerCount()).toBe(1);
+    expect(windowListeners.get("storage")?.size).toBe(1);
+
+    storage.setItem(storageKey, record("rejected", now + 4_000));
+    dispatch("storage", { key: storageKey } as StorageEvent);
+    expect(analyticsState).toBe("denied");
+    expect(state.value.decision).toBe("rejected");
+    expect(vi.getTimerCount()).toBe(1);
+
+    vi.advanceTimersByTime(4_001);
+    expect(analyticsState).toBe("unknown");
+    expect(state.value).toMatchObject({
+      decision: null,
+      ready: true,
+      persistence: "cleared",
+      error: null,
+    });
+    expect(storage.getItem(storageKey)).toBeNull();
+    expect(controller.visible.value).toBe(true);
+  });
+
+  it("revalidates on visibility and bounds long-lived deadlines", () => {
+    const year = 366 * 24 * 60 * 60 * 1_000;
+    storage.setItem(storageKey, record("accepted", Date.now() + year));
+    const { controller, state } = createController();
+    controller.initialize();
+
+    vi.advanceTimersByTime(2_147_483_647);
+    expect(state.value.decision).toBe("accepted");
+    expect(vi.getTimerCount()).toBe(1);
+
+    storage.setItem(storageKey, record("rejected", Date.now() + 10_000));
+    visibilityState = "hidden";
+    dispatch("visibilitychange", {} as Event);
+    expect(state.value.decision).toBe("accepted");
+    visibilityState = "visible";
+    dispatch("visibilitychange", {} as Event);
+    expect(state.value.decision).toBe("rejected");
+    expect(analyticsState).toBe("denied");
+    expect(vi.getTimerCount()).toBe(1);
+  });
+
+  it("keeps invalid and revised records denied with observable cleanup outcomes", () => {
+    storage.setItem(storageKey, "not-json");
+    const first = createController();
+    expect(first.controller.initialize()).toEqual({ status: "undecided", cleanup: "cleared" });
+    expect(first.state.value.persistence).toBe("cleared");
+    expect(analyticsState).toBe("unknown");
+    first.controller.dispose();
+
+    storage.setItem(storageKey, record("accepted", Date.now() + 10_000, "outdated"));
+    storage.failClear = true;
+    const second = createController();
+    expect(second.controller.initialize()).toEqual({
+      status: "undecided",
+      cleanup: "failed",
+      error: "clear-failed",
+    });
+    expect(second.state.value).toMatchObject({
+      decision: null,
+      persistence: "cleanup-failed",
+      error: "clear-failed",
+    });
+    expect(analyticsState).toBe("unknown");
+  });
+
+  it("reports read failure and keeps the choice UI available", () => {
+    storage.failRead = true;
+    const { controller, state } = createController();
+
+    expect(controller.initialize()).toEqual({
+      status: "storage-unavailable",
+      error: "read-failed",
+    });
+    expect(state.value).toMatchObject({ decision: null, ready: true, error: "read-failed" });
+    expect(controller.visible.value).toBe(true);
+    expect(analyticsState).toBe("unknown");
+  });
+
+  it("preserves explicit session behavior across write and withdrawal failures", () => {
+    const accepted = createController();
+    accepted.controller.initialize();
+    storage.failWrite = true;
+    expect(accepted.controller.accept()).toEqual({
+      status: "session-only",
+      value: "accepted",
+      error: "write-failed",
+    });
+    expect(analyticsState).toBe("granted");
+    expect(accepted.state.value.settingsOpen).toBe(true);
+    accepted.controller.closeSettings();
+    expect(accepted.controller.visible.value).toBe(false);
+    accepted.controller.dispose();
+
+    storage.values.set(storageKey, record("accepted", Date.now() + 10_000));
+    const rejected = createController();
+    storage.failWrite = false;
+    rejected.controller.initialize();
+    storage.failWrite = true;
+    expect(rejected.controller.reject()).toEqual({
+      status: "cleared",
+      value: "rejected",
+      error: "write-failed",
+    });
+    expect(storage.values.has(storageKey)).toBe(false);
+    expect(analyticsState).toBe("denied");
+    rejected.controller.dispose();
+
+    storage.values.set(storageKey, record("accepted", Date.now() + 10_000));
+    storage.failWrite = false;
+    const uncleared = createController();
+    uncleared.controller.initialize();
+    storage.failWrite = true;
+    storage.failClear = true;
+    expect(uncleared.controller.reject()).toEqual({
+      status: "session-only",
+      value: "rejected",
+      error: "write-and-clear-failed",
+    });
+    expect(uncleared.state.value.error).toBe("write-and-clear-failed");
+    expect(analyticsState).toBe("denied");
+  });
+
+  it("owns settings and disposes all browser effects", () => {
+    const { controller, state } = createController();
+    expect(() => controller.openSettings()).toThrow(ConsentLifecycleError);
+    controller.initialize();
+    expect(() => controller.closeSettings()).toThrow(ConsentLifecycleError);
+    controller.reject();
+    controller.openSettings();
+    expect(state.value.settingsOpen).toBe(true);
+    controller.closeSettings();
+    expect(state.value.settingsOpen).toBe(false);
+
+    controller.dispose();
+    controller.dispose();
+    expect(vi.getTimerCount()).toBe(0);
+    expect(windowListeners.get("storage")?.size).toBe(0);
+    expect(documentListeners.get("visibilitychange")?.size).toBe(0);
+    expect(() => controller.accept()).toThrow(ConsentLifecycleError);
+  });
+});

package/dist/resources/templates/nuxt/vitest.config.ts

@@ -1,6 +1,12 @@
+import { fileURLToPath } from "node:url";
 import { defineConfig } from "vitest/config";
 
 export default defineConfig({
+  resolve: {
+    alias: {
+      "~": fileURLToPath(new URL("./app", import.meta.url)),
+    },
+  },
   test: {
     include: ["test/**/*.test.ts"],
     testTimeout: 120_000,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackonward/cli",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "StackOnward CLI for creating projects and installing reusable components and snippets",
   "type": "module",
   "main": "dist/index.js",
@@ -36,8 +36,8 @@
     "ora": "^8.0.0",
     "prompts": "^2.4.2",
     "zod": "4",
-    "@stackonward/api-client": "0.0.2",
-    "@stackonward/google-tag-manager": "0.1.1"
+    "@stackonward/google-tag-manager": "0.1.1",
+    "@stackonward/api-client": "0.0.2"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",