@glasshome/widget-sdk 0.2.1 → 0.2.4

package/dist/schemas.d.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+/**
+ * Runtime validation schemas for widget data structures.
+ *
+ * These mirror the TypeScript interfaces in types.ts but work at runtime —
+ * use them at HTTP and database boundaries to catch type mismatches early
+ * instead of letting them surface as cryptic SQLite or JSON errors.
+ */
+export declare const GridSizeSchema: z.ZodObject<{
+    w: z.ZodNumber;
+    h: z.ZodNumber;
+}, z.core.$strip>;
+export declare const WidgetManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    minSize: z.ZodObject<{
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>;
+    maxSize: z.ZodObject<{
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>;
+    sdkVersion: z.ZodString;
+    icon: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    defaultConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const PublishRequestSchema: z.ZodObject<{
+    action: z.ZodLiteral<"request">;
+    scope: z.ZodString;
+    name: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    minSize: z.ZodObject<{
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>;
+    maxSize: z.ZodObject<{
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>;
+    sdkVersion: z.ZodString;
+    version: z.ZodString;
+    bundleSize: z.ZodNumber;
+    sha256Hash: z.ZodString;
+    manifestJson: z.ZodString;
+}, z.core.$strip>;
+export declare const PublishConfirmSchema: z.ZodObject<{
+    action: z.ZodLiteral<"confirm">;
+    versionId: z.ZodString;
+}, z.core.$strip>;
+export declare const PublishBodySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"request">;
+    scope: z.ZodString;
+    name: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    minSize: z.ZodObject<{
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>;
+    maxSize: z.ZodObject<{
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>;
+    sdkVersion: z.ZodString;
+    version: z.ZodString;
+    bundleSize: z.ZodNumber;
+    sha256Hash: z.ZodString;
+    manifestJson: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"confirm">;
+    versionId: z.ZodString;
+}, z.core.$strip>], "action">;
+/**
+ * Serialize a GridSize to a JSON string for database storage.
+ */
+export declare function serializeGridSize(size: z.infer<typeof GridSizeSchema>): string;
+/**
+ * Parse a GridSize from a database text column or API response.
+ * Accepts a JSON string, an already-parsed object, or garbage.
+ * Returns the fallback for any value that doesn't validate.
+ */
+export declare function parseGridSize(raw: unknown, fallback?: z.infer<typeof GridSizeSchema>): z.infer<typeof GridSizeSchema>;
+/**
+ * Format a zod error into a single user-friendly string.
+ * Groups issues by path so the output reads like a bulleted list.
+ */
+export declare function formatSchemaError(error: z.ZodError): string;

package/dist/schemas.js

@@ -0,0 +1,63 @@
+import { z as n } from "zod";
+const t = n.object({
+  w: n.number().int().min(1),
+  h: n.number().int().min(1)
+}), u = n.object({
+  name: n.string().min(1),
+  description: n.string().optional(),
+  minSize: t,
+  maxSize: t,
+  sdkVersion: n.string().min(1),
+  icon: n.string().optional(),
+  schema: n.record(n.string(), n.unknown()).optional(),
+  defaultConfig: n.record(n.string(), n.unknown()).optional()
+}), o = /^[a-z0-9][a-z0-9-]*$/, a = n.object({
+  action: n.literal("request"),
+  scope: n.string().regex(o, "Must be lowercase alphanumeric with hyphens"),
+  name: n.string().min(1),
+  displayName: n.string().min(1),
+  description: n.string().optional(),
+  icon: n.string().optional(),
+  minSize: t,
+  maxSize: t,
+  sdkVersion: n.string().min(1),
+  version: n.string().min(1),
+  bundleSize: n.number().int().positive(),
+  sha256Hash: n.string().min(1),
+  manifestJson: n.string().min(1)
+}), c = n.object({
+  action: n.literal("confirm"),
+  versionId: n.string().min(1)
+}), p = n.discriminatedUnion("action", [
+  a,
+  c
+]);
+function h(i) {
+  return JSON.stringify(i);
+}
+function l(i, e = { w: 1, h: 1 }) {
+  if (i != null && typeof i == "object") {
+    const s = t.safeParse(i);
+    if (s.success) return s.data;
+  }
+  if (typeof i == "string")
+    try {
+      const s = JSON.parse(i), r = t.safeParse(s);
+      if (r.success) return r.data;
+    } catch {
+    }
+  return e;
+}
+function g(i) {
+  return i.issues.map((e) => `${e.path.length > 0 ? e.path.join(".") : "(root)"}: ${e.message}`).join("; ");
+}
+export {
+  t as GridSizeSchema,
+  p as PublishBodySchema,
+  c as PublishConfirmSchema,
+  a as PublishRequestSchema,
+  u as WidgetManifestSchema,
+  g as formatSchemaError,
+  l as parseGridSize,
+  h as serializeGridSize
+};

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { ZodType } from "zod";
 /**
  * Grid size constraint — number of columns (w) and rows (h).
  */
@@ -10,15 +11,16 @@ export interface GridSize {
  * Framework-agnostic: no SolidJS imports.
  */
 export interface WidgetManifest {
-    tag: string;
     name: string;
     description?: string;
     minSize: GridSize;
     maxSize: GridSize;
+    defaultSize?: GridSize;
     sdkVersion: string;
     icon?: string;
     schema?: object;
     defaultConfig?: Record<string, unknown>;
+    configVersion?: number;
 }
 /**
  * Runtime context provided to widgets by the host.
@@ -45,6 +47,8 @@ export interface WidgetContext {
  */
 export interface WidgetDefinition<C = Record<string, unknown>> {
     manifest: WidgetManifest;
+    configSchema?: ZodType<C, unknown>;
+    migrate?: (config: Record<string, unknown>, fromConfigVersion: number) => Record<string, unknown>;
     component: (props: {
         config: C;
     }) => any;

package/dist/vite/index.js

@@ -1,86 +1,91 @@
-import { existsSync as a, rmSync as x, mkdirSync as w, readdirSync as v, statSync as b, readFileSync as D, writeFileSync as S } from "node:fs";
-import { resolve as l, join as g, sep as h, dirname as W } from "node:path";
-import { fileURLToPath as I } from "node:url";
-const j = "virtual:glasshome-widget", p = "\0virtual:glasshome-widget", E = "/@glasshome/preview";
-function y(e) {
-  return h === "\\" ? e.split(h).join("/") : e;
+import { createHash as I } from "node:crypto";
+import { existsSync as l, rmSync as N, mkdirSync as P, readdirSync as x, statSync as O, readFileSync as h, writeFileSync as b } from "node:fs";
+import { resolve as a, join as g, sep as v, dirname as E } from "node:path";
+import { fileURLToPath as _ } from "node:url";
+function R(e) {
+  const n = JSON.stringify(e, Object.keys(e).sort());
+  return I("sha256").update(n).digest("hex").slice(0, 16);
 }
-function f() {
-  const e = I(import.meta.url);
-  return l(W(e), "../../preview");
+const k = "virtual:glasshome-widget", S = "\0virtual:glasshome-widget", T = "/@glasshome/preview";
+function D(e) {
+  return v === "\\" ? e.split(v).join("/") : e;
 }
-function P(e) {
+function y() {
+  const e = _(import.meta.url);
+  return a(E(e), "../../preview");
+}
+function j(e) {
   return e === "solid-js" || e.startsWith("solid-js/") || e === "@glasshome/widget-sdk" || e.startsWith("@glasshome/widget-sdk/") || e === "@glasshome/ui" || e.startsWith("@glasshome/ui/") || e === "@glasshome/sync-layer" || e.startsWith("@glasshome/sync-layer/");
 }
-function _(e) {
-  const i = [];
-  if (!a(e)) return i;
-  for (const r of v(e)) {
-    const n = l(e, r);
-    if (!b(n).isDirectory()) continue;
-    const t = l(n, "index.tsx"), s = l(n, "manifest.json");
-    a(t) && a(s) && i.push({ name: r, entry: t });
+function F(e) {
+  const n = [];
+  if (!l(e)) return n;
+  for (const r of x(e)) {
+    const o = a(e, r);
+    if (!O(o).isDirectory()) continue;
+    const i = a(o, "index.tsx"), t = a(o, "manifest.json");
+    l(i) && l(t) && n.push({ name: r, entry: i });
   }
-  return i;
+  return n;
 }
-function O(e, i) {
+function J(e, n) {
   const r = [];
-  if (a(e))
-    for (const t of v(e)) {
-      if (!b(g(e, t)).isDirectory()) continue;
-      const s = g(e, t, "manifest.json");
+  if (l(e))
+    for (const i of x(e)) {
+      if (!O(g(e, i)).isDirectory()) continue;
+      const t = g(e, i, "manifest.json");
       try {
-        const o = JSON.parse(D(s, "utf-8"));
-        r.push({ ...o, bundleUrl: `./${t}.js` });
+        const s = JSON.parse(h(t, "utf-8"));
+        r.push({ ...s, bundleUrl: `./${i}.js` });
       } catch {
       }
     }
-  const n = {
+  const o = {
     version: 1,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     baseUrl: "./",
     widgets: r
   };
-  a(i) || w(i, { recursive: !0 }), S(g(i, "registry.json"), JSON.stringify(n, null, 2)), console.log(`[registry] Generated registry.json with ${r.length} widget(s)`);
+  l(n) || P(n, { recursive: !0 }), b(g(n, "registry.json"), JSON.stringify(o, null, 2)), console.log(`[registry] Generated registry.json with ${r.length} widget(s)`);
 }
-async function R(e) {
-  const { build: i } = await import("vite"), r = process.cwd(), n = l(r, e?.srcDir ?? "src"), t = l(r, e?.outDir ?? "dist");
-  let s = _(n);
-  if (s.length === 0) {
-    console.warn("[glasshome-widgets] No widgets found in", n);
+async function U(e) {
+  const { build: n } = await import("vite"), r = process.cwd(), o = a(r, e?.srcDir ?? "src"), i = a(r, e?.outDir ?? "dist");
+  let t = F(o);
+  if (t.length === 0) {
+    console.warn("[glasshome-widgets] No widgets found in", o);
     return;
   }
   if (e?.only) {
-    const o = new Set(e.only);
-    s = s.filter((u) => o.has(u.name));
+    const s = new Set(e.only);
+    t = t.filter((c) => s.has(c.name));
   }
-  e?.only || a(t) && x(t, { recursive: !0 }), a(t) || w(t, { recursive: !0 });
-  for (const o of s)
-    await i({
+  e?.only || l(i) && N(i, { recursive: !0 }), l(i) || P(i, { recursive: !0 });
+  for (const s of t)
+    await n({
       configFile: !1,
       root: r,
       plugins: e?.plugins ?? [],
       ...e?.viteConfig,
       build: {
         lib: {
-          entry: o.entry,
+          entry: s.entry,
           formats: ["es"],
-          fileName: o.name
+          fileName: s.name
         },
         rollupOptions: {
-          external: P
+          external: j
         },
-        outDir: t,
+        outDir: i,
         emptyOutDir: !1,
         copyPublicDir: !1,
         ...e?.viteConfig?.build
       },
       logLevel: "warn"
     });
-  O(n, t);
+  J(o, i);
 }
-function L(e) {
-  const i = e?.entry ?? "src/index.tsx";
+function C(e) {
+  const n = e?.entry ?? "src/index.tsx";
   return [{
     name: "glasshome-widget:build",
     apply: "build",
@@ -88,67 +93,92 @@ function L(e) {
       return {
         build: {
           lib: {
-            entry: i,
+            entry: n,
             formats: ["es"],
             fileName: "index"
           },
           rollupOptions: {
-            external: P
+            external: j
           }
         }
       };
     }
+  }, {
+    name: "glasshome-widget:schema",
+    apply: "build",
+    async closeBundle() {
+      const t = a(process.cwd(), "dist", "index.js");
+      if (l(t))
+        try {
+          const c = (await import(`${t}?t=${Date.now()}`)).default;
+          if (!c?.configSchema) return;
+          const { z: m } = await import("zod"), f = m.toJSONSchema(c.configSchema, { unrepresentable: "any" }), d = a(process.cwd(), "manifest.json");
+          if (l(d)) {
+            const w = JSON.parse(h(d, "utf-8"));
+            w.schema = f, b(d, JSON.stringify(w, null, 2));
+          }
+          const u = R(f), p = a(process.cwd(), ".schema-hash");
+          if (l(p) && h(p, "utf-8").trim() !== u) {
+            const W = c.manifest?.name ?? "unknown";
+            console.warn(
+              `[widget-sdk] Schema shape changed for "${W}" — verify configVersion was bumped`
+            );
+          }
+          b(p, u);
+        } catch {
+        }
+    }
   }, {
     name: "glasshome-widget:dev",
     apply: "serve",
     enforce: "pre",
     config() {
-      const t = f(), s = process.cwd(), o = l(s, "..", "..");
+      const t = y(), s = process.cwd(), c = a(s, "..", "..");
       return {
         server: {
           fs: {
-            allow: [t, s, o]
+            allow: [t, s, c]
           }
         }
       };
     },
     configureServer(t) {
-      const s = f(), o = g(s, "preview.html");
-      t.middlewares.use(async (u, d, m) => {
-        if (u.url === "/" || u.url === "/index.html")
+      const s = y(), c = g(s, "preview.html");
+      t.middlewares.use(async (m, f, d) => {
+        if (m.url === "/" || m.url === "/index.html")
           try {
-            let c = D(o, "utf-8");
-            c = await t.transformIndexHtml(u.url, c), d.setHeader("Content-Type", "text/html"), d.statusCode = 200, d.end(c);
-          } catch (c) {
-            m(c);
+            let u = h(c, "utf-8");
+            u = await t.transformIndexHtml(m.url, u), f.setHeader("Content-Type", "text/html"), f.statusCode = 200, f.end(u);
+          } catch (u) {
+            d(u);
           }
         else
-          m();
+          d();
       });
     },
     resolveId(t) {
-      if (t === E) {
-        const s = f();
-        return y(g(s, "host.tsx"));
+      if (t === T) {
+        const s = y();
+        return D(g(s, "host.tsx"));
       }
-      if (t === j)
-        return p;
+      if (t === k)
+        return S;
     },
     load(t) {
-      if (t === p)
-        return `export { default } from "${y(l(process.cwd(), i))}";`;
+      if (t === S)
+        return `export { default } from "${D(a(process.cwd(), n))}";`;
     }
   }];
 }
-function k(e) {
-  const i = e?.srcDir ?? "src", r = e?.outDir ?? "dist";
-  let n = [];
+function A(e) {
+  const n = e?.srcDir ?? "src", r = e?.outDir ?? "dist";
+  let o = [];
   return [{
     name: "glasshome-widgets:build",
     apply: "build",
-    config(s) {
-      return n = (s.plugins ?? []).flat().filter(Boolean).filter(
-        (o) => !o.name?.startsWith("glasshome-widgets:")
+    config(t) {
+      return o = (t.plugins ?? []).flat().filter(Boolean).filter(
+        (s) => !s.name?.startsWith("glasshome-widgets:")
       ), {
         build: {
           rollupOptions: {
@@ -159,26 +189,26 @@ function k(e) {
         }
       };
     },
-    resolveId(s) {
-      if (s === "\0glasshome-noop") return s;
+    resolveId(t) {
+      if (t === "\0glasshome-noop") return t;
     },
-    load(s) {
-      if (s === "\0glasshome-noop") return "export {}";
+    load(t) {
+      if (t === "\0glasshome-noop") return "export {}";
     },
     async closeBundle() {
-      await R({
-        srcDir: i,
+      await U({
+        srcDir: n,
         outDir: r,
-        plugins: n
+        plugins: o
       });
     }
   }];
 }
 export {
-  R as buildWidgets,
-  _ as discoverWidgets,
-  O as generateRegistry,
-  L as glasshomeWidget,
-  k as glasshomeWidgets,
-  P as isWidgetExternal
+  U as buildWidgets,
+  F as discoverWidgets,
+  J as generateRegistry,
+  C as glasshomeWidget,
+  A as glasshomeWidgets,
+  j as isWidgetExternal
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glasshome/widget-sdk",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "description": "SDK for building GlassHome dashboard widgets with SolidJS",
   "keywords": [
     "glasshome",

package/preview/host.tsx

@@ -41,7 +41,7 @@ function PreviewHost() {
               "margin-top": "4px",
             }}
           >
-            <{widget.manifest.tag}> | {widget.manifest.type} | {widget.manifest.size}
+            <{widget.manifest.name}> | {widget.manifest.type} | {widget.manifest.size}
           </p>
         </div>
         <button