@hkdigital/lib-sveltekit 0.1.6 → 0.1.8

package/dist/util/svelte/state-context/index.js

@@ -1,83 +1,83 @@
-import { setContext, getContext, hasContext } from 'svelte';
-
-/* ----------------------------------------------------------- Create and Get */
-
-/**
- * Define a state context:
- * - Returns a function 'createOrGetState' that can be used to create a new state
- *   or get an existing one
- * - Returns a function 'createState' that can be used to create a new state
- *
- * @template T
- *
- * @param {new() => T} State - Class that can be used to construct the state
- *
- * @returns {[
- *   createOrGetState,
- *   createState,
- *   getState
- * ]}
- */
-export function defineStateContext(State) {
-  const description = State.name;
-
-  const sharedKey = Symbol(description);
-
-  /**
-   * Create component state
-   *
-   * @param {string|Symbol} [instanceKey]
-   *
-   * @returns {T} state
-   */
-  function createState(instanceKey) {
-    const key = instanceKey ?? sharedKey;
-
-    // console.log('Create state', key);
-
-    const state = new State();
-
-    // @ts-ignore
-    state._instanceKey = instanceKey;
-
-    return setContext(key, state);
-  }
-
-  /**
-   * Get component state or create a new state if it does not yet exist
-   *
-   * @param {string|Symbol} [instanceKey]
-   *
-   * @returns {T} state
-   */
-  function createOrGetState(instanceKey) {
-    let key = instanceKey ?? sharedKey;
-
-    if (!hasContext(key)) {
-      return createState(key);
-    }
-
-    return getContext(key);
-  }
-
-  /**
-   * Get component state
-   *
-   * @throws Will throw an error if the state-context does not exist
-   *
-   * @param {string|Symbol} [instanceKey]
-   *
-   * @returns {T} state
-   */
-  function getState(instanceKey) {
-    let key = instanceKey ?? sharedKey;
-
-    if (!hasContext(key)) {
-      throw new Error(`No state context found. Create one first`);
-    }
-
-    return getContext(key);
-  }
-
-  return [createOrGetState, createState, getState];
-}
+import { setContext, getContext, hasContext } from 'svelte';
+
+/* ----------------------------------------------------------- Create and Get */
+
+/**
+ * Define a state context:
+ * - Returns a function 'createOrGetState' that can be used to create a new state
+ *   or get an existing one
+ * - Returns a function 'createState' that can be used to create a new state
+ *
+ * @template T
+ *
+ * @param {new() => T} State - Class that can be used to construct the state
+ *
+ * @returns {[
+ *   createOrGetState,
+ *   createState,
+ *   getState
+ * ]}
+ */
+export function defineStateContext(State) {
+  const description = State.name;
+
+  const sharedKey = Symbol(description);
+
+  /**
+   * Create component state
+   *
+   * @param {string|Symbol} [instanceKey]
+   *
+   * @returns {T} state
+   */
+  function createState(instanceKey) {
+    const key = instanceKey ?? sharedKey;
+
+    // console.log('Create state', key);
+
+    const state = new State();
+
+    // @ts-ignore
+    state._instanceKey = instanceKey;
+
+    return setContext(key, state);
+  }
+
+  /**
+   * Get component state or create a new state if it does not yet exist
+   *
+   * @param {string|Symbol} [instanceKey]
+   *
+   * @returns {T} state
+   */
+  function createOrGetState(instanceKey) {
+    let key = instanceKey ?? sharedKey;
+
+    if (!hasContext(key)) {
+      return createState(key);
+    }
+
+    return getContext(key);
+  }
+
+  /**
+   * Get component state
+   *
+   * @throws Will throw an error if the state-context does not exist
+   *
+   * @param {string|Symbol} [instanceKey]
+   *
+   * @returns {T} state
+   */
+  function getState(instanceKey) {
+    let key = instanceKey ?? sharedKey;
+
+    if (!hasContext(key)) {
+      throw new Error(`No state context found. Create one first`);
+    }
+
+    return getContext(key);
+  }
+
+  return [createOrGetState, createState, getState];
+}

package/dist/util/svelte/wait/index.js

@@ -1,38 +1,38 @@
-import { tick } from 'svelte';
-
-/**
- * Waits for a state condition to be met by running the checkFn
- * function after each Svelte tick
- *
- * @param {() => boolean} checkFn -
- *   Should return true when desired state is reached
- *
- * @param {number} [maxWaitMs=1000]
- *
- * @returns {Promise<void>} Promise that resolves when the check
- *   function returns true
- * @throws {Error} if maxAttempts is reached before
- * predicate returns true
- */
-export function waitForState(checkFn, maxWaitMs = 1000) {
-  let startedAt = Date.now();
-
-  return new Promise((resolve, reject) => {
-    async function checkLoop() {
-      if (checkFn()) {
-        resolve();
-        return;
-      }
-
-      if (Date.now() - startedAt >= maxWaitMs) {
-        reject(new Error(`State change timeout`));
-        return;
-      }
-
-      await tick();
-      checkLoop();
-    }
-
-    checkLoop();
-  });
-}
+import { tick } from 'svelte';
+
+/**
+ * Waits for a state condition to be met by running the checkFn
+ * function after each Svelte tick
+ *
+ * @param {() => boolean} checkFn -
+ *   Should return true when desired state is reached
+ *
+ * @param {number} [maxWaitMs=1000]
+ *
+ * @returns {Promise<void>} Promise that resolves when the check
+ *   function returns true
+ * @throws {Error} if maxAttempts is reached before
+ * predicate returns true
+ */
+export function waitForState(checkFn, maxWaitMs = 1000) {
+  let startedAt = Date.now();
+
+  return new Promise((resolve, reject) => {
+    async function checkLoop() {
+      if (checkFn()) {
+        resolve();
+        return;
+      }
+
+      if (Date.now() - startedAt >= maxWaitMs) {
+        reject(new Error(`State change timeout`));
+        return;
+      }
+
+      await tick();
+      checkLoop();
+    }
+
+    checkLoop();
+  });
+}

package/dist/util/sveltekit/index.js

@@ -1 +1 @@
-export * from './route-folders/index.js';
+export * from './route-folders/index.js';

package/dist/util/sveltekit/route-folders/index.js

@@ -1,82 +1,82 @@
-import { readdir } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-
-/**
- * Validates if a path is within the project's src/routes directory
- * @param {string} path - Path to validate
- * @returns {boolean}
- */
-export function isValidRoutePath(path) {
-  const normalizedPath = resolve(path);
-  const routesPath = resolve(process.cwd(), 'src/routes');
-  return normalizedPath.startsWith(routesPath);
-}
-
-/**
- * Scans route folders recursively, only including folders with +page.svelte
- * @param {Object} options - Scan options
- * @param {string} options.dirPath - Directory path to scan
- * @param {number} [options.maxDepth=1] - Maximum depth to scan
- * @param {Set<string>} [options.skipFolders=new Set(['assets'])] - Folders to skip
- * @returns {Promise<Array<{displayName: string, path: string}>>}
- * @throws {Error} If path is outside project routes directory
- */
-export async function scanRouteFolders({
-  dirPath,
-  maxDepth = 1,
-  skipFolders = new Set(['assets'])
-}) {
-  if (!isValidRoutePath(dirPath)) {
-    throw new Error('Invalid path: Must be within src/routes directory');
-  }
-
-  if (maxDepth < 1) return [];
-
-  try {
-    const entries = await readdir(dirPath, { withFileTypes: true });
-    const results = [];
-
-    for (const entry of entries) {
-      if (
-        !entry.isDirectory() ||
-        skipFolders.has(entry.name) ||
-        entry.name.startsWith('.')
-      ) {
-        continue;
-      }
-
-      const fullPath = join(dirPath, entry.name);
-      const currentPath = entry.name;
-
-      const dirContents = await readdir(fullPath);
-      const hasPageFile = dirContents.includes('+page.svelte');
-
-      if (hasPageFile) {
-        results.push({
-          displayName: entry.name,
-          path: currentPath
-        });
-      }
-
-      if (maxDepth > 1) {
-        const subFolders = await scanRouteFolders({
-          dirPath: fullPath,
-          maxDepth: maxDepth - 1,
-          skipFolders
-        });
-
-        for (const subFolder of subFolders) {
-          results.push({
-            displayName: `${entry.name}/${subFolder.displayName}`,
-            path: `${currentPath}/${subFolder.path}`
-          });
-        }
-      }
-    }
-
-    return results;
-  } catch (err) {
-    console.error(err);
-    throw new Error('Failed to scan directory');
-  }
-}
+import { readdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+
+/**
+ * Validates if a path is within the project's src/routes directory
+ * @param {string} path - Path to validate
+ * @returns {boolean}
+ */
+export function isValidRoutePath(path) {
+  const normalizedPath = resolve(path);
+  const routesPath = resolve(process.cwd(), 'src/routes');
+  return normalizedPath.startsWith(routesPath);
+}
+
+/**
+ * Scans route folders recursively, only including folders with +page.svelte
+ * @param {Object} options - Scan options
+ * @param {string} options.dirPath - Directory path to scan
+ * @param {number} [options.maxDepth=1] - Maximum depth to scan
+ * @param {Set<string>} [options.skipFolders=new Set(['assets'])] - Folders to skip
+ * @returns {Promise<Array<{displayName: string, path: string}>>}
+ * @throws {Error} If path is outside project routes directory
+ */
+export async function scanRouteFolders({
+  dirPath,
+  maxDepth = 1,
+  skipFolders = new Set(['assets'])
+}) {
+  if (!isValidRoutePath(dirPath)) {
+    throw new Error('Invalid path: Must be within src/routes directory');
+  }
+
+  if (maxDepth < 1) return [];
+
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    const results = [];
+
+    for (const entry of entries) {
+      if (
+        !entry.isDirectory() ||
+        skipFolders.has(entry.name) ||
+        entry.name.startsWith('.')
+      ) {
+        continue;
+      }
+
+      const fullPath = join(dirPath, entry.name);
+      const currentPath = entry.name;
+
+      const dirContents = await readdir(fullPath);
+      const hasPageFile = dirContents.includes('+page.svelte');
+
+      if (hasPageFile) {
+        results.push({
+          displayName: entry.name,
+          path: currentPath
+        });
+      }
+
+      if (maxDepth > 1) {
+        const subFolders = await scanRouteFolders({
+          dirPath: fullPath,
+          maxDepth: maxDepth - 1,
+          skipFolders
+        });
+
+        for (const subFolder of subFolders) {
+          results.push({
+            displayName: `${entry.name}/${subFolder.displayName}`,
+            path: `${currentPath}/${subFolder.path}`
+          });
+        }
+      }
+    }
+
+    return results;
+  } catch (err) {
+    console.error(err);
+    throw new Error('Failed to scan directory');
+  }
+}