@featurevisor/catalog 0.0.1 → 3.1.0

package/src/styles.css

@@ -0,0 +1,59 @@
+@import "tailwindcss";
+@config "../tailwind.config.mts";
+
+:root {
+  color-scheme: light;
+
+  --mv-color-background: #e5e7eb;
+  --mv-color-surface: #ffffff;
+  --mv-color-elevated: #f8fafc;
+  --mv-color-border: #e5e7eb;
+  --mv-color-text: #374151;
+  --mv-color-muted: #6b7280;
+  --mv-color-primary: #475569;
+  --mv-color-success: #16a34a;
+  --mv-color-warning: #ea580c;
+  --mv-color-danger: #dc2626;
+  --mv-color-header: #1f2937;
+  --mv-color-header-active: #374151;
+  --mv-color-header-text: #f9fafb;
+  --mv-color-pill: #cbd5e1;
+  --mv-color-faint: #9ca3af;
+  --mv-color-success-surface: #bbf7d0;
+  --mv-color-warning-surface: #fed7aa;
+  --mv-color-danger-surface: #fee2e2;
+  --mv-shadow-soft: 0 10px 30px rgb(15 23 42 / 0.08);
+}
+
+body {
+  margin: 0;
+  background: var(--mv-color-background);
+  color: var(--mv-color-text);
+  font-family:
+    ui-sans-serif,
+    system-ui,
+    -apple-system,
+    BlinkMacSystemFont,
+    "Segoe UI",
+    sans-serif;
+}
+
+a {
+  color: inherit;
+}
+
+.variable-schema-col-path {
+  width: 28%;
+}
+
+.variable-schema-col-type {
+  width: 14%;
+}
+
+.variable-schema-col-constraints {
+  width: 30%;
+}
+
+.variable-schema-col-description {
+  width: 28%;
+}

package/src/testModel.ts

@@ -0,0 +1,123 @@
+import type {
+  AssertionMatrix,
+  FeatureAssertion,
+  SegmentAssertion,
+  Test,
+} from "@featurevisor/types";
+
+export interface ExpandedTestAssertion {
+  assertion: FeatureAssertion | SegmentAssertion;
+  assertionIndex: number;
+  caseIndex?: number;
+  caseCount?: number;
+  label: string;
+  matrixValues?: Record<string, unknown>;
+}
+
+function getMatrixCombinations(matrix: AssertionMatrix) {
+  const keys = Object.keys(matrix);
+
+  if (keys.length === 0) {
+    return [];
+  }
+
+  return keys.reduce<Array<Record<string, unknown>>>(
+    (combinations, key) =>
+      combinations.flatMap((combination) =>
+        matrix[key].map((value) => ({ ...combination, [key]: value })),
+      ),
+    [{}],
+  );
+}
+
+function applyCombinationToValue(value: unknown, combination: Record<string, unknown>) {
+  if (typeof value !== "string") {
+    return value;
+  }
+
+  const placeholders = value.match(/\${{(.+?)}}/g);
+  if (!placeholders) {
+    return value;
+  }
+
+  if (placeholders.length === 1 && value.startsWith("${{") && value.endsWith("}}")) {
+    const key = value.replace("${{", "").replace("}}", "").trim();
+    return combination[key];
+  }
+
+  return value.replace(/\${{(.+?)}}/g, (_, key) => String(combination[key.trim()]));
+}
+
+function applyCombinationToContext(
+  context: Record<string, unknown> | undefined,
+  combination: Record<string, unknown>,
+) {
+  return Object.fromEntries(
+    Object.entries(context || {}).map(([key, value]) => [
+      key,
+      applyCombinationToValue(value, combination),
+    ]),
+  );
+}
+
+function applyCombinationToAssertion(
+  test: Test,
+  assertion: FeatureAssertion | SegmentAssertion,
+  combination: Record<string, unknown>,
+) {
+  const result = {
+    ...assertion,
+    context: applyCombinationToContext(assertion.context, combination),
+  };
+  delete result.matrix;
+
+  if (result.description) {
+    result.description = String(applyCombinationToValue(result.description, combination));
+  }
+
+  if ("feature" in test) {
+    const featureResult = result as FeatureAssertion;
+    featureResult.environment = applyCombinationToValue(
+      featureResult.environment,
+      combination,
+    ) as FeatureAssertion["environment"];
+    featureResult.target = applyCombinationToValue(
+      featureResult.target,
+      combination,
+    ) as FeatureAssertion["target"];
+    const at = applyCombinationToValue(featureResult.at, combination);
+    featureResult.at = (
+      typeof at === "string" ? (at.includes(".") ? parseFloat(at) : parseInt(at, 10)) : at
+    ) as FeatureAssertion["at"];
+  }
+
+  return result;
+}
+
+export function expandTestAssertions(test: Test): ExpandedTestAssertion[] {
+  return test.assertions.flatMap((assertion, assertionIndex) => {
+    if (!assertion.matrix) {
+      return [
+        {
+          assertion: { ...assertion },
+          assertionIndex,
+          label: String(assertionIndex + 1),
+        },
+      ];
+    }
+
+    const combinations = getMatrixCombinations(assertion.matrix);
+    return combinations.map((combination, caseIndex) => ({
+      assertion: applyCombinationToAssertion(test, assertion, combination),
+      assertionIndex,
+      caseIndex,
+      caseCount: combinations.length,
+      label: `${assertionIndex + 1}.${caseIndex + 1}`,
+      matrixValues: combination,
+    }));
+  });
+}
+
+export function getTestAssertionPermalink(testKey: string, assertionLabel: string) {
+  return `${testKey}:${assertionLabel}`;
+}

package/src/types.ts

@@ -0,0 +1,112 @@
+import type { EntityType, Test } from "@featurevisor/types";
+
+export type CatalogEntityType = EntityType;
+export type EntityPath =
+  | "features"
+  | "segments"
+  | "attributes"
+  | "targets"
+  | "groups"
+  | "schemas"
+  | "tests";
+export type GitProvider = "github" | "gitlab" | "bitbucket";
+export type DevEditorId = "cursor" | "vscode";
+
+export interface DevEditor {
+  id: DevEditorId;
+  label: string;
+  icon: DevEditorId;
+}
+
+export interface LastModified {
+  commit: string;
+  author: string;
+  timestamp: string;
+}
+
+export interface EntitySummary {
+  key: string;
+  description?: string;
+  archived?: boolean;
+  deprecated?: boolean;
+  promotable?: boolean;
+  environmentStatus?: "production" | "other" | "disabled";
+  environmentStatusEnvironment?: string;
+  tags?: string[];
+  targets?: string[];
+  usedInFeatureCount?: number;
+  usedInSegmentCount?: number;
+  environments?: string[];
+  variationValues?: string[];
+  variableKeys?: string[];
+  hasVariations?: boolean;
+  hasVariables?: boolean;
+  lastModified?: LastModified;
+  href: string;
+}
+
+export interface CatalogIndex {
+  set: string;
+  counts: Record<CatalogEntityType, number>;
+  entities: Record<CatalogEntityType, EntitySummary[]>;
+}
+
+export interface CatalogManifest {
+  schemaVersion: string;
+  generatedAt: string;
+  router?: "hash" | "browser";
+  sets: boolean;
+  setKeys: string[];
+  projectConfig: {
+    tags: string[];
+    environments?: string[];
+  };
+  dev?: {
+    editors: DevEditor[];
+  };
+  links?: {
+    provider?: GitProvider;
+    repository?: string;
+    source: string;
+    commit: string;
+  };
+  paths: {
+    projectHistory: string;
+    root?: string;
+    sets?: Record<string, string>;
+  };
+  counts: Record<string, Record<CatalogEntityType, number>>;
+}
+
+export interface HistoryEntity {
+  type: CatalogEntityType;
+  key: string;
+  set?: string;
+}
+
+export interface HistoryEntry {
+  commit: string;
+  author: string;
+  timestamp: string;
+  entities: HistoryEntity[];
+}
+
+export interface HistoryPage {
+  page: number;
+  pageSize: number;
+  totalPages: number;
+  entries: HistoryEntry[];
+}
+
+export interface EntityDetail<T = Record<string, unknown>> {
+  type: CatalogEntityType;
+  key: string;
+  entity: T;
+  sourcePath?: string;
+  editLinks?: Partial<Record<DevEditorId, string>>;
+  lastModified?: LastModified;
+  relationships?: Record<string, string[]>;
+  tests?: Test[];
+  environments?: string[];
+  historyPath?: string;
+}

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/index.js

@@ -1 +0,0 @@
-module.exports = {};