@hkdigital/lib-core 0.5.80 → 0.5.83

package/dist/network/loaders/README.md

@@ -213,7 +213,7 @@ All loaders implement consistent loading state management:
 
 ```svelte
 <script>
-  import { ImageBox } from '$lib/ui/components/index.js';
+  import { ImageBox } from '$lib/ui/typedef.js';
   
   // ImageBox uses ImageVariantsLoader internally
   const imageSource = [
@@ -259,4 +259,4 @@ try {
 - `toSingleImageMeta()` - Extract single image from variants
 - `calculateEffectiveWidth()` - Calculate optimal image dimensions
 
-All loaders provide built-in loading states, error handling, and memory management with automatic cleanup of object URLs.
+All loaders provide built-in loading states, error handling, and memory management with automatic cleanup of object URLs.

package/dist/services/service-manager/typedef.js

@@ -8,8 +8,8 @@
  * // When using ServiceManager
  * import { ServiceManager } from './ServiceManager.js';
  *
- * // @ typedef {import('./typedef-service-manager.js').ServiceManagerConfig} ServiceManagerConfig
- * // @ typedef {import('./typedef-service-manager.js').ServiceRegistrationOptions} ServiceRegistrationOptions
+ * // @ typedef {import('../typedef.js').ServiceManagerConfig} ServiceManagerConfig
+ * // @ typedef {import('../typedef.js').ServiceRegistrationOptions} ServiceRegistrationOptions
  *
  * const config = {
  *   environment: 'development',

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hkdigital/lib-core",
-	"version": "0.5.80",
+	"version": "0.5.83",
 	"author": {
 		"name": "HKdigital",
 		"url": "https://hkdigital.nl"

package/scripts/validate-imports.mjs

@@ -15,6 +15,17 @@ const LIB_ROOT = dirname(SCRIPT_DIR);
  */
 const EXTERNAL_SCOPES_TO_VALIDATE = ['@hkdigital'];
 
+/**
+ * Built-in SvelteKit aliases
+ * These are provided by SvelteKit and don't need to be in svelte.config.js
+ */
+const SVELTEKIT_BUILT_IN_ALIASES = [
+  '$lib',
+  '$app',
+  '$env',
+  '$service-worker'
+];
+
 /**
  * Project aliases from svelte.config.js
  * Loaded dynamically at startup
@@ -559,28 +570,176 @@ async function validateFile(filePath) {
   const isInLib = filePath.includes('/src/lib/');
   const isInRoutes = filePath.includes('/src/routes/');
 
-  // Check each line for import statements
+  // Check each line for import statements and JSDoc type imports
   const lines = content.split('\n');
   for (let index = 0; index < lines.length; index++) {
     const line = lines[index];
     const lineNum = index + 1;
 
-    // Skip if not an import line
-    if (!line.trim().startsWith('import ')) {
-      continue;
+    let importPathRaw = null;
+    let isJSDocImport = false;
+
+    // Check for regular import statements
+    if (line.trim().startsWith('import ')) {
+      const importMatch = line.match(/from ['"]([^'"]+)['"]/);
+      if (importMatch) {
+        importPathRaw = importMatch[1];
+      }
+    }
+    // Check for JSDoc type imports: import('path')
+    else if (line.includes('import(')) {
+      // Match import('...') or import("...")
+      const jsdocMatch = line.match(/import\(['"]([^'"]+)['"]\)/);
+      if (jsdocMatch) {
+        importPathRaw = jsdocMatch[1];
+        isJSDocImport = true;
+      }
     }
 
-    // Extract import path from line
-    const importMatch = line.match(/from ['"]([^'"]+)['"]/);
-    if (!importMatch) {
+    // Skip if no import found
+    if (!importPathRaw) {
       continue;
     }
 
-    const importPathRaw = importMatch[1];
-
     // Strip query parameters (Vite asset imports like ?preset=render)
     let importPath = importPathRaw.split('?')[0];
 
+    // For JSDoc imports: only check unsafe aliases and file existence
+    if (isJSDocImport) {
+      // Check if using an unsafe alias
+      const isAliasImport = Object.keys(PROJECT_ALIASES).some(
+        alias => importPath === alias || importPath.startsWith(alias + '/')
+      );
+
+      if (isAliasImport && isInLib) {
+        let matchedAlias = null;
+        for (const alias of Object.keys(PROJECT_ALIASES)) {
+          if (importPath === alias || importPath.startsWith(alias + '/')) {
+            matchedAlias = alias;
+            break;
+          }
+        }
+
+        if (matchedAlias && UNSAFE_ALIASES.has(matchedAlias)) {
+          const suggestion = UNSAFE_ALIASES.get(matchedAlias);
+          const pathAfterAlias = importPath.slice(matchedAlias.length);
+
+          let errorMsg;
+          if (suggestion.startsWith('(')) {
+            errorMsg = `${relativePath}:${lineNum}\n` +
+              `  JSDoc import('${importPath}')\n` +
+              `  => ${suggestion}`;
+          } else {
+            const suggestedImport = suggestion + pathAfterAlias;
+            errorMsg = `${relativePath}:${lineNum}\n` +
+              `  JSDoc import('${importPath}')\n` +
+              `  => import('${suggestedImport}') ` +
+              `(alias resolves outside project)`;
+          }
+
+          errors.push(errorMsg);
+          // Skip file existence check if unsafe alias (already error)
+          continue;
+        }
+      }
+
+      // Check for unknown aliases in JSDoc imports
+      if (importPath.startsWith('$')) {
+        const aliasName = importPath.split('/')[0];
+        const isBuiltInAlias = SVELTEKIT_BUILT_IN_ALIASES.some(
+          builtIn => importPath === builtIn || importPath.startsWith(builtIn + '/')
+        );
+        const isConfiguredAlias = Object.keys(PROJECT_ALIASES).some(
+          alias => importPath === alias || importPath.startsWith(alias + '/')
+        );
+
+        if (!isBuiltInAlias && !isConfiguredAlias) {
+          errors.push(
+            `${relativePath}:${lineNum}\n` +
+            `  JSDoc import('${importPath}')\n` +
+            `  => Unknown alias '${aliasName}' (not configured in svelte.config.js)`
+          );
+          continue;
+        }
+      }
+
+      // Check file existence for JSDoc imports (skip external packages)
+      const isExternalPackage = !importPath.startsWith('./') &&
+        !importPath.startsWith('../') &&
+        !importPath.startsWith('$lib/') &&
+        !importPath.startsWith('$');
+
+      if (!isExternalPackage) {
+        // Resolve to filesystem path
+        let jsdocFsPath;
+        if (importPath.startsWith('$lib/')) {
+          jsdocFsPath = join(
+            PROJECT_ROOT,
+            importPath.replace('$lib/', 'src/lib/')
+          );
+        } else {
+          jsdocFsPath = resolve(dirname(filePath), importPath);
+        }
+
+        // Check if file exists
+        const possiblePaths = [];
+        if (importPath.match(/\.(js|svelte|svelte\.js|test\.js|spec\.js)$/)) {
+          possiblePaths.push(jsdocFsPath);
+        } else {
+          possiblePaths.push(jsdocFsPath);
+          possiblePaths.push(jsdocFsPath + '.js');
+          possiblePaths.push(jsdocFsPath + '.svelte');
+          possiblePaths.push(jsdocFsPath + '.svelte.js');
+          possiblePaths.push(jsdocFsPath + '/index.js');
+          possiblePaths.push(jsdocFsPath + '/index.svelte');
+        }
+
+        let fileExists = false;
+        for (const testPath of possiblePaths) {
+          try {
+            const stats = await stat(testPath);
+            if (stats.isFile()) {
+              fileExists = true;
+              break;
+            }
+          } catch {
+            // File doesn't exist, continue checking
+          }
+        }
+
+        if (!fileExists) {
+          errors.push(
+            `${relativePath}:${lineNum}\n` +
+            `  JSDoc import('${importPath}')\n` +
+            `  => Import path does not exist`
+          );
+        }
+      }
+
+      // Skip all other validations for JSDoc imports
+      continue;
+    }
+
+    // Check for unknown aliases (starts with $ but not configured)
+    if (importPath.startsWith('$')) {
+      const aliasName = importPath.split('/')[0];
+      const isBuiltInAlias = SVELTEKIT_BUILT_IN_ALIASES.some(
+        builtIn => importPath === builtIn || importPath.startsWith(builtIn + '/')
+      );
+      const isConfiguredAlias = Object.keys(PROJECT_ALIASES).some(
+        alias => importPath === alias || importPath.startsWith(alias + '/')
+      );
+
+      if (!isBuiltInAlias && !isConfiguredAlias) {
+        errors.push(
+          `${relativePath}:${lineNum}\n` +
+          `  from '${importPath}'\n` +
+          `  => Unknown alias '${aliasName}' (not configured in svelte.config.js)`
+        );
+        continue;
+      }
+    }
+
     // Check if using $src/lib when $lib is available (built-in SvelteKit)
     // Report the issue and normalize the path for further validation
     let hasSrcLibIssue = false;