@squaredr/fieldcraft-pro 1.0.0 → 1.1.0

package/dist/{chunk-MQGR25NG.mjs → chunk-7LQW5QYT.mjs}

@@ -1,10 +1,8 @@
-import { requireLicense } from '@squaredr/fieldcraft-pro-license';
+import { requireLicense } from './chunk-VECQKSWS.mjs';
 import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
 import { cleanPreset, playfulPreset, clinicalPreset, highContrastPreset, modernPreset, darkPreset, FormEngineRenderer } from '@squaredr/fieldcraft-react';
 import { jsxs, jsx } from 'react/jsx-runtime';
 
-// src/theme-editor/ThemeEditor.tsx
-
 // src/theme-editor/preview-schema.ts
 var PREVIEW_SCHEMA = {
   id: "theme-preview",

package/dist/{chunk-DDQDYTMB.mjs → chunk-CJBC3KWB.mjs}

@@ -1,5 +1,5 @@
 import { cn } from './chunk-QQ4JZGTD.mjs';
-import { requireLicense } from '@squaredr/fieldcraft-pro-license';
+import { requireLicense } from './chunk-VECQKSWS.mjs';
 import { forwardRef, createContext, Component, useRef, useEffect, useCallback, useState, useMemo, useContext } from 'react';
 import { DndContext, DragOverlay, useSensors, useSensor, MouseSensor, TouchSensor, useDraggable, useDroppable } from '@dnd-kit/core';
 import { ChevronDown, Undo2, Redo2, Upload, Download, Save, Search, ChevronRight, Plus, Settings, Copy, Trash2, X, HelpCircle, MoveVertical, Minus, Video, Image, FileText, PartyPopper, Hand, ShieldCheck, SeparatorHorizontal, Info, Heading, Trophy, EyeOff, Calculator, CreditCard, MapPin, Repeat, Grid3X3, Camera, PenTool, Paperclip, CalendarCheck, CalendarRange, Clock, Calendar, ArrowUpDown, Globe, ToggleLeft, CheckSquare, CircleDot, ListOrdered, TrendingUp, BarChart3, Star, SlidersHorizontal, Hash, UserCheck, Link, PhoneCall, Phone, Mail, AlignLeft, Type, GripVertical } from 'lucide-react';

package/dist/{chunk-LOFGBNJV.mjs → chunk-RSU3X25P.mjs}

@@ -1,5 +1,5 @@
 import { cn } from './chunk-QQ4JZGTD.mjs';
-import { requireLicense } from '@squaredr/fieldcraft-pro-license';
+import { requireLicense } from './chunk-VECQKSWS.mjs';
 import { useState } from 'react';
 import { Button, Separator } from '@squaredr/fieldcraft-react';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';

package/dist/chunk-VECQKSWS.mjs

@@ -0,0 +1,582 @@
+import { createContext, useState, useEffect, useContext } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// ../license/dist/index.mjs
+var LEGACY_TIER_MAP = {
+  "01": "starter",
+  "02": "pro",
+  "03": "business",
+  "04": "enterprise"
+};
+var TIER_MAP_NUMERIC = {
+  1: "starter",
+  2: "pro",
+  3: "business",
+  4: "enterprise"
+};
+var PRO_FEATURES = [
+  "SchemaEditor",
+  "ResponseViewer",
+  "ThemeEditor",
+  "FormBuilder",
+  "ApiManager",
+  "Analytics"
+];
+var ALL_FEATURES = [
+  ...PRO_FEATURES,
+  "Telehealth"
+];
+var TIER_FEATURES = {
+  starter: ["SchemaEditor", "ResponseViewer"],
+  pro: PRO_FEATURES,
+  business: ALL_FEATURES,
+  enterprise: ALL_FEATURES
+};
+var HMAC_SECRET = "e50a657813a5ab9563050728a605b9ab58b911d5c1a9f48c6825f379a533ccd7685d11d01937d9f135776a0db3efeefe29b3e5282b27ede8cee93758f94f2d75";
+var B32_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+function base32hexDecode(str) {
+  const upper = str.toUpperCase();
+  let bits = 0;
+  let value = 0;
+  const bytes = [];
+  for (let i = 0; i < upper.length; i++) {
+    const idx = B32_CHARS.indexOf(upper[i]);
+    if (idx === -1) return null;
+    value = value << 5 | idx;
+    bits += 5;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(value >>> bits & 255);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+function parseLegacyKey(key) {
+  const parts = key.split("-");
+  if (parts.length !== 5) return null;
+  const [p1, p2, tierHex, expiryHex, hash] = parts;
+  if (p1 !== "FC" || p2 !== "PRO") return null;
+  if (!(tierHex in LEGACY_TIER_MAP)) return null;
+  if (!/^[0-9A-Fa-f]{8}$/.test(expiryHex)) return null;
+  if (!/^[0-9A-Fa-f]{8}$/.test(hash)) return null;
+  return { format: "legacy", tierHex, expiryHex, hash };
+}
+function parseOpaqueKey(key) {
+  const stripped = key.replace(/-/g, "");
+  if (!stripped.startsWith("FCPRO")) return null;
+  const encoded = stripped.slice(5);
+  const decoded = base32hexDecode(encoded);
+  if (!decoded || decoded.length < 17) return null;
+  const tier = decoded[0];
+  if (!(tier in TIER_MAP_NUMERIC)) return null;
+  const expiryTimestamp = decoded[1] << 24 | decoded[2] << 16 | decoded[3] << 8 | decoded[4];
+  const expiryUnsigned = expiryTimestamp >>> 0;
+  const nonce = decoded.slice(5, 9);
+  const signature = decoded.slice(9, 17);
+  return { format: "opaque", tier, expiryTimestamp: expiryUnsigned, nonce, signature };
+}
+function parseKey(key) {
+  if (!key || typeof key !== "string") return null;
+  if (key.startsWith("FCPRO-")) {
+    return parseOpaqueKey(key);
+  }
+  return parseLegacyKey(key);
+}
+async function computeHmacLegacy(tierHex, expiryHex) {
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(HMAC_SECRET);
+  const message = encoder.encode(`FC-PRO-${tierHex}-${expiryHex}`);
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    keyData,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", cryptoKey, message);
+  const hashBytes = new Uint8Array(signature).slice(0, 4);
+  return Array.from(hashBytes).map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
+}
+async function computeHmacOpaque(payload) {
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(HMAC_SECRET);
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    keyData,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", cryptoKey, payload);
+  return new Uint8Array(signature).slice(0, 8);
+}
+function isExpiredLegacy(expiryHex) {
+  const expiryTimestamp = parseInt(expiryHex, 16);
+  if (expiryTimestamp === 4294967295) return false;
+  return Date.now() / 1e3 > expiryTimestamp;
+}
+function isExpiredOpaque(expiryTimestamp) {
+  if (expiryTimestamp === 4294967295) return false;
+  return Date.now() / 1e3 > expiryTimestamp;
+}
+async function validateLicense(key) {
+  if (!key || typeof key !== "string") {
+    return { status: "invalid", tier: null };
+  }
+  const parsed = parseKey(key);
+  if (!parsed) {
+    return { status: "invalid", tier: null };
+  }
+  if (parsed.format === "opaque") {
+    const payload = new Uint8Array(9);
+    payload[0] = parsed.tier;
+    payload[1] = parsed.expiryTimestamp >>> 24 & 255;
+    payload[2] = parsed.expiryTimestamp >>> 16 & 255;
+    payload[3] = parsed.expiryTimestamp >>> 8 & 255;
+    payload[4] = parsed.expiryTimestamp & 255;
+    payload.set(parsed.nonce, 5);
+    const expectedSig = await computeHmacOpaque(payload);
+    let match = true;
+    for (let i = 0; i < 8; i++) {
+      if (parsed.signature[i] !== expectedSig[i]) {
+        match = false;
+        break;
+      }
+    }
+    if (!match) {
+      return { status: "invalid", tier: null };
+    }
+    const tier2 = TIER_MAP_NUMERIC[parsed.tier];
+    if (!tier2) {
+      return { status: "invalid", tier: null };
+    }
+    if (isExpiredOpaque(parsed.expiryTimestamp)) {
+      return { status: "expired", tier: tier2 };
+    }
+    return { status: "valid", tier: tier2 };
+  }
+  const expectedHash = await computeHmacLegacy(parsed.tierHex, parsed.expiryHex);
+  if (parsed.hash.toUpperCase() !== expectedHash) {
+    return { status: "invalid", tier: null };
+  }
+  const tier = LEGACY_TIER_MAP[parsed.tierHex];
+  if (isExpiredLegacy(parsed.expiryHex)) {
+    return { status: "expired", tier };
+  }
+  return { status: "valid", tier };
+}
+function tierHasFeature(tier, featureName) {
+  return TIER_FEATURES[tier]?.includes(featureName) ?? false;
+}
+var DEV_HOSTNAMES = /* @__PURE__ */ new Set([
+  "localhost",
+  "127.0.0.1",
+  "0.0.0.0",
+  "[::1]",
+  "::1"
+]);
+var DEV_HOSTNAME_PATTERNS = [
+  /^192\.168\.\d+\.\d+$/,
+  // local network
+  /^10\.\d+\.\d+\.\d+$/,
+  // local network
+  /^172\.(1[6-9]|2\d|3[01])\.\d+\.\d+$/
+  // local network
+];
+var PRODUCTION_HOST_SUFFIXES = [
+  ".vercel.app",
+  ".netlify.app",
+  ".netlify.com",
+  ".herokuapp.com",
+  ".fly.dev",
+  ".railway.app",
+  ".render.com",
+  ".onrender.com",
+  ".pages.dev",
+  // Cloudflare Pages
+  ".workers.dev",
+  // Cloudflare Workers
+  ".azurewebsites.net",
+  ".web.app",
+  // Firebase
+  ".firebaseapp.com",
+  ".amplifyapp.com",
+  ".surge.sh",
+  ".github.io",
+  ".gitlab.io"
+];
+function isDevHostname(hostname) {
+  if (DEV_HOSTNAMES.has(hostname)) return true;
+  for (const pattern of DEV_HOSTNAME_PATTERNS) {
+    if (pattern.test(hostname)) return true;
+  }
+  return false;
+}
+function isKnownProductionHost(hostname) {
+  for (const suffix of PRODUCTION_HOST_SUFFIXES) {
+    if (hostname.endsWith(suffix)) return true;
+  }
+  return false;
+}
+function hasRealTLD(hostname) {
+  return /\.[a-z]{2,}$/i.test(hostname) && !isDevHostname(hostname);
+}
+function isProductionEnvironment() {
+  const _proc = typeof globalThis !== "undefined" ? globalThis.process : void 0;
+  if (_proc?.env) {
+    const nodeEnv = _proc.env.NODE_ENV;
+    if (nodeEnv === "production") return true;
+    if (nodeEnv === "development" || nodeEnv === "test") return false;
+  }
+  if (typeof window !== "undefined" && window.location) {
+    const { hostname, protocol, port } = window.location;
+    if (protocol === "file:") return false;
+    if (isDevHostname(hostname)) return false;
+    if (port && port !== "443" && port !== "80") return false;
+    if (isKnownProductionHost(hostname)) return true;
+    if (protocol === "https:" && hasRealTLD(hostname)) return true;
+    if (hasRealTLD(hostname)) return true;
+  }
+  return false;
+}
+var PING_URL = "https://squaredr.tech/api/license/ping";
+var CACHE_KEY = "fcpro_lp";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function hashKey(key) {
+  let hash = 0;
+  for (let i = 0; i < key.length; i++) {
+    hash = (hash << 5) - hash + key.charCodeAt(i) | 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+function cacheId(key) {
+  return `${CACHE_KEY}_${hashKey(key)}`;
+}
+function readCache(key) {
+  if (typeof window === "undefined" || !window.localStorage) return null;
+  try {
+    const raw = localStorage.getItem(cacheId(key));
+    if (!raw) return null;
+    const entry = JSON.parse(raw);
+    if (Date.now() - entry.ts > CACHE_TTL_MS) {
+      localStorage.removeItem(cacheId(key));
+      return null;
+    }
+    return entry;
+  } catch {
+    return null;
+  }
+}
+function writeCache(key, status, tier, reason = null) {
+  if (typeof window === "undefined" || !window.localStorage) return;
+  try {
+    const entry = { s: status, t: tier, r: reason, ts: Date.now() };
+    localStorage.setItem(cacheId(key), JSON.stringify(entry));
+  } catch {
+  }
+}
+function getCachedPingResult(key) {
+  const cached = readCache(key);
+  if (!cached) return null;
+  return { status: cached.s, tier: cached.t, reason: cached.r || void 0 };
+}
+async function performPing(key) {
+  const cached = readCache(key);
+  if (cached) {
+    return { status: cached.s, tier: cached.t };
+  }
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const res = await fetch(PING_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ key }),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = await res.json();
+    const tier = data.tier || null;
+    if (data.status === "active") {
+      writeCache(key, "valid", tier);
+      return { status: "valid", tier };
+    }
+    if (data.status === "revoked") {
+      writeCache(key, "revoked", null, data.reason);
+      return { status: "revoked", tier: null, reason: data.reason };
+    }
+    if (data.status === "expired") {
+      writeCache(key, "expired", tier);
+      return { status: "expired", tier };
+    }
+    if (data.status === "domain_mismatch") {
+      writeCache(key, "domain_mismatch", null, data.reason);
+      return { status: "domain_mismatch", tier: null, reason: data.reason };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var defaultContext = { status: "validating", tier: null };
+var LicenseCtx = createContext(defaultContext);
+function FieldCraftProProvider({ licenseKey, children }) {
+  const [license, setLicense] = useState(defaultContext);
+  useEffect(() => {
+    let cancelled = false;
+    setLicense(defaultContext);
+    validateLicense(licenseKey).then((clientResult) => {
+      if (cancelled) return;
+      setLicense(clientResult);
+      if (clientResult.status !== "valid" || !isProductionEnvironment()) return;
+      const cached = getCachedPingResult(licenseKey);
+      if (cached) {
+        if (cached.status === "revoked" || cached.status === "domain_mismatch") {
+          setLicense({ status: cached.status, tier: null });
+        }
+        return;
+      }
+      performPing(licenseKey).then((pingResult) => {
+        if (cancelled) return;
+        if (!pingResult) return;
+        if (pingResult.status === "revoked" || pingResult.status === "domain_mismatch") {
+          setLicense({ status: pingResult.status, tier: null });
+        }
+      });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [licenseKey]);
+  return /* @__PURE__ */ jsx(LicenseCtx.Provider, { value: license, children });
+}
+function useLicense() {
+  return useContext(LicenseCtx);
+}
+function UnlicensedOverlay({ featureName, reason, children }) {
+  return /* @__PURE__ */ jsxs("div", { style: { position: "relative", minHeight: "200px" }, children: [
+    /* @__PURE__ */ jsx("div", { style: { pointerEvents: "none", userSelect: "none", filter: "blur(2px)" }, children }),
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          inset: 0,
+          zIndex: 2147483647,
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "center",
+          justifyContent: "center",
+          backgroundColor: "rgba(0, 0, 0, 0.75)",
+          backdropFilter: "blur(4px)",
+          fontFamily: "system-ui, -apple-system, sans-serif",
+          padding: "32px"
+        },
+        children: [
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              style: {
+                position: "absolute",
+                inset: 0,
+                overflow: "hidden",
+                pointerEvents: "none",
+                zIndex: 0
+              },
+              children: Array.from({ length: 12 }).map((_, i) => /* @__PURE__ */ jsx(
+                "div",
+                {
+                  style: {
+                    position: "absolute",
+                    top: `${i * 80}px`,
+                    left: "-50%",
+                    right: "-50%",
+                    textAlign: "center",
+                    transform: "rotate(-30deg)",
+                    fontSize: "18px",
+                    fontWeight: 700,
+                    color: "rgba(255, 255, 255, 0.06)",
+                    letterSpacing: "8px",
+                    textTransform: "uppercase",
+                    whiteSpace: "nowrap",
+                    userSelect: "none"
+                  },
+                  children: "UNLICENSED \u2022 FIELDCRAFT PRO \u2022 UNLICENSED \u2022 FIELDCRAFT PRO \u2022 UNLICENSED \u2022 FIELDCRAFT PRO"
+                },
+                i
+              ))
+            }
+          ),
+          /* @__PURE__ */ jsxs(
+            "div",
+            {
+              style: {
+                position: "relative",
+                zIndex: 1,
+                textAlign: "center",
+                maxWidth: "420px"
+              },
+              children: [
+                /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    style: {
+                      width: "64px",
+                      height: "64px",
+                      margin: "0 auto 16px",
+                      borderRadius: "50%",
+                      backgroundColor: "rgba(239, 68, 68, 0.2)",
+                      border: "2px solid rgba(239, 68, 68, 0.5)",
+                      display: "flex",
+                      alignItems: "center",
+                      justifyContent: "center",
+                      fontSize: "28px"
+                    },
+                    children: "\u{1F6E1}"
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    style: {
+                      fontSize: "22px",
+                      fontWeight: 700,
+                      color: "#ffffff",
+                      marginBottom: "8px",
+                      letterSpacing: "-0.02em"
+                    },
+                    children: "License Required"
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    style: {
+                      fontSize: "15px",
+                      fontWeight: 600,
+                      color: "#f87171",
+                      marginBottom: "6px"
+                    },
+                    children: featureName
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    style: {
+                      fontSize: "14px",
+                      color: "#d1d5db",
+                      marginBottom: "24px",
+                      lineHeight: "1.5"
+                    },
+                    children: reason
+                  }
+                ),
+                /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "10px", justifyContent: "center", flexWrap: "wrap" }, children: [
+                  /* @__PURE__ */ jsx(
+                    "a",
+                    {
+                      href: "https://squaredr.tech/products/fieldcraft/admin-pro#pricing",
+                      target: "_blank",
+                      rel: "noopener noreferrer",
+                      style: {
+                        display: "inline-block",
+                        padding: "12px 24px",
+                        fontSize: "14px",
+                        fontWeight: 600,
+                        color: "#ffffff",
+                        backgroundColor: "#2563eb",
+                        borderRadius: "8px",
+                        textDecoration: "none",
+                        boxShadow: "0 4px 14px rgba(37, 99, 235, 0.4)"
+                      },
+                      children: "Get a License"
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    "a",
+                    {
+                      href: "https://discord.gg/zMxdu5UVW",
+                      target: "_blank",
+                      rel: "noopener noreferrer",
+                      style: {
+                        display: "inline-block",
+                        padding: "12px 24px",
+                        fontSize: "14px",
+                        fontWeight: 600,
+                        color: "#93c5fd",
+                        backgroundColor: "rgba(37, 99, 235, 0.15)",
+                        border: "1px solid rgba(37, 99, 235, 0.4)",
+                        borderRadius: "8px",
+                        textDecoration: "none"
+                      },
+                      children: "Join Discord"
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsxs(
+                  "div",
+                  {
+                    style: {
+                      fontSize: "12px",
+                      color: "#6b7280",
+                      marginTop: "16px"
+                    },
+                    children: [
+                      "This component works freely in development.",
+                      " ",
+                      /* @__PURE__ */ jsx(
+                        "a",
+                        {
+                          href: "https://squaredr.tech/products/fieldcraft/docs/pro/license",
+                          target: "_blank",
+                          rel: "noopener noreferrer",
+                          style: { color: "#9ca3af", textDecoration: "underline" },
+                          children: "Learn more"
+                        }
+                      )
+                    ]
+                  }
+                )
+              ]
+            }
+          )
+        ]
+      }
+    )
+  ] });
+}
+function requireLicense(Component, featureName) {
+  function LicenseGated(props) {
+    const { status, tier } = useLicense();
+    const isProduction = isProductionEnvironment();
+    if (!isProduction) {
+      return /* @__PURE__ */ jsx(Component, { ...props });
+    }
+    if (status === "validating") {
+      return null;
+    }
+    const isLicensed = status === "valid" && tier != null && tierHasFeature(tier, featureName);
+    if (isLicensed) {
+      return /* @__PURE__ */ jsx(Component, { ...props });
+    }
+    let reason = "A valid license is required for production use.";
+    if (status === "invalid") {
+      reason = "Invalid license key. Please check your license key and try again.";
+    } else if (status === "expired") {
+      reason = "Your license has expired. Please renew to continue using this component in production.";
+    } else if (status === "revoked") {
+      reason = "This license key has been revoked. Please contact support or purchase a new license.";
+    } else if (status === "domain_mismatch") {
+      reason = "This license key is registered to a different domain. Each key can only be used on one production domain. Please purchase a new license for this domain.";
+    } else if (!tier || !tierHasFeature(tier, featureName)) {
+      reason = "Your license does not include this feature. Please upgrade your plan.";
+    }
+    return /* @__PURE__ */ jsx(UnlicensedOverlay, { featureName, reason, children: /* @__PURE__ */ jsx(Component, { ...props }) });
+  }
+  LicenseGated.displayName = `requireLicense(${Component.displayName || Component.name || "Component"})`;
+  return LicenseGated;
+}
+
+export { FieldCraftProProvider, UnlicensedOverlay, isProductionEnvironment, requireLicense, useLicense, validateLicense };