@erinjs/core 1.0.0

package/core/apps/docs/src/stores/docs.ts

@@ -0,0 +1,54 @@
+import { defineStore } from 'pinia';
+import { ref, computed } from 'vue';
+import { DocOutput } from '../types/doc-schema';
+
+/** Version used for fetch path: "latest" or "v1.0.5" */
+export type DocsVersionKey = string;
+
+export const useDocsStore = defineStore('docs', () => {
+  const docsData = ref<DocOutput | null>(null);
+  const loadedVersion = ref<DocsVersionKey | null>(null);
+  const loading = ref(false);
+  const error = ref<string | null>(null);
+
+  const currentDoc = computed(() => docsData.value);
+
+  /**
+   * Load docs for a specific version. Uses versioned path: docs/{version}/main.json
+   */
+  async function loadDocs(versionKey: DocsVersionKey) {
+    if (docsData.value && loadedVersion.value === versionKey) return;
+    loading.value = true;
+    error.value = null;
+    try {
+      const versionPath = versionKey === 'latest' ? 'latest' : `v${versionKey}`;
+      const url = `/docs/${versionPath}/main.json`;
+      const res = await fetch(url);
+      if (!res.ok) throw new Error(`Failed to load docs: ${res.status}`);
+      const data = (await res.json()) as DocOutput;
+      docsData.value = data;
+      loadedVersion.value = versionKey;
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : String(e);
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  /** Clear cached docs (e.g. when switching versions) */
+  function clearDocs() {
+    docsData.value = null;
+    loadedVersion.value = null;
+  }
+
+  return {
+    docsData,
+    loadedVersion,
+    loading,
+    error,
+    currentDoc,
+    loadDocs,
+    clearDocs,
+  };
+});

package/core/apps/docs/src/stores/guides.ts

@@ -0,0 +1,53 @@
+import { defineStore } from 'pinia';
+import { ref, computed } from 'vue';
+import { Guide } from '../data/guides';
+import { guides as staticGuides } from '../data/guides';
+
+export const useGuidesStore = defineStore('guides', () => {
+  const guidesData = ref<Guide[] | null>(null);
+  const loadedVersion = ref<string | null>(null);
+  const loading = ref(false);
+  const error = ref<string | null>(null);
+
+  const guides = computed(() => guidesData.value ?? staticGuides);
+
+  function getGuideBySlug(slug: string): Guide | undefined {
+    return (guidesData.value ?? staticGuides).find((g) => g.slug === slug);
+  }
+
+  async function loadGuides(versionKey: string) {
+    if (guidesData.value && loadedVersion.value === versionKey) return;
+    loading.value = true;
+    error.value = null;
+    try {
+      const versionPath = versionKey === 'latest' ? 'latest' : `v${versionKey}`;
+      const url = `/docs/${versionPath}/guides.json`;
+      const res = await fetch(url);
+      if (!res.ok) throw new Error(`Failed to load guides: ${res.status}`);
+      guidesData.value = (await res.json()) as Guide[];
+      loadedVersion.value = versionKey;
+    } catch (e) {
+      // Fallback to static guides if json not yet generated (e.g. dev before docs:build)
+      guidesData.value = null;
+      loadedVersion.value = versionKey;
+      error.value = e instanceof Error ? e.message : String(e);
+      // Don't throw - use static fallback
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  function clearGuides() {
+    guidesData.value = null;
+    loadedVersion.value = null;
+  }
+
+  return {
+    guides,
+    loading,
+    error,
+    getGuideBySlug,
+    loadGuides,
+    clearGuides,
+  };
+});

package/core/apps/docs/src/stores/version.ts

@@ -0,0 +1,67 @@
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+
+const STORAGE_KEY = 'fluxer-docs-version';
+
+export interface VersionsManifest {
+  versions: string[];
+  latest: string;
+}
+
+export const useVersionStore = defineStore('version', () => {
+  const availableVersions = ref<string[]>([]);
+  const latestVersion = ref<string>('');
+  const currentVersion = ref<string>('latest');
+  const versionsLoaded = ref(false);
+
+  function setVersion(version: string) {
+    currentVersion.value = version;
+    try {
+      localStorage.setItem(STORAGE_KEY, version);
+    } catch {
+      /* ignore */
+    }
+  }
+
+  function getVersionForFetch(): string {
+    // "latest" maps to the actual latest version for fetching
+    return currentVersion.value === 'latest' ? latestVersion.value : currentVersion.value;
+  }
+
+  async function loadVersions() {
+    if (versionsLoaded.value) return;
+    try {
+      const res = await fetch('/docs/versions.json');
+      if (!res.ok) throw new Error('Failed to load versions');
+      const data = (await res.json()) as VersionsManifest;
+      availableVersions.value = data.versions ?? [];
+      latestVersion.value = data.latest ?? data.versions?.[0] ?? '1.0.7';
+      versionsLoaded.value = true;
+
+      try {
+        const saved = localStorage.getItem(STORAGE_KEY);
+        if (saved && (saved === 'latest' || availableVersions.value.includes(saved))) {
+          currentVersion.value = saved;
+        }
+      } catch {
+        /* ignore */
+      }
+    } catch {
+      // Fallback when versions.json doesn't exist (e.g. dev before first generate)
+      availableVersions.value = ['1.0.7'];
+      latestVersion.value = '1.0.7';
+      currentVersion.value = 'latest';
+      versionsLoaded.value = true;
+    }
+  }
+
+  return {
+    availableVersions,
+    latestVersion,
+    currentVersion,
+    versionsLoaded,
+    setVersion,
+    getVersionForFetch,
+    loadVersions,
+  };
+});

package/core/apps/docs/src/styles/main.css

@@ -0,0 +1,278 @@
+:root {
+  --bg-primary: #0a0b0e;
+  --bg-secondary: #12141a;
+  --bg-tertiary: #1a1c24;
+  --bg-hover: rgba(255, 255, 255, 0.04);
+  --bg-active: rgba(99, 179, 237, 0.08);
+  --text-primary: #e8e9ed;
+  --text-secondary: #9ba0ab;
+  --text-muted: #5f6472;
+  --accent: #63b3ed;
+  --accent-hover: #7dc3f4;
+  --border: #2a2c35;
+  --border-subtle: #22242a;
+  --code-bg: #1a1c23;
+  --radius: 8px;
+  --radius-sm: 4px;
+
+  /* Type signature syntax highlighting */
+  --ts-keyword: #c792ea;
+  --ts-type: #82aaff;
+  --ts-string: #c3e88d;
+  --ts-punct: #5f6472;
+  --ts-ident: #e8e9ed;
+
+  /* Type/badge colors - distinct per kind */
+  --badge-class: #63b3ed;
+  --badge-class-bg: rgba(99, 179, 237, 0.15);
+  --badge-interface: #82aaff;
+  --badge-interface-bg: rgba(130, 170, 255, 0.15);
+  --badge-enum: #c792ea;
+  --badge-enum-bg: rgba(199, 146, 234, 0.15);
+
+  --error: #f87171;
+  --deprecated: #f59e0b;
+  --deprecated-bg: rgba(245, 158, 11, 0.12);
+  --deprecated-border: rgba(245, 158, 11, 0.35);
+
+  --discord-compat: #57f287;
+  --discord-compat-bg: rgba(87, 242, 135, 0.12);
+  --discord-compat-border: rgba(87, 242, 135, 0.35);
+  --discord-compat-badge-text: #0d3b1a;
+
+  /* Sidebar - shared across docs and guides */
+  --sidebar-width: 260px;
+  --sidebar-padding-x: 1rem;
+  --sidebar-accent-stripe: 3px;
+}
+
+/* Shared sidebar base */
+.sidebar-base {
+  width: var(--sidebar-width);
+  min-width: var(--sidebar-width);
+  min-height: 0;
+  flex-shrink: 0;
+  background: var(--bg-secondary);
+  border-right: 1px solid var(--border);
+  overflow-y: auto;
+  overflow-x: hidden;
+  -webkit-overflow-scrolling: touch;
+  padding: 1.25rem 0;
+  border-left: var(--sidebar-accent-stripe) solid var(--accent);
+}
+
+.sidebar-base .sidebar-title {
+  font-size: 0.7rem;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: var(--accent);
+  padding: 0 var(--sidebar-padding-x) 1rem;
+  margin-bottom: 0.5rem;
+  border-bottom: 1px solid var(--border);
+}
+
+.sidebar-base .sidebar-group-label {
+  display: block;
+  font-size: 0.7rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-muted);
+  padding: 1rem var(--sidebar-padding-x) 0.35rem;
+  margin-top: 0.25rem;
+}
+
+.sidebar-base .sidebar-group-label:first-of-type {
+  margin-top: 0;
+  padding-top: 0.5rem;
+}
+
+.sidebar-base .sidebar-group-label.link {
+  text-decoration: none;
+  transition: color 0.15s;
+}
+
+.sidebar-base .sidebar-group-label.link:hover {
+  color: var(--accent);
+}
+
+.sidebar-base .sidebar-group-label.link.active {
+  color: var(--accent);
+}
+
+.sidebar-base .sidebar-link {
+  display: block;
+  padding: 0.4rem var(--sidebar-padding-x);
+  font-size: 0.85rem;
+  color: var(--text-secondary);
+  text-decoration: none;
+  border-left: 2px solid transparent;
+  margin-left: 2px;
+  transition:
+    color 0.15s,
+    background 0.15s,
+    border-color 0.15s;
+}
+
+.sidebar-base .sidebar-link:hover {
+  color: var(--text-primary);
+  background: var(--bg-hover);
+}
+
+.sidebar-base .sidebar-link.active {
+  color: var(--accent);
+  border-left-color: var(--accent);
+  background: var(--bg-active);
+}
+
+.sidebar-base .sidebar-sublist {
+  padding-left: 0.5rem;
+  margin-left: calc(var(--sidebar-padding-x) - 2px);
+  border-left: 1px solid var(--border);
+}
+
+/* Type-specific accent colors in docs sidebar */
+.sidebar-base .sidebar-link-class {
+  --sidebar-type-color: var(--badge-class);
+}
+.sidebar-base .sidebar-link-interface {
+  --sidebar-type-color: var(--badge-interface);
+}
+.sidebar-base .sidebar-link-enum {
+  --sidebar-type-color: var(--badge-enum);
+}
+
+.sidebar-base .sidebar-link-class::before,
+.sidebar-base .sidebar-link-interface::before,
+.sidebar-base .sidebar-link-enum::before {
+  content: '';
+  display: inline-block;
+  width: 4px;
+  height: 4px;
+  border-radius: 50%;
+  background: var(--sidebar-type-color);
+  margin-right: 0.5rem;
+  vertical-align: middle;
+}
+
+.sidebar-base .sidebar-link-class:hover,
+.sidebar-base .sidebar-link-interface:hover,
+.sidebar-base .sidebar-link-enum:hover {
+  color: var(--sidebar-type-color);
+}
+
+.sidebar-base .sidebar-link-class.active,
+.sidebar-base .sidebar-link-interface.active,
+.sidebar-base .sidebar-link-enum.active {
+  color: var(--sidebar-type-color);
+  border-left-color: var(--sidebar-type-color);
+}
+
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+html {
+  scroll-behavior: smooth;
+}
+
+body {
+  font-family:
+    'DM Sans',
+    system-ui,
+    -apple-system,
+    sans-serif;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  line-height: 1.6;
+  min-height: 100vh;
+  -webkit-font-smoothing: antialiased;
+}
+
+body::before {
+  content: '';
+  position: fixed;
+  inset: 0;
+  background-image:
+    linear-gradient(rgba(99, 179, 237, 0.03) 1px, transparent 1px),
+    linear-gradient(90deg, rgba(99, 179, 237, 0.03) 1px, transparent 1px);
+  background-size: 48px 48px;
+  pointer-events: none;
+  z-index: 0;
+}
+
+a {
+  color: var(--accent);
+  text-decoration: none;
+}
+
+a:hover {
+  color: var(--accent-hover);
+}
+
+code {
+  font-family: 'JetBrains Mono', 'Fira Code', ui-monospace, monospace;
+  font-size: 0.9em;
+  background: var(--code-bg);
+  padding: 0.18em 0.45em;
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--border-subtle);
+}
+
+pre {
+  background: var(--code-bg);
+  padding: 1.25rem 1.5rem;
+  border-radius: var(--radius);
+  overflow-x: auto;
+  border: 1px solid var(--border-subtle);
+}
+
+pre code {
+  padding: 0;
+  background: none;
+  border: none;
+}
+
+/* Responsive breakpoints */
+@media (max-width: 900px) {
+  .sidebar-base,
+  .guides-sidebar,
+  .docs-layout .sidebar {
+    position: fixed;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    z-index: 100;
+    transform: translateX(-100%);
+    transition: transform 0.2s ease;
+    box-shadow: 4px 0 24px rgba(0, 0, 0, 0.3);
+  }
+
+  .sidebar-base.is-open,
+  .guides-sidebar.is-open,
+  .docs-layout .sidebar.is-open {
+    transform: translateX(0);
+  }
+
+  .guide-toc,
+  .on-this-page {
+    display: none !important;
+  }
+
+  .guide-page,
+  .class-page {
+    flex-direction: column;
+  }
+
+  .guides-content-scroll,
+  .content-scroll {
+    padding: 1.25rem 1rem !important;
+  }
+
+  .guide-page {
+    max-width: 100%;
+  }
+}

package/core/apps/docs/src/styles/prism.css

@@ -0,0 +1,95 @@
+/**
+ * Custom Prism syntax highlighting – matches docs palette
+ */
+
+code[class*='language-'],
+pre[class*='language-'] {
+  font-family: 'JetBrains Mono', 'Fira Code', ui-monospace, monospace;
+  font-size: 0.875rem;
+  line-height: 1.6;
+  text-align: left;
+  white-space: pre;
+  word-spacing: normal;
+  word-break: normal;
+  tab-size: 2;
+  hyphens: none;
+}
+
+pre[class*='language-'] {
+  padding: 1.25rem 1.5rem;
+  margin: 0;
+  overflow: auto;
+  background: var(--code-bg);
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius);
+}
+
+:not(pre) > code[class*='language-'] {
+  padding: 0.2em 0.4em;
+  border-radius: var(--radius-sm);
+}
+
+/* Token colors – tuned for dark theme */
+.token.comment,
+.token.prolog,
+.token.doctype,
+.token.cdata {
+  color: #64748b;
+}
+
+.token.punctuation {
+  color: #94a3b8;
+}
+
+.token.property,
+.token.tag,
+.token.boolean,
+.token.number,
+.token.constant,
+.token.symbol {
+  color: #fcd34d;
+}
+
+.token.selector,
+.token.attr-name,
+.token.string,
+.token.char,
+.token.builtin {
+  color: #6ee7b7;
+}
+
+.token.operator {
+  color: #67e8f9;
+}
+
+.token.entity,
+.token.url {
+  color: #a5b4fc;
+}
+
+.token.atrule,
+.token.attr-value,
+.token.keyword {
+  color: #c4b5fd;
+}
+
+.token.function,
+.token.class-name {
+  color: #7dd3fc;
+}
+
+.token.regex,
+.token.important,
+.token.variable {
+  color: #f9a8d4;
+}
+
+/* Doc links inside code blocks */
+.code-with-links .doc-link {
+  color: #7dd3fc;
+  text-decoration: none;
+}
+
+.code-with-links .doc-link:hover {
+  text-decoration: underline;
+}

package/core/apps/docs/src/types/doc-schema.ts

@@ -0,0 +1,112 @@
+/**
+ * Doc schema - matches output from @erinjs/docgen
+ */
+
+export interface DocMeta {
+  generator: string;
+  version: string;
+  date: number;
+}
+
+export interface DocParam {
+  name: string;
+  type: string;
+  optional?: boolean;
+  description?: string;
+}
+
+export interface DocConstructor {
+  params: DocParam[];
+  description?: string;
+  examples?: string[];
+}
+
+export interface DocProperty {
+  name: string;
+  type: string;
+  readonly?: boolean;
+  description?: string;
+  examples?: string[];
+  optional?: boolean;
+  /** Discord.js compatible: string = link to d.js docs, true = no link */
+  discordJsCompat?: boolean | string;
+}
+
+export interface DocMethod {
+  name: string;
+  params: DocParam[];
+  returns: string;
+  description?: string;
+  examples?: string[];
+  async?: boolean;
+  deprecated?: boolean | string;
+  /** Discord.js compatible: string = link to d.js docs, true = no link */
+  discordJsCompat?: boolean | string;
+  source?: DocSource;
+}
+
+export interface DocSource {
+  file: string;
+  line: number;
+  /** Path relative to repo root for GitHub links */
+  path?: string;
+}
+
+export interface DocClass {
+  name: string;
+  description?: string;
+  extends?: string;
+  constructor?: DocConstructor;
+  properties: DocProperty[];
+  methods: DocMethod[];
+  source?: DocSource;
+  deprecated?: boolean | string;
+  /** Discord.js compatible: string = link to d.js docs, true = no link */
+  discordJsCompat?: boolean | string;
+  /** Package name e.g. @erinjs/core */
+  package?: string;
+}
+
+export interface DocInterfaceProperty {
+  name: string;
+  type: string;
+  optional?: boolean;
+  description?: string;
+  examples?: string[];
+  discordJsCompat?: boolean | string;
+}
+
+export interface DocInterface {
+  name: string;
+  description?: string;
+  properties: DocInterfaceProperty[];
+  source?: DocSource;
+  /** Package name e.g. @erinjs/core */
+  package?: string;
+}
+
+export interface DocEnumMember {
+  name: string;
+  value: string | number;
+}
+
+export interface DocEnum {
+  name: string;
+  description?: string;
+  members: DocEnumMember[];
+  source?: DocSource;
+  /** Package name e.g. @erinjs/core */
+  package?: string;
+}
+
+export interface DocOutput {
+  meta: DocMeta;
+  package: string;
+  /** SDK version e.g. 1.0.5 */
+  version?: string;
+  /** Available packages for filtering */
+  packages?: string[];
+  classes: DocClass[];
+  interfaces: DocInterface[];
+  enums: DocEnum[];
+}

package/core/apps/docs/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "jsx": "preserve",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "types": ["node"],
+    "paths": { "~/*": ["./src/*"] },
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.vue"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/core/apps/docs/tsconfig.node.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true
+  },
+  "include": ["vite.config.ts", "vite.config.d.ts"]
+}

package/core/apps/docs/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vite').UserConfig;
+export default _default;