@alphacifer/slidev-addon-theme 0.0.10 → 0.0.12

package/utils/comparisons/table-comparison/constants.ts

@@ -0,0 +1,47 @@
+export const DEFAULT_COL_COLORS: readonly string[] = [
+  'var(--alpha-table-comparison-col-1-background)',
+  'var(--alpha-table-comparison-col-2-background)',
+  'var(--alpha-table-comparison-col-3-background)',
+  'var(--alpha-table-comparison-col-4-background)',
+  'var(--alpha-table-comparison-col-5-background)',
+];
+
+export const DEFAULT_ROW_HEADER_COLOR = 'var(--alpha-table-comparison-row-bg)';
+export const DEFAULT_ROW_HEADER_TEXT_COLOR =
+  'var(--alpha-table-comparison-row)';
+export const DEFAULT_COL_HEADER_TEXT_COLOR =
+  'var(--alpha-table-comparison-col)';
+export const DEFAULT_CELL_BG = 'var(--alpha-table-comparison-cell-bg)';
+export const DEFAULT_CELL_COLOR = 'var(--alpha-table-comparison-cell)';
+export const DEFAULT_BORDER_RADIUS = '8px';
+export const DEFAULT_SPACING = '6px';
+export const DEFAULT_ROW_HEADER_WIDTH = '160px';
+
+/**
+ * Resolves a dimension input (number or string) into a CSS-ready unit string.
+ */
+export function resolveDimension(
+  value: number | string | undefined,
+  defaultUnit = 'px',
+): string | undefined {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  if (typeof value === 'number') {
+    return `${value}${defaultUnit}`;
+  }
+
+  const trimmed = value.trim();
+
+  if (!trimmed) {
+    return undefined;
+  }
+
+  // If already contains unit or percentage or calc/var, return as is
+  if (/^[+-]?\d+(\.\d+)?$/.test(trimmed)) {
+    return `${trimmed}${defaultUnit}`;
+  }
+
+  return trimmed;
+}

package/utils/{tableComparison → comparisons/table-comparison}/context.ts

@@ -13,12 +13,12 @@ export interface ITableComparisonContext {
   readonly animation: ComputedRef<boolean>;
 }
 
-export interface ITableComparisonColsContext {
+export interface ITableComparisonColumnsContext {
   readonly registerCol: () => number;
 }
 
 export const TABLE_COMPARISON_KEY: InjectionKey<ITableComparisonContext> =
   Symbol('TABLE_COMPARISON_KEY');
 
-export const TABLE_COMPARISON_COLS_KEY: InjectionKey<ITableComparisonColsContext> =
+export const TABLE_COMPARISON_COLS_KEY: InjectionKey<ITableComparisonColumnsContext> =
   Symbol('TABLE_COMPARISON_COLS_KEY');

package/utils/{arcOrbit → core/arc-orbit}/resolveArcOrbitItems.ts

@@ -14,10 +14,7 @@ export interface IResolvedArcOrbitItem {
   readonly textColor?: string;
 }
 
-export const DEFAULT_ARC_ORBIT_COLOR = '#ea580c';
-
-export const DEFAULT_LOREM_TEXT =
-  'Lorem ipsum dolor sit amet, constitutor adipiscing elit. Nam vulputate augue vel ligula.';
+export const DEFAULT_ARC_ORBIT_COLOR = 'var(--alpha-arc-orbit-accent)';
 
 export const DEFAULT_ARC_ORBIT_ITEMS: readonly [
   IResolvedArcOrbitItem,
@@ -27,26 +24,26 @@ export const DEFAULT_ARC_ORBIT_ITEMS: readonly [
 ] = [
   {
     id: '01',
-    title: 'Add Text Here',
-    description: DEFAULT_LOREM_TEXT,
+    title: '',
+    description: '',
     color: DEFAULT_ARC_ORBIT_COLOR,
   },
   {
     id: '02',
-    title: 'Add Text Here',
-    description: DEFAULT_LOREM_TEXT,
+    title: '',
+    description: '',
     color: DEFAULT_ARC_ORBIT_COLOR,
   },
   {
     id: '03',
-    title: 'Add Text Here',
-    description: DEFAULT_LOREM_TEXT,
+    title: '',
+    description: '',
     color: DEFAULT_ARC_ORBIT_COLOR,
   },
   {
     id: '04',
-    title: 'Add Text Here',
-    description: DEFAULT_LOREM_TEXT,
+    title: '',
+    description: '',
     color: DEFAULT_ARC_ORBIT_COLOR,
   },
 ];
@@ -73,9 +70,8 @@ export function resolveArcOrbitItems(
         ? custom.id
         : (defaultItem?.id ?? String(i + 1).padStart(2, '0'));
 
-    const title = custom?.title ?? defaultItem?.title ?? 'Add Text Here';
-    const description =
-      custom?.description ?? defaultItem?.description ?? DEFAULT_LOREM_TEXT;
+    const title = custom?.title ?? defaultItem?.title ?? '';
+    const description = custom?.description ?? defaultItem?.description ?? '';
     const color = custom?.color ?? defaultColor;
     const textColor = custom?.textColor ?? defaultItem?.textColor;
 

package/utils/{defenseInDepth/arcDid → defense-in-depth/arc-defense-in-depth}/context.ts

@@ -1,35 +1,38 @@
 import type { ComputedRef, InjectionKey, Ref } from 'vue';
 
 import type {
-  IArcDiDGeometry,
-  IArcDiDLayerGeometry,
-  IArcDiDPartItem,
-  IArcDiDSectorGeometry,
-  IArcDiDSectorItem,
-  TArcDiDOrder,
+  IArcDefenseInDepthGeometry,
+  IArcDefenseInDepthLayerGeometry,
+  IArcDefenseInDepthPartItem,
+  IArcDefenseInDepthSectorGeometry,
+  IArcDefenseInDepthSectorItem,
+  TArcDefenseInDepthOrder,
+  TArcDefenseInDepthOrientation,
 } from './types';
 
-export interface IArcDiDRegisteredSectorData {
-  readonly parts?: readonly IArcDiDPartItem[];
+export interface IArcDefenseInDepthRegisteredSectorData {
+  readonly parts?: readonly IArcDefenseInDepthPartItem[];
   readonly split?: boolean;
   readonly angle?: number;
   readonly span?: number;
   readonly color?: string;
   readonly index?: number;
-  readonly rotate?: boolean | number | 'tangent' | 'auto';
-  readonly skew?: boolean | number | string;
+  readonly rotate?: TArcDefenseInDepthOrientation;
+  readonly skew?: TArcDefenseInDepthOrientation;
 }
 
-export interface IArcDiDRegisteredLayerData {
+export interface IArcDefenseInDepthRegisteredLayerData {
   readonly title?: string;
   readonly color?: string;
-  readonly parts?: readonly IArcDiDPartItem[];
-  readonly sectors?: readonly IArcDiDSectorItem[];
+  readonly parts?: readonly IArcDefenseInDepthPartItem[];
+  readonly sectors?: readonly IArcDefenseInDepthSectorItem[];
   readonly index?: number;
+  readonly titleAngleSpan?: number;
+  readonly titleWidth?: number;
 }
 
-export interface IArcDiDRootContext {
-  readonly geo: ComputedRef<IArcDiDGeometry>;
+export interface IArcDefenseInDepthRootContext {
+  readonly geo: ComputedRef<IArcDefenseInDepthGeometry>;
   readonly count: ComputedRef<number>;
   readonly activeIndex: Ref<number> | ComputedRef<number>;
   readonly setActiveIndex: (index: number) => void;
@@ -45,39 +48,37 @@ export interface IArcDiDRootContext {
   ) => boolean;
   readonly color: ComputedRef<string>;
   readonly colors: ComputedRef<readonly string[] | undefined>;
-  readonly order: ComputedRef<TArcDiDOrder>;
+  readonly order: ComputedRef<TArcDefenseInDepthOrder>;
   readonly animation: ComputedRef<boolean>;
   readonly interactive: ComputedRef<boolean>;
   readonly startDelay: ComputedRef<number>;
   readonly getLayerColor: (index: number) => string;
   readonly registerLayer: (
     token?: symbol,
-    dataRef?: ComputedRef<IArcDiDRegisteredLayerData | undefined>,
+    dataRef?: ComputedRef<IArcDefenseInDepthRegisteredLayerData | undefined>,
   ) => {
     index: ComputedRef<number>;
     unregister: () => void;
   };
 }
 
-export interface IArcDiDSectorContext {
+export interface IArcDefenseInDepthSectorContext {
   readonly sectorIndex: ComputedRef<number>;
-  readonly sectorGeo: ComputedRef<IArcDiDSectorGeometry | undefined>;
-  readonly rotate?: ComputedRef<
-    boolean | number | 'tangent' | 'auto' | undefined
-  >;
-  readonly skew?: ComputedRef<boolean | number | string | undefined>;
+  readonly sectorGeo: ComputedRef<IArcDefenseInDepthSectorGeometry | undefined>;
+  readonly rotate?: ComputedRef<TArcDefenseInDepthOrientation | undefined>;
+  readonly skew?: ComputedRef<TArcDefenseInDepthOrientation | undefined>;
   readonly registerPart: (
     token?: symbol,
-    partDataRef?: ComputedRef<IArcDiDPartItem | undefined>,
+    partDataRef?: ComputedRef<IArcDefenseInDepthPartItem | undefined>,
   ) => {
     index: ComputedRef<number>;
     unregister: () => void;
   };
 }
 
-export interface IArcDiDLayerContext {
+export interface IArcDefenseInDepthLayerContext {
   readonly layerIndex: ComputedRef<number>;
-  readonly layerGeo: ComputedRef<IArcDiDLayerGeometry | undefined>;
+  readonly layerGeo: ComputedRef<IArcDefenseInDepthLayerGeometry | undefined>;
   readonly isActive: ComputedRef<boolean>;
   readonly color: ComputedRef<string>;
   readonly textColor?: ComputedRef<string | undefined>;
@@ -86,25 +87,27 @@ export interface IArcDiDLayerContext {
   readonly partsCount: ComputedRef<number>;
   readonly registerPart: (
     token?: symbol,
-    partDataRef?: ComputedRef<IArcDiDPartItem | undefined>,
+    partDataRef?: ComputedRef<IArcDefenseInDepthPartItem | undefined>,
   ) => {
     index: ComputedRef<number>;
     unregister: () => void;
   };
   readonly registerSector: (
     token?: symbol,
-    sectorDataRef?: ComputedRef<IArcDiDRegisteredSectorData | undefined>,
+    sectorDataRef?: ComputedRef<
+      IArcDefenseInDepthRegisteredSectorData | undefined
+    >,
   ) => {
     index: ComputedRef<number>;
     unregister: () => void;
   };
 }
 
-export const ARC_DID_ROOT_KEY: InjectionKey<IArcDiDRootContext> =
+export const ARC_DID_ROOT_KEY: InjectionKey<IArcDefenseInDepthRootContext> =
   Symbol('ARC_DID_ROOT_KEY');
 
-export const ARC_DID_LAYER_KEY: InjectionKey<IArcDiDLayerContext> =
+export const ARC_DID_LAYER_KEY: InjectionKey<IArcDefenseInDepthLayerContext> =
   Symbol('ARC_DID_LAYER_KEY');
 
-export const ARC_DID_SECTOR_KEY: InjectionKey<IArcDiDSectorContext> =
+export const ARC_DID_SECTOR_KEY: InjectionKey<IArcDefenseInDepthSectorContext> =
   Symbol('ARC_DID_SECTOR_KEY');

package/utils/{defenseInDepth/arcDid/createArcDiDGeometry.ts → defense-in-depth/arc-defense-in-depth/createArcDefenseInDepthGeometry.ts}

@@ -1,15 +1,15 @@
 import type {
-  IArcDiDDecorativeArc,
-  IArcDiDGeometry,
-  IArcDiDLayerGeometry,
-  IArcDiDLayerItem,
-  IArcDiDPartGeometry,
-  IArcDiDPartItem,
-  IArcDiDPoint,
-  IArcDiDSectorGeometry,
-  IArcDiDSectorItem,
-  ICreateArcDiDOptions,
-  TArcDiDOrder,
+  IArcDefenseInDepthDecorativeArc,
+  IArcDefenseInDepthGeometry,
+  IArcDefenseInDepthLayerGeometry,
+  IArcDefenseInDepthLayerItem,
+  IArcDefenseInDepthPartGeometry,
+  IArcDefenseInDepthPartItem,
+  IArcDefenseInDepthPoint,
+  IArcDefenseInDepthSectorGeometry,
+  IArcDefenseInDepthSectorItem,
+  ICreateArcDefenseInDepthOptions,
+  TArcDefenseInDepthOrder,
 } from './types';
 
 export function round(val: number, decimals = 2): number {
@@ -22,7 +22,7 @@ export function polarToCartesian(
   cy: number,
   radius: number,
   angleInDegrees: number,
-): IArcDiDPoint {
+): IArcDefenseInDepthPoint {
   const angleInRadians = (angleInDegrees * Math.PI) / 180;
   return {
     x: round(cx + radius * Math.cos(angleInRadians)),
@@ -68,19 +68,21 @@ export function describeArcBand(
   ].join(' ');
 }
 
-export interface IArcDiDSectorInfo {
+export interface IArcDefenseInDepthSectorInfo {
   readonly startAngle: number;
   readonly endAngle: number;
   readonly midAngle: number;
 }
 
-export interface IArcDiDTitleAngles {
+export interface IArcDefenseInDepthTitleAngles {
   readonly halfSpan: number;
   readonly titleLeft: number;
   readonly titleRight: number;
 }
 
-export function calculateTitleAngles(titleAngleSpan = 40): IArcDiDTitleAngles {
+function calculateTitleAngles(
+  titleAngleSpan = 40,
+): IArcDefenseInDepthTitleAngles {
   const halfSpan = round(titleAngleSpan / 2, 2);
   const titleLeft = round(90 + halfSpan, 1);
   const titleRight = round(90 - halfSpan, 1);
@@ -92,7 +94,10 @@ function resolveSpansDistribution(
   totalSpan: number,
   inputSpans?: readonly (number | undefined)[],
 ): number[] {
-  if (count <= 0) return [];
+  if (count <= 0) {
+    return [];
+  }
+
   if (
     !inputSpans ||
     inputSpans.length === 0 ||
@@ -106,6 +111,7 @@ function resolveSpansDistribution(
 
   for (let i = 0; i < count; i++) {
     const s = inputSpans[i];
+
     if (s !== undefined && s > 0) {
       specifiedSum += s;
     } else {
@@ -116,8 +122,10 @@ function resolveSpansDistribution(
   if (unspecifiedCount > 0) {
     const remaining = Math.max(0, totalSpan - specifiedSum);
     const perUnspecified = remaining / unspecifiedCount;
+
     return Array.from({ length: count }, (_, i) => {
       const s = inputSpans[i];
+
       return s !== undefined && s > 0 ? s : perUnspecified;
     });
   }
@@ -127,17 +135,18 @@ function resolveSpansDistribution(
     const headSpans = inputSpans.slice(0, count - 1).map((s) => s ?? 0);
     const headSum = headSpans.reduce((a, b) => a + b, 0);
     const lastSpan = Math.max(0, totalSpan - headSum);
+
     return [...headSpans, round(lastSpan, 2)];
   }
 
   return [totalSpan];
 }
 
-export function calculatePartSectors(
+function calculatePartSectors(
   partCount: number,
   titleAngleSpan = 40,
   sectorSpans?: readonly (number | undefined)[],
-): IArcDiDSectorInfo[] {
+): IArcDefenseInDepthSectorInfo[] {
   if (partCount <= 0) {
     return [];
   }
@@ -174,10 +183,11 @@ export function calculatePartSectors(
     rightSpansInput,
   );
 
-  const sectors: IArcDiDSectorInfo[] = [];
+  const sectors: IArcDefenseInDepthSectorInfo[] = [];
 
   // Left sectors: 180 down to titleLeft
   let currentLeft = 180;
+
   for (let i = 0; i < leftCount; i++) {
     const span = leftAllocatedSpans[i] ?? totalLeftSpan / leftCount;
     const start = currentLeft;
@@ -192,6 +202,7 @@ export function calculatePartSectors(
 
   // Right sectors: titleRight down to 0
   let currentRight = titleRight;
+
   for (let j = 0; j < rightCount; j++) {
     const span = rightAllocatedSpans[j] ?? totalRightSpan / rightCount;
     const start = currentRight;
@@ -214,7 +225,7 @@ export function calculatePartAngles(
   return calculatePartSectors(partCount, titleAngleSpan).map((s) => s.midAngle);
 }
 
-export function resolveLayerTitleSpan(
+function resolveLayerTitleSpan(
   midRadius: number,
   layerTitleAngleSpan?: number,
   globalTitleAngleSpan?: number,
@@ -223,10 +234,13 @@ export function resolveLayerTitleSpan(
   if (layerTitleAngleSpan !== undefined) {
     return Math.max(10, Math.min(80, layerTitleAngleSpan));
   }
+
   if (globalTitleAngleSpan !== undefined) {
     return Math.max(10, Math.min(80, globalTitleAngleSpan));
   }
+
   const computedAngle = (titleWidth / Math.max(1, midRadius)) * (180 / Math.PI);
+
   return Math.max(18, Math.min(50, round(computedAngle, 1)));
 }
 
@@ -235,13 +249,13 @@ export function createDecorativeArcs(
   _cy?: number,
   _outerRadius?: number,
   _innerRadius?: number,
-): readonly IArcDiDDecorativeArc[] {
+): readonly IArcDefenseInDepthDecorativeArc[] {
   return [];
 }
 
-export function createArcDiDGeometry(
-  options: ICreateArcDiDOptions = {},
-): IArcDiDGeometry {
+export function createArcDefenseInDepthGeometry(
+  options: ICreateArcDefenseInDepthOptions = {},
+): IArcDefenseInDepthGeometry {
   const viewBoxWidth = options.viewBoxWidth ?? 900;
   const viewBoxHeight = options.viewBoxHeight ?? 460;
   const cx = options.cx ?? round(viewBoxWidth / 2);
@@ -256,16 +270,17 @@ export function createArcDiDGeometry(
   const count = Math.max(0, Math.min(rawCount, 6));
 
   const gap = options.gap !== undefined ? Math.max(0, options.gap) : 0;
-  const order: TArcDiDOrder = options.order ?? 'outer-to-inner';
+  const order: TArcDefenseInDepthOrder = options.order ?? 'outer-to-inner';
 
   const totalSpan = outerRadius - innerRadius;
   const totalGaps = count > 1 ? (count - 1) * gap : 0;
   const layerThickness =
     count > 0 ? Math.max(10, (totalSpan - totalGaps) / count) : 0;
 
-  const layersData: readonly IArcDiDLayerItem[] = options.layers ?? [];
+  const layersData: readonly IArcDefenseInDepthLayerItem[] =
+    options.layers ?? [];
 
-  const layers: IArcDiDLayerGeometry[] = [];
+  const layers: IArcDefenseInDepthLayerGeometry[] = [];
 
   if (count > 0) {
     for (let i = 0; i < count; i++) {
@@ -286,14 +301,18 @@ export function createArcDiDGeometry(
       const path = describeArcBand(cx, cy, rIn, rOut, 180, 0);
 
       const layerItem = layersData[i];
-      let rawSectors: readonly IArcDiDSectorItem[] = [];
+      let rawSectors: readonly IArcDefenseInDepthSectorItem[] = [];
 
       if (layerItem?.sectors && layerItem.sectors.length > 0) {
         rawSectors = layerItem.sectors.map((s) => {
           if (Array.isArray(s)) {
-            return { parts: s, split: false };
+            return {
+              parts: s,
+              split: false,
+            };
           }
-          return s as IArcDiDSectorItem;
+
+          return s as IArcDefenseInDepthSectorItem;
         });
       } else if (layerItem?.parts && layerItem.parts.length > 0) {
         rawSectors = layerItem.parts.map((p) => {
@@ -303,9 +322,13 @@ export function createArcDiDGeometry(
             'parts' in p &&
             Array.isArray((p as { parts: unknown }).parts)
           ) {
-            return p as IArcDiDSectorItem;
+            return p as IArcDefenseInDepthSectorItem;
           }
-          return { parts: [p], split: false };
+
+          return {
+            parts: [p],
+            split: false,
+          };
         });
       }
 
@@ -335,8 +358,8 @@ export function createArcDiDGeometry(
         rawSectorSpans,
       );
 
-      const sectors: IArcDiDSectorGeometry[] = [];
-      const parts: IArcDiDPartGeometry[] = [];
+      const sectors: IArcDefenseInDepthSectorGeometry[] = [];
+      const parts: IArcDefenseInDepthPartGeometry[] = [];
 
       for (let s = 0; s < sectorCount; s++) {
         const sectorItem = rawSectors[s];
@@ -370,6 +393,7 @@ export function createArcDiDGeometry(
           numParts > 0 ? layerThickness / numParts : layerThickness;
 
         const dividerPaths: string[] = [];
+
         if (isSplit && numParts > 1) {
           for (let d = 1; d < numParts; d++) {
             const dividerRadius = round(rOut - d * trackThickness, 2);
@@ -379,16 +403,21 @@ export function createArcDiDGeometry(
           }
         }
 
-        const sectorParts: IArcDiDPartGeometry[] = [];
+        const sectorParts: IArcDefenseInDepthPartGeometry[] = [];
 
         for (let p = 0; p < numParts; p++) {
           const rawPart = rawSectorParts[p];
-          const partItem: IArcDiDPartItem =
+          const partItem: IArcDefenseInDepthPartItem =
             typeof rawPart === 'string'
-              ? { label: rawPart }
-              : (rawPart ?? { label: '' });
+              ? {
+                  label: rawPart,
+                }
+              : (rawPart ?? {
+                  label: '',
+                });
 
           let trackIndex = p;
+
           if (partItem.position === 'top') {
             trackIndex = 0;
           } else if (partItem.position === 'bottom') {
@@ -458,6 +487,7 @@ export function createArcDiDGeometry(
 
           const tangentAngle = round(90 - partAngle, 1);
           let rotationAngle: number | undefined;
+
           if (typeof effectiveRotate === 'number') {
             rotationAngle = effectiveRotate;
           } else if (
@@ -486,7 +516,7 @@ export function createArcDiDGeometry(
                 : Number.parseInt(partItem.maxWidth, 10)
               : defaultMaxContentWidth;
 
-          const partGeo: IArcDiDPartGeometry = {
+          const partGeo: IArcDefenseInDepthPartGeometry = {
             index: parts.length,
             sectorIndex: s,
             trackIndex,