@decantr/registry 1.0.2 → 1.0.3

package/dist/index.js

@@ -1,262 +1,3 @@
-// src/types.ts
-var CONTENT_TYPES = [
-  "pattern",
-  "theme",
-  "blueprint",
-  "archetype",
-  "shell"
-];
-var API_CONTENT_TYPES = [
-  "patterns",
-  "themes",
-  "blueprints",
-  "archetypes",
-  "shells"
-];
-var CONTENT_TYPE_TO_API_CONTENT_TYPE = {
-  pattern: "patterns",
-  theme: "themes",
-  blueprint: "blueprints",
-  archetype: "archetypes",
-  shell: "shells"
-};
-var API_CONTENT_TYPE_TO_CONTENT_TYPE = {
-  patterns: "pattern",
-  themes: "theme",
-  blueprints: "blueprint",
-  archetypes: "archetype",
-  shells: "shell"
-};
-function isContentType(value) {
-  return CONTENT_TYPES.includes(value);
-}
-function isApiContentType(value) {
-  return API_CONTENT_TYPES.includes(value);
-}
-var PUBLIC_CONTENT_SOURCES = [
-  "official",
-  "community",
-  "organization"
-];
-function isPublicContentSource(value) {
-  return PUBLIC_CONTENT_SOURCES.includes(value);
-}
-var CONTENT_INTELLIGENCE_SOURCES = [
-  "authored",
-  "benchmark",
-  "hybrid"
-];
-function isContentIntelligenceSource(value) {
-  return CONTENT_INTELLIGENCE_SOURCES.includes(value);
-}
-
-// src/resolver.ts
-import { readFile } from "fs/promises";
-import { join } from "path";
-var TYPE_DIRS = {
-  pattern: "patterns",
-  archetype: "archetypes",
-  theme: "themes",
-  blueprint: "blueprints",
-  shell: "shells"
-};
-async function tryLoadJson(filePath) {
-  try {
-    const content = await readFile(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function createResolver(options) {
-  const { contentRoot, overridePaths = [] } = options;
-  return {
-    async resolve(type, id) {
-      const dir = TYPE_DIRS[type];
-      const fileName = `${id}.json`;
-      for (const overridePath of overridePaths) {
-        const filePath = join(overridePath, dir, fileName);
-        const item = await tryLoadJson(filePath);
-        if (item) return { item, source: "local", path: filePath };
-      }
-      const mainPath = join(contentRoot, dir, fileName);
-      const mainItem = await tryLoadJson(mainPath);
-      if (mainItem) return { item: mainItem, source: "core", path: mainPath };
-      const corePath = join(contentRoot, "core", dir, fileName);
-      const coreItem = await tryLoadJson(corePath);
-      if (coreItem) return { item: coreItem, source: "core", path: corePath };
-      return null;
-    }
-  };
-}
-
-// src/pattern.ts
-function resolvePatternPreset(pattern, explicitPreset, themeDefaultPresets) {
-  const presets = pattern.presets;
-  const hasPresets = Object.keys(presets).length > 0;
-  if (!hasPresets) {
-    return {
-      preset: "",
-      layout: { layout: "row", atoms: "" },
-      code: pattern.code ?? { imports: "", example: "" }
-    };
-  }
-  let presetName = explicitPreset;
-  if (presetName && !presets[presetName]) presetName = void 0;
-  if (!presetName && themeDefaultPresets?.[pattern.id]) {
-    const themeName = themeDefaultPresets[pattern.id];
-    if (presets[themeName]) presetName = themeName;
-  }
-  if (!presetName) presetName = pattern.default_preset;
-  if (!presetName || !presets[presetName]) presetName = Object.keys(presets)[0];
-  const preset = presets[presetName];
-  return { preset: presetName, layout: preset.layout, code: preset.code };
-}
-
-// src/wiring.ts
-var WIRING_RULES = [
-  {
-    pair: ["filter-bar", "data-table"],
-    signals: [
-      { name: "pageSearch", init: "''", hookType: "search" },
-      { name: "pageStatus", init: "'all'", hookType: "filter" }
-    ],
-    props: {
-      "filter-bar": { onSearch: "setPageSearch", onCategory: "setPageStatus" },
-      "data-table": { search: "pageSearch", status: "pageStatus" }
-    },
-    hookProps: {
-      "filter-bar": { search: "search", filters: "filters" },
-      "data-table": { search: "search", filters: "filters" }
-    }
-  },
-  {
-    pair: ["filter-bar", "activity-feed"],
-    signals: [
-      { name: "pageSearch", init: "''", hookType: "search" },
-      { name: "pageView", init: "'all'", hookType: "filter" }
-    ],
-    props: {
-      "filter-bar": { onSearch: "setPageSearch", onView: "setPageView" },
-      "activity-feed": { search: "pageSearch", view: "pageView" }
-    },
-    hookProps: {
-      "filter-bar": { search: "search", filters: "filters" },
-      "activity-feed": { search: "search", filters: "filters" }
-    }
-  },
-  {
-    pair: ["filter-bar", "card-grid"],
-    signals: [
-      { name: "pageSearch", init: "''", hookType: "search" }
-    ],
-    props: {
-      "filter-bar": { onSearch: "setPageSearch" },
-      "card-grid": { search: "pageSearch" }
-    },
-    hookProps: {
-      "filter-bar": { search: "search" },
-      "card-grid": { search: "search" }
-    }
-  }
-];
-function getPatternId(item) {
-  if (typeof item === "string") return item;
-  if ("pattern" in item) return item.pattern;
-  return null;
-}
-function deriveIOWirings(layoutIds, patternIOMap) {
-  const edges = [];
-  const layoutSet = new Set(layoutIds);
-  for (const producerId of layoutIds) {
-    const producerIO = patternIOMap.get(producerId);
-    if (!producerIO?.produces?.length) continue;
-    for (const consumerId of layoutIds) {
-      if (producerId === consumerId) continue;
-      if (!layoutSet.has(consumerId)) continue;
-      const consumerIO = patternIOMap.get(consumerId);
-      if (!consumerIO?.consumes?.length) continue;
-      const shared = producerIO.produces.filter(
-        (signal) => consumerIO.consumes.includes(signal)
-      );
-      if (shared.length > 0) {
-        edges.push({ producer: producerId, consumer: consumerId, signals: shared });
-      }
-    }
-  }
-  return edges;
-}
-function buildIOMap(entries) {
-  const map = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    map.set(entry.id, entry.io);
-  }
-  return map;
-}
-function detectWirings(layout, patternIOMap) {
-  const patternIds = layout.map(getPatternId).filter((id) => id !== null);
-  const results = [];
-  const coveredPairs = /* @__PURE__ */ new Set();
-  for (const rule of WIRING_RULES) {
-    const [a, b] = rule.pair;
-    if (patternIds.includes(a) && patternIds.includes(b)) {
-      results.push({ rule, signals: rule.signals, props: rule.props, hookProps: rule.hookProps });
-      coveredPairs.add(`${a}:${b}`);
-      coveredPairs.add(`${b}:${a}`);
-    }
-  }
-  if (patternIOMap) {
-    const ioEdges = deriveIOWirings(patternIds, patternIOMap);
-    for (const edge of ioEdges) {
-      const pairKey = `${edge.producer}:${edge.consumer}`;
-      if (coveredPairs.has(pairKey)) continue;
-      coveredPairs.add(pairKey);
-      const signals = edge.signals.map((sig) => {
-        const camel = toCamelCase(sig);
-        return {
-          name: `page${capitalize(camel)}`,
-          init: "''",
-          hookType: classifySignal(sig)
-        };
-      });
-      const producerProps = {};
-      const consumerProps = {};
-      const producerHookProps = {};
-      const consumerHookProps = {};
-      for (const sig of edge.signals) {
-        const camel = toCamelCase(sig);
-        const stateName = `page${capitalize(camel)}`;
-        const setterName = `set${capitalize(stateName)}`;
-        producerProps[`on${capitalize(camel)}`] = setterName;
-        consumerProps[sig] = stateName;
-        producerHookProps[sig] = sig;
-        consumerHookProps[sig] = sig;
-      }
-      const rule = {
-        pair: [edge.producer, edge.consumer],
-        signals,
-        props: { [edge.producer]: producerProps, [edge.consumer]: consumerProps },
-        hookProps: { [edge.producer]: producerHookProps, [edge.consumer]: consumerHookProps }
-      };
-      results.push({ rule, signals, props: rule.props, hookProps: rule.hookProps });
-    }
-  }
-  return results;
-}
-function toCamelCase(str) {
-  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-}
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-function classifySignal(signal) {
-  const normalized = toCamelCase(signal);
-  if (normalized === "search") return "search";
-  if (normalized === "selection") return "selection";
-  if (normalized === "sort") return "sort";
-  return "filter";
-}
-
 // src/api-client.ts
 var DEFAULT_BASE_URL = "https://api.decantr.ai/v1";
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -297,7 +38,7 @@ var RegistryAPIClient = class {
   // ── HTTP helpers ──
   buildHeaders() {
     const headers = {
-      "Accept": "application/json"
+      Accept: "application/json"
     };
     if (this.apiKey) {
       headers["X-API-Key"] = this.apiKey;
@@ -378,7 +119,8 @@ var RegistryAPIClient = class {
     if (params?.source) searchParams.set("source", params.source);
     if (params?.sort) searchParams.set("sort", params.sort);
     if (params?.recommended) searchParams.set("recommended", "true");
-    if (params?.intelligenceSource) searchParams.set("intelligence_source", params.intelligenceSource);
+    if (params?.intelligenceSource)
+      searchParams.set("intelligence_source", params.intelligenceSource);
     if (params?.limit) searchParams.set("limit", String(params.limit));
     if (params?.offset) searchParams.set("offset", String(params.offset));
     const query = searchParams.toString();
@@ -436,7 +178,8 @@ var RegistryAPIClient = class {
     if (params.source) searchParams.set("source", params.source);
     if (params.sort) searchParams.set("sort", params.sort);
     if (params.recommended) searchParams.set("recommended", "true");
-    if (params.intelligenceSource) searchParams.set("intelligence_source", params.intelligenceSource);
+    if (params.intelligenceSource)
+      searchParams.set("intelligence_source", params.intelligenceSource);
     if (params.limit) searchParams.set("limit", String(params.limit));
     if (params.offset) searchParams.set("offset", String(params.offset));
     return this.request(`/search?${searchParams}`);
@@ -458,7 +201,8 @@ var RegistryAPIClient = class {
     if (params?.source) searchParams.set("source", params.source);
     if (params?.sort) searchParams.set("sort", params.sort);
     if (params?.recommended) searchParams.set("recommended", "true");
-    if (params?.intelligenceSource) searchParams.set("intelligence_source", params.intelligenceSource);
+    if (params?.intelligenceSource)
+      searchParams.set("intelligence_source", params.intelligenceSource);
     if (params?.limit != null) searchParams.set("limit", String(params.limit));
     if (params?.offset != null) searchParams.set("offset", String(params.offset));
     const query = searchParams.toString();
@@ -540,27 +284,21 @@ var RegistryAPIClient = class {
     const searchParams = new URLSearchParams();
     if (params?.namespace) searchParams.set("namespace", params.namespace);
     const query = searchParams.toString();
-    return this.request(
-      `/packs/compile${query ? `?${query}` : ""}`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(essence)
-      }
-    );
+    return this.request(`/packs/compile${query ? `?${query}` : ""}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(essence)
+    });
   }
   async selectExecutionPack(input, params) {
     const searchParams = new URLSearchParams();
     if (params?.namespace) searchParams.set("namespace", params.namespace);
     const query = searchParams.toString();
-    return this.request(
-      `/packs/select${query ? `?${query}` : ""}`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(input)
-      }
-    );
+    return this.request(`/packs/select${query ? `?${query}` : ""}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input)
+    });
   }
   async getExecutionPackManifest(essence, params) {
     const selected = await this.selectExecutionPack(
@@ -576,27 +314,21 @@ var RegistryAPIClient = class {
     const searchParams = new URLSearchParams();
     if (params?.namespace) searchParams.set("namespace", params.namespace);
     const query = searchParams.toString();
-    return this.request(
-      `/critique/file${query ? `?${query}` : ""}`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(input)
-      }
-    );
+    return this.request(`/critique/file${query ? `?${query}` : ""}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input)
+    });
   }
   async auditProject(input, params) {
     const searchParams = new URLSearchParams();
     if (params?.namespace) searchParams.set("namespace", params.namespace);
     const query = searchParams.toString();
-    return this.request(
-      `/audit/project${query ? `?${query}` : ""}`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(input)
-      }
-    );
+    return this.request(`/audit/project${query ? `?${query}` : ""}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input)
+    });
   }
 };
 function createRegistryClient(options = {}) {
@@ -620,6 +352,29 @@ function createRegistryClient(options = {}) {
   };
 }
 
+// src/pattern.ts
+function resolvePatternPreset(pattern, explicitPreset, themeDefaultPresets) {
+  const presets = pattern.presets;
+  const hasPresets = Object.keys(presets).length > 0;
+  if (!hasPresets) {
+    return {
+      preset: "",
+      layout: { layout: "row", atoms: "" },
+      code: pattern.code ?? { imports: "", example: "" }
+    };
+  }
+  let presetName = explicitPreset;
+  if (presetName && !presets[presetName]) presetName = void 0;
+  if (!presetName && themeDefaultPresets?.[pattern.id]) {
+    const themeName = themeDefaultPresets[pattern.id];
+    if (presets[themeName]) presetName = themeName;
+  }
+  if (!presetName) presetName = pattern.default_preset;
+  if (!presetName || !presets[presetName]) presetName = Object.keys(presets)[0];
+  const preset = presets[presetName];
+  return { preset: presetName, layout: preset.layout, code: preset.code };
+}
+
 // src/ranking.ts
 function verificationScore(status) {
   switch (status) {
@@ -726,6 +481,224 @@ function comparePublicContent(a, b, sort = "recommended") {
 function sortPublicContent(items, sort = "recommended") {
   return [...items].sort((left, right) => comparePublicContent(left, right, sort));
 }
+
+// src/resolver.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+var TYPE_DIRS = {
+  pattern: "patterns",
+  archetype: "archetypes",
+  theme: "themes",
+  blueprint: "blueprints",
+  shell: "shells"
+};
+async function tryLoadJson(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function createResolver(options) {
+  const { contentRoot, overridePaths = [] } = options;
+  return {
+    async resolve(type, id) {
+      const dir = TYPE_DIRS[type];
+      const fileName = `${id}.json`;
+      for (const overridePath of overridePaths) {
+        const filePath = join(overridePath, dir, fileName);
+        const item = await tryLoadJson(filePath);
+        if (item) return { item, source: "local", path: filePath };
+      }
+      const mainPath = join(contentRoot, dir, fileName);
+      const mainItem = await tryLoadJson(mainPath);
+      if (mainItem) return { item: mainItem, source: "core", path: mainPath };
+      const corePath = join(contentRoot, "core", dir, fileName);
+      const coreItem = await tryLoadJson(corePath);
+      if (coreItem) return { item: coreItem, source: "core", path: corePath };
+      return null;
+    }
+  };
+}
+
+// src/types.ts
+var CONTENT_TYPES = ["pattern", "theme", "blueprint", "archetype", "shell"];
+var API_CONTENT_TYPES = [
+  "patterns",
+  "themes",
+  "blueprints",
+  "archetypes",
+  "shells"
+];
+var CONTENT_TYPE_TO_API_CONTENT_TYPE = {
+  pattern: "patterns",
+  theme: "themes",
+  blueprint: "blueprints",
+  archetype: "archetypes",
+  shell: "shells"
+};
+var API_CONTENT_TYPE_TO_CONTENT_TYPE = {
+  patterns: "pattern",
+  themes: "theme",
+  blueprints: "blueprint",
+  archetypes: "archetype",
+  shells: "shell"
+};
+function isContentType(value) {
+  return CONTENT_TYPES.includes(value);
+}
+function isApiContentType(value) {
+  return API_CONTENT_TYPES.includes(value);
+}
+var PUBLIC_CONTENT_SOURCES = ["official", "community", "organization"];
+function isPublicContentSource(value) {
+  return PUBLIC_CONTENT_SOURCES.includes(value);
+}
+var CONTENT_INTELLIGENCE_SOURCES = ["authored", "benchmark", "hybrid"];
+function isContentIntelligenceSource(value) {
+  return CONTENT_INTELLIGENCE_SOURCES.includes(value);
+}
+
+// src/wiring.ts
+var WIRING_RULES = [
+  {
+    pair: ["filter-bar", "data-table"],
+    signals: [
+      { name: "pageSearch", init: "''", hookType: "search" },
+      { name: "pageStatus", init: "'all'", hookType: "filter" }
+    ],
+    props: {
+      "filter-bar": { onSearch: "setPageSearch", onCategory: "setPageStatus" },
+      "data-table": { search: "pageSearch", status: "pageStatus" }
+    },
+    hookProps: {
+      "filter-bar": { search: "search", filters: "filters" },
+      "data-table": { search: "search", filters: "filters" }
+    }
+  },
+  {
+    pair: ["filter-bar", "activity-feed"],
+    signals: [
+      { name: "pageSearch", init: "''", hookType: "search" },
+      { name: "pageView", init: "'all'", hookType: "filter" }
+    ],
+    props: {
+      "filter-bar": { onSearch: "setPageSearch", onView: "setPageView" },
+      "activity-feed": { search: "pageSearch", view: "pageView" }
+    },
+    hookProps: {
+      "filter-bar": { search: "search", filters: "filters" },
+      "activity-feed": { search: "search", filters: "filters" }
+    }
+  },
+  {
+    pair: ["filter-bar", "card-grid"],
+    signals: [{ name: "pageSearch", init: "''", hookType: "search" }],
+    props: {
+      "filter-bar": { onSearch: "setPageSearch" },
+      "card-grid": { search: "pageSearch" }
+    },
+    hookProps: {
+      "filter-bar": { search: "search" },
+      "card-grid": { search: "search" }
+    }
+  }
+];
+function getPatternId(item) {
+  if (typeof item === "string") return item;
+  if ("pattern" in item) return item.pattern;
+  return null;
+}
+function deriveIOWirings(layoutIds, patternIOMap) {
+  const edges = [];
+  const layoutSet = new Set(layoutIds);
+  for (const producerId of layoutIds) {
+    const producerIO = patternIOMap.get(producerId);
+    if (!producerIO?.produces?.length) continue;
+    for (const consumerId of layoutIds) {
+      if (producerId === consumerId) continue;
+      if (!layoutSet.has(consumerId)) continue;
+      const consumerIO = patternIOMap.get(consumerId);
+      if (!consumerIO?.consumes?.length) continue;
+      const shared = producerIO.produces.filter((signal) => consumerIO.consumes.includes(signal));
+      if (shared.length > 0) {
+        edges.push({ producer: producerId, consumer: consumerId, signals: shared });
+      }
+    }
+  }
+  return edges;
+}
+function buildIOMap(entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    map.set(entry.id, entry.io);
+  }
+  return map;
+}
+function detectWirings(layout, patternIOMap) {
+  const patternIds = layout.map(getPatternId).filter((id) => id !== null);
+  const results = [];
+  const coveredPairs = /* @__PURE__ */ new Set();
+  for (const rule of WIRING_RULES) {
+    const [a, b] = rule.pair;
+    if (patternIds.includes(a) && patternIds.includes(b)) {
+      results.push({ rule, signals: rule.signals, props: rule.props, hookProps: rule.hookProps });
+      coveredPairs.add(`${a}:${b}`);
+      coveredPairs.add(`${b}:${a}`);
+    }
+  }
+  if (patternIOMap) {
+    const ioEdges = deriveIOWirings(patternIds, patternIOMap);
+    for (const edge of ioEdges) {
+      const pairKey = `${edge.producer}:${edge.consumer}`;
+      if (coveredPairs.has(pairKey)) continue;
+      coveredPairs.add(pairKey);
+      const signals = edge.signals.map((sig) => {
+        const camel = toCamelCase(sig);
+        return {
+          name: `page${capitalize(camel)}`,
+          init: "''",
+          hookType: classifySignal(sig)
+        };
+      });
+      const producerProps = {};
+      const consumerProps = {};
+      const producerHookProps = {};
+      const consumerHookProps = {};
+      for (const sig of edge.signals) {
+        const camel = toCamelCase(sig);
+        const stateName = `page${capitalize(camel)}`;
+        const setterName = `set${capitalize(stateName)}`;
+        producerProps[`on${capitalize(camel)}`] = setterName;
+        consumerProps[sig] = stateName;
+        producerHookProps[sig] = sig;
+        consumerHookProps[sig] = sig;
+      }
+      const rule = {
+        pair: [edge.producer, edge.consumer],
+        signals,
+        props: { [edge.producer]: producerProps, [edge.consumer]: consumerProps },
+        hookProps: { [edge.producer]: producerHookProps, [edge.consumer]: consumerHookProps }
+      };
+      results.push({ rule, signals, props: rule.props, hookProps: rule.hookProps });
+    }
+  }
+  return results;
+}
+function toCamelCase(str) {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function classifySignal(signal) {
+  const normalized = toCamelCase(signal);
+  if (normalized === "search") return "search";
+  if (normalized === "selection") return "selection";
+  if (normalized === "sort") return "sort";
+  return "filter";
+}
 export {
   API_CONTENT_TYPES,
   API_CONTENT_TYPE_TO_CONTENT_TYPE,