@hkdigital/lib-sveltekit 0.1.0 → 0.1.2

package/dist/util/design-system/layout/scaling.js

@@ -0,0 +1,97 @@
+import { clamp } from '../css/clamp.js';
+
+/**
+ * Manages responsive design scaling by calculating and applying scale factors
+ * based on viewport dimensions and design system requirements.
+ *
+ * @param {Object} design - The base design dimensions
+ * @param {number} design.width - The reference design width
+ * @param {number} design.height - The reference design height
+ * @param {Object} clamping - The min/max values for various scale factors
+ * @param {Object} clamping.ui - UI element scaling constraints
+ * @param {number} clamping.ui.min - Minimum UI scale factor
+ * @param {number} clamping.ui.max - Maximum UI scale factor
+ * @param {Object} clamping.textContent - Content text scaling constraints
+ * @param {number} clamping.textContent.min - Minimum content text scale factor
+ * @param {number} clamping.textContent.max - Maximum content text scale factor
+ * @param {Object} clamping.textHeading - Heading text scaling constraints
+ * @param {number} clamping.textHeading.min - Minimum heading text scale factor
+ * @param {number} clamping.textHeading.max - Maximum heading text scale factor
+ * @param {Object} clamping.textUi - UI text scaling constraints
+ * @param {number} clamping.textUi.min - Minimum UI text scale factor
+ * @param {number} clamping.textUi.max - Maximum UI text scale factor
+ *
+ * @returns {()=>void} A cleanup function that removes the event listener
+ */
+export function enableScalingUI(design, clamping) {
+  /**
+   * Updates CSS scale variables based on current viewport dimensions
+   * and design system constraints
+   */
+  function updateScaleValues() {
+    try {
+      const vw = window.innerWidth;
+      const vh = window.innerHeight;
+
+      // Calculate scale factors based on viewport size relative to design dimensions
+      const scaleW = vw / design.width;
+      const scaleH = vh / design.height;
+
+      // Use the smaller scale factor to ensure content fits within viewport
+      const scaleViewport = Math.min(scaleW, scaleH);
+
+      // Apply clamping to different element types
+      const scaleUI = clamp(scaleViewport, clamping.ui.min, clamping.ui.max);
+
+      const scaleTextContent = clamp(
+        scaleViewport,
+        clamping.textContent.min,
+        clamping.textContent.max
+      );
+
+      const scaleTextHeading = clamp(
+        scaleViewport,
+        clamping.textHeading.min,
+        clamping.textHeading.max
+      );
+
+      const scaleTextUi = clamp(
+        scaleViewport,
+        clamping.textUi.min,
+        clamping.textUi.max
+      );
+
+      // Set CSS custom properties for use in the design system
+      document.documentElement.style.setProperty('--scale-w', String(scaleW));
+      document.documentElement.style.setProperty('--scale-h', String(scaleH));
+      document.documentElement.style.setProperty(
+        '--scale-viewport',
+        String(scaleViewport)
+      );
+      document.documentElement.style.setProperty('--scale-ui', String(scaleUI));
+      document.documentElement.style.setProperty(
+        '--scale-text-content',
+        String(scaleTextContent)
+      );
+      document.documentElement.style.setProperty(
+        '--scale-text-heading',
+        String(scaleTextHeading)
+      );
+      document.documentElement.style.setProperty(
+        '--scale-text-ui',
+        String(scaleTextUi)
+      );
+    } catch (error) {
+      console.error('Error updating design scale values:', error);
+    }
+  }
+
+  // Initialize scales and attach resize listener
+  updateScaleValues();
+  window.addEventListener('resize', updateScaleValues);
+
+  // Return cleanup function
+  return function cleanup() {
+    window.removeEventListener('resize', updateScaleValues);
+  };
+}

package/dist/util/design-system/tailwind.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Generates text-based spacing units with with different scaling
+ * units (ut, ct, ht)
+ *
+ * @param {number[]} values
+ *   Array of pixel values to generate text-based spacing units for
+ *
+ * @returns {{[key: string]: string}}
+ *   Generated text-based spacing units with ut, ct, and ht suffixes
+ *
+ * @throws {Error} If values is not an array or contains non-numeric values
+ *
+ * @example
+ * generateTextBasedSpacing([1, 2, 4, 8])
+ * // Returns:
+ * // {
+ * //   '1ut': 'calc(1px * var(--scale-text-ui))',
+ * //   '2ut': 'calc(2px * var(--scale-text-ui))',
+ * //   '1ct': 'calc(1px * var(--scale-text-content))',
+ * //   '2ct': 'calc(2px * var(--scale-text-content))',
+ * //   '1ht': 'calc(1px * var(--scale-text-heading))',
+ * //   '2ht': 'calc(2px * var(--scale-text-heading))'
+ * // }
+ */
+export function generateTextBasedSpacing(values: number[]): {
+    [key: string]: string;
+};
+/**
+ * Generates viewport-based spacing units with different scaling
+ * units (p, vp, wp, hp)
+ *
+ * @param {number[]} values
+ *   Array of pixel values to generate viewport-based spacing units for
+ *
+ * @returns {Object.<string, string>}
+ *   Generated viewport-based spacing units:
+ *   - p:  UI points (clamped scaling)
+ *   - vp: Viewport points (min of width/height)
+ *   - wp: Width points
+ *   - hp: Height points
+ *
+ * @throws {Error} If values is not an array or contains non-numeric values
+ *
+ * @example
+ * generateViewportBasedSpacing([1, 2, 4])
+ * // Returns:
+ * // {
+ * //   '1p': 'calc(1px * var(--scale-ui))',
+ * //   '1vp': 'calc(1px * var(--scale-viewport))',
+ * //   '1wp': 'calc(1px * var(--scale-w))',
+ * //   '1hp': 'calc(1px * var(--scale-h))'
+ * // }
+ */
+export function generateViewportBasedSpacing(values: number[]): {
+    [x: string]: string;
+};
+/**
+ * Generates semantic text style definitions for a specific text category
+ * (content, UI, or heading). Each style includes a scaled font size and
+ * line height.
+ *
+ * @param {{[key: string]: {size: number, lineHeight?: number}}} sizes
+ *   Set of text sizes to generate styles for
+ *
+ * @param {'content' | 'ui' | 'heading'} category
+ *   Text category to generate styles for
+ *
+ * @returns {{[key: string]: [string, {lineHeight: number}]}}
+ *   Generated text styles in Tailwind format
+ *
+ * @throws {Error} If a size has an invalid size or lineHeight
+ *
+ * @example
+ * const TEXT_CONTENT_SIZES = {
+ *   sm: { size: 16, lineHeight: 1.5 },
+ *   base: { size: 20, lineHeight: 1.5 },
+ *   lg: { size: 24, lineHeight: 1.4 }
+ * };
+ *
+ * generateTextStyles(TEXT_CONTENT_SIZES, 'content');
+ * // Returns:
+ * // {
+ * //   'content-sm':
+ * //     ['calc(16px * var(--scale-text-content))', { lineHeight: 1.5 }],
+ * //   'content-base':
+ * //     ['calc(20px * var(--scale-text-content))', { lineHeight: 1.5 }],
+ * //   'content-lg':
+ * //     ['calc(24px * var(--scale-text-content))', { lineHeight: 1.4 }]
+ * // }
+ */
+export function generateTextStyles(sizes: {
+    [key: string]: {
+        size: number;
+        lineHeight?: number;
+    };
+}, category: "content" | "ui" | "heading"): {
+    [key: string]: [string, {
+        lineHeight: number;
+    }];
+};
+/**
+ * Generates border radius styles with UI scaling
+ *
+ * @param {{[key: string]: string | {size: number}}} sizes
+ *   Set of radius sizes to generate, either as:
+ *   - Object with size property (e.g., { size: 10 })
+ *   - Direct string value (e.g., '0px', '9999px')
+ *
+ * @returns {Object.<string, string>}
+ *   Generated border radius styles in Tailwind format
+ *
+ * @throws {Error} If a value has an invalid type
+ *
+ * @example
+ * const RADIUS_SIZES = {
+ *   none: '0px',
+ *   sm: { size: 10 },
+ *   md: { size: 15 },
+ *   full: '9999px'
+ * };
+ *
+ * generateBorderRadiusStyles(RADIUS_SIZES)
+ * // Returns:
+ * // {
+ * //   'none': '0px',
+ * //   'sm': 'calc(10px * var(--scale-ui))',
+ * //   'md': 'calc(15px * var(--scale-ui))',
+ * //   'full': '9999px'
+ * // }
+ */
+export function generateBorderRadiusStyles(sizes: {
+    [key: string]: string | {
+        size: number;
+    };
+}): {
+    [x: string]: string;
+};
+/**
+ * Generates width styles for various CSS properties with UI scaling and explicit naming
+ *
+ * @param {{[key: string]: {size: number}}} sizes
+ *   Set of width sizes to generate
+ *
+ * @param {string} [prefix='width']
+ *   Prefix to add before each variant name (default: 'width')
+ *
+ * @param {string} scaleVar
+ *   CSS variable to use for scaling (default: '--scale-ui')
+ *
+ * @returns {{[key: string]: string}}
+ *   Generated width styles in Tailwind format
+ *
+ * @throws {Error} If a size has an invalid type
+ *
+ * @example
+ * const WIDTH_SIZES = {
+ *   thin: { size: 1 },
+ *   normal: { size: 2 },
+ *   thick: { size: 4 }
+ * };
+ *
+ * generateWidthStyles(WIDTH_SIZES, 'width')
+ * // Returns:
+ * // {
+ * //   'width-thin': 'calc(1px * var(--scale-ui))',
+ * //   'width-normal': 'calc(2px * var(--scale-ui))',
+ * //   'width-thick': 'calc(4px * var(--scale-ui))'
+ * // }
+ */
+export function generateWidthStyles(sizes: {
+    [key: string]: {
+        size: number;
+    };
+}, prefix?: string, scaleVar?: string): {
+    [key: string]: string;
+};

package/dist/util/design-system/tailwind.js

@@ -0,0 +1,289 @@
+/**
+ * Generates text-based spacing units with with different scaling
+ * units (ut, ct, ht)
+ *
+ * @param {number[]} values
+ *   Array of pixel values to generate text-based spacing units for
+ *
+ * @returns {{[key: string]: string}}
+ *   Generated text-based spacing units with ut, ct, and ht suffixes
+ *
+ * @throws {Error} If values is not an array or contains non-numeric values
+ *
+ * @example
+ * generateTextBasedSpacing([1, 2, 4, 8])
+ * // Returns:
+ * // {
+ * //   '1ut': 'calc(1px * var(--scale-text-ui))',
+ * //   '2ut': 'calc(2px * var(--scale-text-ui))',
+ * //   '1ct': 'calc(1px * var(--scale-text-content))',
+ * //   '2ct': 'calc(2px * var(--scale-text-content))',
+ * //   '1ht': 'calc(1px * var(--scale-text-heading))',
+ * //   '2ht': 'calc(2px * var(--scale-text-heading))'
+ * // }
+ */
+export function generateTextBasedSpacing(values) {
+  if (!Array.isArray(values)) {
+    throw new Error('values must be an array');
+  }
+
+  return values.reduce((units, value) => {
+    if (typeof value !== 'number' || isNaN(value)) {
+      throw new Error(`Invalid spacing value: ${value}. Must be a number.`);
+    }
+
+    // Generate UI text spacing units
+    units[`${value}ut`] = `calc(${value}px * var(--scale-text-ui))`;
+
+    // Generate content text spacing units
+    units[`${value}ct`] = `calc(${value}px * var(--scale-text-content))`;
+
+    // Generate heading text spacing units
+    units[`${value}ht`] = `calc(${value}px * var(--scale-text-heading))`;
+
+    return units;
+  }, {});
+}
+
+/**
+ * Generates viewport-based spacing units with different scaling
+ * units (p, vp, wp, hp)
+ *
+ * @param {number[]} values
+ *   Array of pixel values to generate viewport-based spacing units for
+ *
+ * @returns {Object.<string, string>}
+ *   Generated viewport-based spacing units:
+ *   - p:  UI points (clamped scaling)
+ *   - vp: Viewport points (min of width/height)
+ *   - wp: Width points
+ *   - hp: Height points
+ *
+ * @throws {Error} If values is not an array or contains non-numeric values
+ *
+ * @example
+ * generateViewportBasedSpacing([1, 2, 4])
+ * // Returns:
+ * // {
+ * //   '1p': 'calc(1px * var(--scale-ui))',
+ * //   '1vp': 'calc(1px * var(--scale-viewport))',
+ * //   '1wp': 'calc(1px * var(--scale-w))',
+ * //   '1hp': 'calc(1px * var(--scale-h))'
+ * // }
+ */
+export function generateViewportBasedSpacing(values) {
+  if (!Array.isArray(values)) {
+    throw new Error('values must be an array');
+  }
+
+  return values.reduce((units, value) => {
+    if (typeof value !== 'number' || isNaN(value)) {
+      throw new Error(`Invalid spacing value: ${value}. Must be a number.`);
+    }
+
+    // Viewport points (min of width/height)
+    units[`${value}vp`] = `calc(${value}px * var(--scale-viewport))`;
+    // Width points
+    units[`${value}wp`] = `calc(${value}px * var(--scale-w))`;
+    // Height points
+    units[`${value}hp`] = `calc(${value}px * var(--scale-h))`;
+    // UI points
+    units[`${value}p`] = `calc(${value}px * var(--scale-ui))`;
+    return units;
+  }, {});
+}
+
+/**
+ * Generates semantic text style definitions for a specific text category
+ * (content, UI, or heading). Each style includes a scaled font size and
+ * line height.
+ *
+ * @param {{[key: string]: {size: number, lineHeight?: number}}} sizes
+ *   Set of text sizes to generate styles for
+ *
+ * @param {'content' | 'ui' | 'heading'} category
+ *   Text category to generate styles for
+ *
+ * @returns {{[key: string]: [string, {lineHeight: number}]}}
+ *   Generated text styles in Tailwind format
+ *
+ * @throws {Error} If a size has an invalid size or lineHeight
+ *
+ * @example
+ * const TEXT_CONTENT_SIZES = {
+ *   sm: { size: 16, lineHeight: 1.5 },
+ *   base: { size: 20, lineHeight: 1.5 },
+ *   lg: { size: 24, lineHeight: 1.4 }
+ * };
+ *
+ * generateTextStyles(TEXT_CONTENT_SIZES, 'content');
+ * // Returns:
+ * // {
+ * //   'content-sm':
+ * //     ['calc(16px * var(--scale-text-content))', { lineHeight: 1.5 }],
+ * //   'content-base':
+ * //     ['calc(20px * var(--scale-text-content))', { lineHeight: 1.5 }],
+ * //   'content-lg':
+ * //     ['calc(24px * var(--scale-text-content))', { lineHeight: 1.4 }]
+ * // }
+ */
+export function generateTextStyles(sizes, category) {
+  if (!sizes || typeof sizes !== 'object') {
+    throw new Error('sizes must be an object');
+  }
+
+  if (!['content', 'ui', 'heading'].includes(category)) {
+    throw new Error('category must be one of: content, ui, heading');
+  }
+
+  return Object.entries(sizes).reduce((result, [variant, config]) => {
+    // Validate config
+    if (!config || typeof config !== 'object') {
+      throw new Error(
+        `Invalid size config for "${variant}": must be an object`
+      );
+    }
+
+    if (typeof config.size !== 'number') {
+      throw new Error(
+        `Invalid size for "${category}-${variant}": must be a number`
+      );
+    }
+
+    if (
+      config.lineHeight !== undefined &&
+      typeof config.lineHeight !== 'number'
+    ) {
+      throw new Error(
+        `Invalid lineHeight for "${category}-${variant}": must be a number`
+      );
+    }
+
+    const { size, lineHeight = 1.5 } = config;
+
+    result[`${category}-${variant}`] = [
+      `calc(${size}px * var(--scale-text-${category}))`,
+      { lineHeight }
+    ];
+
+    return result;
+  }, {});
+}
+
+/**
+ * Generates border radius styles with UI scaling
+ *
+ * @param {{[key: string]: string | {size: number}}} sizes
+ *   Set of radius sizes to generate, either as:
+ *   - Object with size property (e.g., { size: 10 })
+ *   - Direct string value (e.g., '0px', '9999px')
+ *
+ * @returns {Object.<string, string>}
+ *   Generated border radius styles in Tailwind format
+ *
+ * @throws {Error} If a value has an invalid type
+ *
+ * @example
+ * const RADIUS_SIZES = {
+ *   none: '0px',
+ *   sm: { size: 10 },
+ *   md: { size: 15 },
+ *   full: '9999px'
+ * };
+ *
+ * generateBorderRadiusStyles(RADIUS_SIZES)
+ * // Returns:
+ * // {
+ * //   'none': '0px',
+ * //   'sm': 'calc(10px * var(--scale-ui))',
+ * //   'md': 'calc(15px * var(--scale-ui))',
+ * //   'full': '9999px'
+ * // }
+ */
+export function generateBorderRadiusStyles(sizes) {
+  if (!sizes || typeof sizes !== 'object') {
+    throw new Error('sizes must be an object');
+  }
+
+  return Object.entries(sizes).reduce((result, [variant, value]) => {
+    if (typeof value === 'object' && value !== null) {
+      // Handle {size: 10} format
+      if (typeof value.size !== 'number') {
+        throw new Error(
+          `Invalid radius size for "${variant}": size must be a number`
+        );
+      }
+      result[variant] = `calc(${value.size}px * var(--scale-ui))`;
+    } else if (typeof value === 'string') {
+      // Handle direct strings (like '0px' or '9999px')
+      result[variant] = value;
+    } else {
+      throw new Error(
+        `Invalid radius value for "${variant}": ` +
+          `must be an object with size property or a string`
+      );
+    }
+    return result;
+  }, {});
+}
+
+/**
+ * Generates width styles for various CSS properties with UI scaling and explicit naming
+ *
+ * @param {{[key: string]: {size: number}}} sizes
+ *   Set of width sizes to generate
+ *
+ * @param {string} [prefix='width']
+ *   Prefix to add before each variant name (default: 'width')
+ *
+ * @param {string} scaleVar
+ *   CSS variable to use for scaling (default: '--scale-ui')
+ *
+ * @returns {{[key: string]: string}}
+ *   Generated width styles in Tailwind format
+ *
+ * @throws {Error} If a size has an invalid type
+ *
+ * @example
+ * const WIDTH_SIZES = {
+ *   thin: { size: 1 },
+ *   normal: { size: 2 },
+ *   thick: { size: 4 }
+ * };
+ *
+ * generateWidthStyles(WIDTH_SIZES, 'width')
+ * // Returns:
+ * // {
+ * //   'width-thin': 'calc(1px * var(--scale-ui))',
+ * //   'width-normal': 'calc(2px * var(--scale-ui))',
+ * //   'width-thick': 'calc(4px * var(--scale-ui))'
+ * // }
+ */
+export function generateWidthStyles(
+  sizes,
+  prefix = 'width',
+  scaleVar = '--scale-ui'
+) {
+  if (!sizes || typeof sizes !== 'object') {
+    throw new Error('sizes must be an object');
+  }
+
+  return Object.entries(sizes).reduce((result, [variant, value]) => {
+    if (typeof value === 'object' && value !== null) {
+      if (typeof value.size !== 'number') {
+        throw new Error(
+          `Invalid width size for "${variant}": size must be a number`
+        );
+      }
+
+      result[`${prefix}${prefix.length ? '-' : ''}${variant}`] =
+        `calc(${value.size}px * var(${scaleVar}))`;
+    } else {
+      throw new Error(
+        `Invalid width value for "${variant}": ` +
+          `must be an object with size property`
+      );
+    }
+    return result;
+  }, {});
+}

package/dist/util/http/index.js

@@ -5,7 +5,7 @@
 // 	AbortError,
 // 	TimeoutError,
 // 	TypeOrValueError
-// } from '../../constants/errors/index.js';
+// } from '$lib/constants/errors/index.js';
 
 // import { setRequestHeaders } from './headers.js';
 // import { getErrorFromResponse } from './errors.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hkdigital/lib-sveltekit",
-	"version": "0.1.0",
+	"version": "0.1.2",
 	"author": {
 		"name": "HKdigital",
 		"url": "https://hkdigital.nl"
@@ -63,37 +63,37 @@
 		"valibot": "^0.42.1"
 	},
 	"devDependencies": {
-		"@playwright/test": "^1.49.1",
+		"@playwright/test": "^1.50.1",
 		"@skeletonlabs/skeleton": "3.0.0-next.2",
 		"@skeletonlabs/skeleton-svelte": "1.0.0-next.4",
 		"@steeze-ui/heroicons": "^2.4.2",
-		"@sveltejs/adapter-auto": "^3.3.1",
-		"@sveltejs/package": "^2.3.7",
+		"@sveltejs/adapter-auto": "^4.0.0",
+		"@sveltejs/package": "^2.3.10",
 		"@sveltejs/vite-plugin-svelte": "^5.0.3",
 		"@tailwindcss/typography": "^0.5.16",
 		"@types/eslint": "^9.6.1",
 		"autoprefixer": "^10.4.20",
-		"eslint": "^9.18.0",
-		"eslint-config-prettier": "^10.0.1",
-		"eslint-plugin-svelte": "^2.46.1",
-		"globals": "^15.14.0",
+		"eslint": "^9.21.0",
+		"eslint-config-prettier": "^10.0.2",
+		"eslint-plugin-svelte": "^3.0.2",
+		"globals": "^16.0.0",
 		"jsdom": "^26.0.0",
-		"postcss": "^8.5.1",
+		"postcss": "^8.5.3",
 		"postcss-mixins": "^11.0.3",
-		"prettier": "^3.4.2",
+		"prettier": "^3.5.3",
 		"prettier-plugin-svelte": "^3.3.3",
-		"prettier-plugin-tailwindcss": "^0.6.9",
-		"publint": "^0.3.2",
-		"standardized-audio-context-mock": "^9.7.15",
-		"svelte": "^5.17.5",
+		"prettier-plugin-tailwindcss": "^0.6.11",
+		"publint": "^0.3.7",
+		"standardized-audio-context-mock": "^9.7.16",
+		"svelte": "^5.20.5",
 		"svelte-check": "^4.1.4",
 		"tailwindcss": "^3.4.17",
-		"typescript": "^5.7.3",
-		"vite": "^6.0.7",
+		"typescript": "^5.8.2",
+		"vite": "^6.2.0",
 		"vite-imagetools": "^7.0.5",
-		"vitest": "^2.1.8"
+		"vitest": "^3.0.7"
 	},
 	"dependencies": {
-		"zod": "^3.24.1"
+		"zod": "^3.24.2"
 	}
 }

package/dist/components/buttons/plain-button/PlainButton.svelte

@@ -1,37 +0,0 @@
-<script>
-  /**
-   * @type {{
-   *   base?: string,
-   *   bg?: string,
-   *   variant?: string,
-   *   classes?: string,
-   *   role?: 'primary' | 'secondary',
-   *   children: import('svelte').Snippet,
-   *   [key: string]: any
-   * }}
-   */
-  const {
-    // Style
-    base,
-    bg,
-    variant,
-    classes,
-
-    role = 'primary',
-
-    // Snippets
-    children,
-
-    // Attributes
-    ...attrs
-  } = $props();
-</script>
-
-<button
-  data-button="plain-button"
-  type="button"
-  class="{base} {bg} {variant} {classes} role-{role}"
-  {...attrs}
->
-  <p class="p">{@render children()}</p>
-</button>

package/dist/components/buttons/plain-button/PlainButton.svelte.d.ts

@@ -1,10 +0,0 @@
-export default PlainButton;
-declare const PlainButton: import("svelte").Component<{
-    [key: string]: any;
-    base?: string;
-    bg?: string;
-    variant?: string;
-    classes?: string;
-    role?: "primary" | "secondary";
-    children: import("svelte").Snippet;
-}, {}, "">;