@yoamigo.com/core 0.1.0

package/dist/plugin.d.ts

@@ -0,0 +1,47 @@
+import { UserConfig, Plugin } from 'vite';
+
+/**
+ * YoAmigo Vite Plugin
+ *
+ * Handles all the build-time configuration for YoAmigo templates:
+ * - React → Preact swap in production (smaller bundles)
+ * - Component aliasing: @yoamigo/core → @yoamigo/core/prod in production
+ * - Path aliases: @/ → src/
+ * - Environment variables: YA_* prefix
+ * - Build output configuration
+ *
+ * Usage:
+ * ```ts
+ * // vite.config.ts
+ * import { defineConfig } from 'vite'
+ * import { yoamigoPlugin } from '@yoamigo/core/plugin'
+ *
+ * export default defineConfig({
+ *   plugins: [yoamigoPlugin()],
+ * })
+ * ```
+ */
+
+interface YoamigoPluginOptions {
+    /**
+     * Additional Vite plugins to include
+     */
+    plugins?: UserConfig['plugins'];
+    /**
+     * Additional path aliases
+     */
+    aliases?: Record<string, string>;
+    /**
+     * Custom build options
+     */
+    build?: UserConfig['build'];
+}
+/**
+ * Creates the YoAmigo Vite plugin configuration.
+ *
+ * @param options - Optional customization options
+ * @returns Array of Vite plugins
+ */
+declare function yoamigoPlugin(options?: YoamigoPluginOptions): Plugin[];
+
+export { type YoamigoPluginOptions, yoamigoPlugin as default, yoamigoPlugin };

package/dist/plugin.js

@@ -0,0 +1,96 @@
+// src/plugin/index.ts
+import react from "@vitejs/plugin-react";
+import preact from "@preact/preset-vite";
+import path from "path";
+function yoamigoPlugin(options = {}) {
+  const templateDir = process.cwd();
+  const resolveFromTemplate = (relativePath) => path.resolve(templateDir, relativePath);
+  return [
+    {
+      name: "yoamigo:config",
+      config(config, { mode }) {
+        const isProd = mode === "production";
+        const aliasArray = [
+          // Production aliases must come FIRST for priority
+          ...isProd ? [
+            // === React -> Preact (must be first for broad matching) ===
+            { find: "react", replacement: "preact/compat" },
+            { find: "react-dom/test-utils", replacement: "preact/test-utils" },
+            { find: "react-dom/client", replacement: "preact/compat/client" },
+            { find: "react-dom", replacement: "preact/compat" },
+            { find: "react/jsx-runtime", replacement: "preact/jsx-runtime" },
+            // === @yoamigo/core -> Production barrel ===
+            // Redirect the entire components import to use static versions.
+            // This removes Tiptap and editing UI from the production bundle.
+            {
+              find: /^@yoamigo\/core$/,
+              replacement: "@yoamigo/core/prod"
+            },
+            {
+              find: /^@yoamigo\/core\/lib$/,
+              replacement: "@yoamigo/core/lib/prod"
+            }
+          ] : [],
+          // === Template-specific path aliases ===
+          { find: "@", replacement: resolveFromTemplate("./src") },
+          { find: "@components", replacement: resolveFromTemplate("./src/components") },
+          { find: "@lib", replacement: resolveFromTemplate("./src/lib") },
+          { find: "@assets", replacement: resolveFromTemplate("./assets") },
+          // Add any custom aliases from options
+          ...Object.entries(options.aliases || {}).map(([find, replacement]) => ({
+            find,
+            replacement: resolveFromTemplate(replacement)
+          }))
+        ];
+        return {
+          plugins: [isProd ? preact() : react(), ...options.plugins || []],
+          // Expose YA_ prefixed env vars to client code
+          envPrefix: "YA_",
+          // Serve static files from public/ directory
+          publicDir: "public",
+          resolve: {
+            alias: aliasArray,
+            // Ensure single React instance across all packages (prevents "Invalid hook call" errors)
+            dedupe: ["react", "react-dom"]
+          },
+          server: {
+            port: 5173,
+            strictPort: false,
+            // Allow Vite to find next available port
+            hmr: {
+              // When behind a proxy (builder worker), HMR needs to connect through the proxy
+              // Setting these to undefined lets Vite auto-detect from the page URL
+              // This ensures HMR WebSocket connects to the proxy (router) not directly to Vite
+              clientPort: void 0,
+              host: void 0,
+              protocol: void 0
+            }
+          },
+          // Dynamic base URL for different deployment contexts:
+          // - Preview builds: /deploy-preview/{siteId}/ (passed via YA_BASE_URL env var)
+          // - Published builds: / (default, served from subdomain root)
+          // - Dev server: ignored (base only affects production builds)
+          base: process.env.YA_BASE_URL || "/",
+          build: {
+            outDir: "dist",
+            emptyOutDir: true,
+            rollupOptions: {
+              output: {
+                // Output to build/ to avoid confusion with public/assets/ (source images)
+                entryFileNames: "build/[name].[hash].js",
+                chunkFileNames: "build/[name].[hash].js",
+                assetFileNames: "build/[name].[hash].[ext]"
+              }
+            },
+            ...options.build
+          }
+        };
+      }
+    }
+  ];
+}
+var plugin_default = yoamigoPlugin;
+export {
+  plugin_default as default,
+  yoamigoPlugin
+};

package/dist/prod.d.ts

@@ -0,0 +1,31 @@
+export { a as ContentStore, E as ContentStoreMode, C as ContentStoreProvider, d as MarkdownText, e as MarkdownTextProps, P as PageInfo, b as StaticImage, c as StaticImageProps, M as StaticText, S as StaticTextProps, b as YaImage, c as YaImageProps, M as YaText, S as YaTextProps, u as useContentStore } from './MarkdownText-mylt-QX-.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+
+interface StaticLinkProps {
+    fieldId: string;
+    href?: string;
+    className?: string;
+    as?: 'a' | 'span';
+    children?: React.ReactNode;
+    /** Optional click handler called after navigation */
+    onClick?: () => void;
+}
+declare function StaticLink({ fieldId, href: defaultHref, className, as: Component, children, onClick }: StaticLinkProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * SafeHtml (Production) - Renders trusted HTML without sanitization.
+ *
+ * Content is trusted because:
+ * 1. It's created in the builder using Tiptap (controlled markup)
+ * 2. Sanitized by DOMPurify when saved in the builder
+ * 3. Users can't inject arbitrary HTML into content.json
+ */
+interface SafeHtmlProps {
+    content: string;
+    className?: string;
+    mode?: 'read-only' | 'inline-edit';
+}
+declare function SafeHtml({ content, className }: SafeHtmlProps): react_jsx_runtime.JSX.Element;
+
+export { SafeHtml, type SafeHtmlProps, StaticLink, type StaticLinkProps, StaticLink as YaLink, type StaticLinkProps as YaLinkProps };

package/dist/prod.js

@@ -0,0 +1,295 @@
+// src/components/ContentStoreProvider.prod.tsx
+import { createContext, useContext } from "react";
+
+// src/lib/content-registry.ts
+var contentMap = /* @__PURE__ */ new Map();
+function getContent(fieldId) {
+  return contentMap.get(fieldId) ?? "";
+}
+function getAllContent() {
+  return Object.fromEntries(contentMap);
+}
+
+// src/components/ContentStoreProvider.prod.tsx
+import { jsx } from "react/jsx-runtime";
+var contentMap2 = new Map(Object.entries(getAllContent()));
+var staticStore = {
+  getValue: (fieldId) => contentMap2.get(fieldId) ?? "",
+  setValue: () => {
+  },
+  // No-op in production
+  mode: "read-only",
+  setMode: () => {
+  },
+  // No-op in production
+  subscribe: () => () => {
+  },
+  // No-op, return empty unsubscribe
+  saveToWorker: void 0
+};
+var ContentStoreContext = createContext(staticStore);
+function useContentStore() {
+  return useContext(ContentStoreContext);
+}
+function ContentStoreProvider({ children }) {
+  return /* @__PURE__ */ jsx(ContentStoreContext.Provider, { value: staticStore, children });
+}
+
+// src/components/StaticText.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function MpText({ fieldId, className, as: Component = "span", children }) {
+  const content = getContent(fieldId) || (typeof children === "string" ? children : "");
+  return /* @__PURE__ */ jsx2(
+    Component,
+    {
+      className,
+      "data-field-id": fieldId,
+      dangerouslySetInnerHTML: { __html: content }
+    }
+  );
+}
+
+// src/lib/asset-resolver.ts
+var assetResolver = (path) => path;
+function resolveAssetUrl(path) {
+  if (!path) return "";
+  if (path.startsWith("http://") || path.startsWith("https://")) {
+    return path;
+  }
+  return assetResolver(path);
+}
+
+// src/components/StaticImage.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function parseImageValue(value) {
+  if (!value) {
+    return { src: "" };
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "object" && parsed.src) {
+      return parsed;
+    }
+  } catch {
+  }
+  return { src: value };
+}
+function getObjectPosition(imageData) {
+  if (imageData.focalPoint) {
+    return `${imageData.focalPoint.x}% ${imageData.focalPoint.y}%`;
+  }
+  return imageData.objectPosition || "50% 50%";
+}
+function MpImage({
+  fieldId,
+  className,
+  alt,
+  objectFit: propObjectFit,
+  objectPosition: propObjectPosition,
+  loading = "lazy",
+  fallbackSrc,
+  fallbackAlt
+}) {
+  const rawValue = getContent(fieldId);
+  const imageData = parseImageValue(rawValue);
+  const src = imageData.src || fallbackSrc || "";
+  const altText = imageData.alt || alt || fallbackAlt || "";
+  const objectFit = imageData.objectFit || propObjectFit || "cover";
+  const objectPosition = getObjectPosition(imageData) || propObjectPosition || "50% 50%";
+  return /* @__PURE__ */ jsx3(
+    "img",
+    {
+      src: resolveAssetUrl(src),
+      alt: altText,
+      className,
+      style: {
+        objectFit,
+        objectPosition
+      },
+      loading,
+      "data-field-id": fieldId
+    }
+  );
+}
+
+// src/components/StaticLink.tsx
+import { useLocation } from "wouter";
+
+// src/components/SafeHtml.prod.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function SafeHtml({ content, className }) {
+  return /* @__PURE__ */ jsx4(
+    "span",
+    {
+      className,
+      dangerouslySetInnerHTML: { __html: content }
+    }
+  );
+}
+
+// src/components/StaticLink.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function isInternalPath(path) {
+  if (!path) return false;
+  if (path.startsWith("#")) return false;
+  if (path.startsWith("//")) return false;
+  if (path.includes("://")) return false;
+  if (path.startsWith("mailto:") || path.startsWith("tel:")) return false;
+  return path.startsWith("/");
+}
+function StaticLink({ fieldId, href: defaultHref = "#", className, as: Component = "a", children, onClick }) {
+  const { getValue, mode } = useContentStore();
+  const [, navigate] = useLocation();
+  const textFieldId = `${fieldId}.text`;
+  const hrefFieldId = `${fieldId}.href`;
+  const storeText = getValue(textFieldId);
+  const storeHref = getValue(hrefFieldId);
+  const href = storeHref || defaultHref;
+  const hasStoreText = Boolean(storeText);
+  const hasStringChildren = typeof children === "string";
+  const hasReactChildren = children && !hasStringChildren;
+  const handleClick = (e) => {
+    if (href.startsWith("#")) {
+      e.preventDefault();
+      const targetId = href.substring(1);
+      const targetElement = document.getElementById(targetId);
+      if (targetElement) {
+        const navHeight = 118;
+        const targetPosition = targetElement.offsetTop - navHeight;
+        window.scrollTo({
+          top: targetPosition,
+          behavior: "smooth"
+        });
+      }
+      onClick?.();
+      return;
+    }
+    if (isInternalPath(href)) {
+      e.preventDefault();
+      navigate(href);
+      onClick?.();
+      return;
+    }
+    onClick?.();
+  };
+  return /* @__PURE__ */ jsx5(
+    Component,
+    {
+      href: Component === "a" ? href : void 0,
+      onClick: handleClick,
+      className,
+      "data-ya-restricted": "true",
+      "data-field-id": fieldId,
+      children: hasStoreText || hasStringChildren ? /* @__PURE__ */ jsx5(SafeHtml, { content: storeText || children || "", mode }) : hasReactChildren ? children : null
+    }
+  );
+}
+
+// src/components/MarkdownText.tsx
+import { Fragment } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function tokenize(text) {
+  const tokens = [];
+  let remaining = text;
+  const patterns = [
+    // Bold: **text**
+    { regex: /^\*\*(.+?)\*\*/, type: "bold" },
+    // Italic: *text* (but not **)
+    { regex: /^\*([^*]+?)\*/, type: "italic" },
+    // Link: [text](url)
+    { regex: /^\[([^\]]+)\]\(([^)]+)\)/, type: "link" },
+    // Newline
+    { regex: /^\n/, type: "newline" }
+  ];
+  while (remaining.length > 0) {
+    let matched = false;
+    for (const pattern of patterns) {
+      const match = remaining.match(pattern.regex);
+      if (match) {
+        if (pattern.type === "bold") {
+          tokens.push({ type: "bold", content: match[1] });
+        } else if (pattern.type === "italic") {
+          tokens.push({ type: "italic", content: match[1] });
+        } else if (pattern.type === "link") {
+          tokens.push({ type: "link", text: match[1], url: match[2] });
+        } else if (pattern.type === "newline") {
+          tokens.push({ type: "newline" });
+        }
+        remaining = remaining.slice(match[0].length);
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      const nextSpecial = remaining.search(/[*[\n]/);
+      if (nextSpecial === -1) {
+        tokens.push({ type: "text", content: remaining });
+        remaining = "";
+      } else if (nextSpecial === 0) {
+        tokens.push({ type: "text", content: remaining[0] });
+        remaining = remaining.slice(1);
+      } else {
+        tokens.push({ type: "text", content: remaining.slice(0, nextSpecial) });
+        remaining = remaining.slice(nextSpecial);
+      }
+    }
+  }
+  const merged = [];
+  for (const token of tokens) {
+    const last = merged[merged.length - 1];
+    if (token.type === "text" && last?.type === "text") {
+      last.content += token.content;
+    } else {
+      merged.push(token);
+    }
+  }
+  return merged;
+}
+function tokensToElements(tokens) {
+  return tokens.map((token, index) => {
+    switch (token.type) {
+      case "text":
+        return /* @__PURE__ */ jsx6(Fragment, { children: token.content }, index);
+      case "bold":
+        return /* @__PURE__ */ jsx6("strong", { children: token.content }, index);
+      case "italic":
+        return /* @__PURE__ */ jsx6("em", { children: token.content }, index);
+      case "link":
+        return /* @__PURE__ */ jsx6(
+          "a",
+          {
+            href: token.url,
+            target: "_blank",
+            rel: "noopener noreferrer",
+            className: "text-[var(--color-primary)] underline hover:text-[var(--color-secondary)]",
+            children: token.text
+          },
+          index
+        );
+      case "newline":
+        return /* @__PURE__ */ jsx6("br", {}, index);
+      default:
+        return null;
+    }
+  });
+}
+function parseMarkdownToElements(content) {
+  const tokens = tokenize(content);
+  return tokensToElements(tokens);
+}
+function MarkdownText({ content, className }) {
+  const elements = parseMarkdownToElements(content);
+  return /* @__PURE__ */ jsx6("span", { className, children: elements });
+}
+export {
+  ContentStoreProvider,
+  MarkdownText,
+  SafeHtml,
+  MpImage as StaticImage,
+  StaticLink,
+  MpText as StaticText,
+  MpImage as YaImage,
+  StaticLink as YaLink,
+  MpText as YaText,
+  useContentStore
+};

package/dist/router.d.ts

@@ -0,0 +1,46 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode, MouseEvent } from 'react';
+
+/**
+ * Router Abstraction - Shared Types
+ *
+ * These types are used by both development (React Router) and
+ * production (wouter) router implementations.
+ */
+
+interface LinkProps {
+    /** Target path (alias: href) */
+    to?: string;
+    /** Target path (alias: to) */
+    href?: string;
+    children: ReactNode;
+    className?: string;
+    onClick?: (e: MouseEvent<HTMLAnchorElement>) => void;
+    replace?: boolean;
+    [key: string]: unknown;
+}
+interface RouterProps$1 {
+    children: ReactNode;
+    base?: string;
+}
+type NavigateFunction = (to: string, options?: {
+    replace?: boolean;
+}) => void;
+
+declare function Link({ to, href, children, className, onClick, replace, ...props }: LinkProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * useNavigate Hook - Production (wouter)
+ *
+ * Provides React Router-like useNavigate API using wouter's useLocation.
+ */
+
+declare function useNavigate(): NavigateFunction;
+
+interface RouterProps {
+    children: ReactNode;
+    base?: string;
+}
+declare function Router({ children, base }: RouterProps): react_jsx_runtime.JSX.Element;
+
+export { Link, type LinkProps, type NavigateFunction, Router, type RouterProps$1 as RouterProps, useNavigate };

package/dist/router.js

@@ -0,0 +1,42 @@
+// src/router/Link.tsx
+import { Link as WouterLink } from "wouter";
+import { jsx } from "react/jsx-runtime";
+function Link({ to, href, children, className, onClick, replace, ...props }) {
+  const target = href ?? to ?? "/";
+  return /* @__PURE__ */ jsx(WouterLink, { href: target, className, onClick, replace, ...props, children });
+}
+
+// src/router/useNavigate.ts
+import { useLocation } from "wouter";
+function useNavigate() {
+  const [, setLocation] = useLocation();
+  return (to, options) => {
+    if (options?.replace) {
+      window.history.replaceState(null, "", to);
+      setLocation(to);
+    } else {
+      setLocation(to);
+    }
+  };
+}
+
+// src/router/Router.tsx
+import { Router as WouterRouter } from "wouter";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function detectBasename() {
+  if (typeof window === "undefined") return "";
+  const sessionMatch = window.location.pathname.match(/^\/session\/[^/]+/);
+  if (sessionMatch) return sessionMatch[0];
+  const previewMatch = window.location.pathname.match(/^\/deploy-preview\/[^/]+/);
+  if (previewMatch) return previewMatch[0];
+  return "";
+}
+function Router({ children, base }) {
+  const basename = base ?? detectBasename();
+  return /* @__PURE__ */ jsx2(WouterRouter, { base: basename, children });
+}
+export {
+  Link,
+  Router,
+  useNavigate
+};

package/package.json

@@ -0,0 +1,115 @@
+{
+  "name": "@yoamigo.com/core",
+  "version": "0.1.0",
+  "description": "Core components, router, and utilities for YoAmigo templates",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js"
+    },
+    "./prod": {
+      "types": "./dist/prod.d.ts",
+      "import": "./dist/prod.js"
+    },
+    "./router": {
+      "types": "./dist/router.d.ts",
+      "import": "./dist/router.js"
+    },
+    "./lib": {
+      "types": "./dist/lib.d.ts",
+      "import": "./dist/lib.js"
+    },
+    "./lib/prod": {
+      "types": "./dist/lib-prod.d.ts",
+      "import": "./dist/lib-prod.js"
+    },
+    "./styles": "./src/styles/index.css",
+    "./styles/*": "./src/styles/*"
+  },
+  "files": [
+    "dist",
+    "src/styles",
+    "LICENSE",
+    "README.md"
+  ],
+  "sideEffects": [
+    "*.css"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yoamigo/sdk.git",
+    "directory": "packages/yoamigo-core"
+  },
+  "homepage": "https://yoamigo.com/developers",
+  "bugs": {
+    "url": "https://github.com/yoamigo/sdk/issues"
+  },
+  "keywords": [
+    "yoamigo",
+    "vite",
+    "vite-plugin",
+    "template",
+    "react",
+    "preact",
+    "website-builder"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:check": "eslint src --ext .ts,.tsx"
+  },
+  "dependencies": {
+    "clsx": "^2.1.1",
+    "preact": "^10.27.2",
+    "wouter": "^3.8.0"
+  },
+  "devDependencies": {
+    "@preact/preset-vite": "^2.8.0",
+    "@tiptap/core": "^3.11.1",
+    "@tiptap/extension-link": "^3.11.1",
+    "@tiptap/extension-text-style": "^3.11.1",
+    "@tiptap/pm": "^3.11.1",
+    "@tiptap/react": "^3.11.1",
+    "@tiptap/starter-kit": "^3.11.1",
+    "@types/dompurify": "^3.0.5",
+    "@types/node": "^20.0.0",
+    "@types/react": "^19.2.1",
+    "@types/react-dom": "^19.2.1",
+    "@vitejs/plugin-react": "^5.1.0",
+    "dompurify": "^3.2.3",
+    "react": "^19.2.1",
+    "react-dom": "^19.2.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.4"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0",
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
+  }
+}

package/src/styles/index.css

@@ -0,0 +1,5 @@
+/* @yoamigo/core styles - import all component styles */
+@import '../components/ya-text.css';
+@import '../components/ya-image.css';
+@import '../components/ya-link.css';
+@import '../components/ya-tooltip.css';