solidstep 0.1.0

package/utils/fetch.server.js

@@ -0,0 +1,54 @@
+import { fetch } from 'undici';
+/**
+ * It's a wrapper around the native fetch function that adds a timeout and a json parser
+ * @param {string} url - string - The URL to fetch
+ * @param {Options} [options] - {
+ *  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+ *  body?: any;
+ *  headers?: any;
+ *  MAX_FETCH_TIME?: number;
+ * }
+ * @param [json=true] - boolean - If the response is JSON, it will be parsed and returned.
+ * @returns The return type is Promise<any>
+ */
+const Fetch = async (url, options, json = true) => {
+    // AbortController was added in node v14.17.0 globally
+    const AbortController = globalThis.AbortController;
+    const maxTime = options?.MAX_FETCH_TIME ?? 4000;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, maxTime);
+    try {
+        const response = await fetch(url, {
+            ...options,
+            signal: controller.signal,
+        });
+        if (response?.status >= 400 && response?.status <= 599) {
+            if (json) {
+                throw await response.json();
+            }
+            throw response;
+        }
+        if (json) {
+            const data = await response.json();
+            if (data) {
+                if (data.error)
+                    throw data.error; // in case the status is marked as 200 but the response is an error
+                return data;
+            }
+            throw new Error('Not Defined');
+        }
+        return response;
+    }
+    catch (error) {
+        if (controller.signal.aborted) {
+            throw new Error('Timeout');
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+};
+export default Fetch;

package/utils/hooks/action-state.d.ts

@@ -0,0 +1,3 @@
+declare const useActionState: () => readonly [import("solid-js").Accessor<boolean>, (callback: () => void | Promise<void>) => void];
+export default useActionState;
+//# sourceMappingURL=action-state.d.ts.map

package/utils/hooks/action-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-state.d.ts","sourceRoot":"","sources":["../../../utils/hooks/action-state.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,cAAc,mEAIF,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,UAU3C,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/utils/hooks/action-state.js

@@ -0,0 +1,13 @@
+import { createSignal } from 'solid-js';
+const useActionState = () => {
+    const [isPending, setIsPending] = createSignal(false);
+    const startTransition = (callback) => {
+        setIsPending(true);
+        Promise.resolve(callback())
+            .finally(() => {
+            setIsPending(false);
+        });
+    };
+    return [isPending, startTransition];
+};
+export default useActionState;

package/utils/loader.d.ts

@@ -0,0 +1,18 @@
+type LoaderFunction<T> = (request?: Request) => Promise<T>;
+type LoaderOptions = {
+    type?: 'defer' | 'sequential';
+};
+export declare const defineLoader: <T>(loader: LoaderFunction<T>, options?: LoaderOptions) => {
+    loader: (request?: Request) => Promise<{
+        data: Awaited<T>;
+        type: "defer" | "sequential";
+    }>;
+    options: LoaderOptions;
+} | null;
+export type LoaderDataFromFunction<T> = T extends {
+    loader: infer L extends (...args: any) => any;
+} ? Awaited<ReturnType<T['loader']>> extends {
+    data: infer D;
+} ? D : never : never;
+export {};
+//# sourceMappingURL=loader.d.ts.map

package/utils/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../utils/loader.ts"],"names":[],"mappings":"AAEA,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;AAE3D,KAAK,aAAa,GAAG;IACjB,IAAI,CAAC,EAAE,OAAO,GAAG,YAAY,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,QAAQ,cAAc,CAAC,CAAC,CAAC,EAAE,UAAU,aAAa;uBAE9C,OAAO;;;;;QAoB1C,CAAC;AAEF,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,CAAA;CAAE,GAC7F,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,GACtE,KAAK,CAAC"}

package/utils/loader.js

@@ -0,0 +1,23 @@
+import { isServer } from 'solid-js/web';
+export const defineLoader = (loader, options) => {
+    if (isServer) {
+        const fn = async (request) => {
+            try {
+                const loaderData = await loader(request);
+                return {
+                    data: loaderData,
+                    type: options?.type || 'sequential',
+                };
+            }
+            catch (error) {
+                console.error('Error in loader:', error);
+                throw error; // Re-throw to allow error handling upstream
+            }
+        };
+        return {
+            loader: fn,
+            options: options || {},
+        };
+    }
+    return null; // Return null if not on the server
+};

package/utils/redirect.d.ts

@@ -0,0 +1,5 @@
+export declare class RedirectError extends Error {
+    constructor(message: string);
+}
+export declare const redirect: (url: string) => void;
+//# sourceMappingURL=redirect.d.ts.map

package/utils/redirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redirect.d.ts","sourceRoot":"","sources":["../../utils/redirect.ts"],"names":[],"mappings":"AAEA,qBAAa,aAAc,SAAQ,KAAK;gBACxB,OAAO,EAAE,MAAM;CAI9B;AAED,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,SAMnC,CAAC"}

package/utils/redirect.js

@@ -0,0 +1,14 @@
+import { isServer } from 'solid-js/web';
+export class RedirectError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RedirectError';
+    }
+}
+export const redirect = (url) => {
+    if (isServer) {
+        throw new RedirectError(url);
+    }
+    window.location.href = url;
+    return;
+};

package/utils/router.d.ts

@@ -0,0 +1,104 @@
+import { BaseFileSystemRouter } from 'vinxi/fs-router';
+export declare class ServerRouter extends BaseFileSystemRouter {
+    toPath(src: string): string;
+    toRoute(filePath: string): {
+        type: string;
+        path: string;
+        $handler: {
+            src: string;
+            pick: string[];
+        };
+        parent?: undefined;
+        $component?: undefined;
+        $loader?: undefined;
+        $options?: undefined;
+        $generateMeta?: undefined;
+    } | {
+        type: string;
+        parent: string;
+        path: string;
+        $handler: {
+            src: string;
+            pick: never[];
+        };
+        $component: {
+            src: string;
+            pick: string[];
+        };
+        $loader: {
+            src: string;
+            pick: string[];
+        };
+        $options: {
+            src: string;
+            pick: string[];
+        };
+        $generateMeta?: undefined;
+    } | {
+        type: string;
+        path: string;
+        $handler: {
+            src: string;
+            pick: never[];
+        };
+        $component: {
+            src: string;
+            pick: string[];
+        };
+        $loader: {
+            src: string;
+            pick: string[];
+        };
+        $generateMeta: {
+            src: string;
+            pick: string[];
+        };
+        $options: {
+            src: string;
+            pick: string[];
+        };
+        parent?: undefined;
+    } | {
+        type: string;
+        path: string;
+        $handler: {
+            src: string;
+            pick: never[];
+        };
+        $component: {
+            src: string;
+            pick: string[];
+        };
+        $generateMeta: {
+            src: string;
+            pick: string[];
+        };
+        $options: {
+            src: string;
+            pick: string[];
+        };
+        parent?: undefined;
+        $loader?: undefined;
+    } | undefined;
+}
+export declare class ClientRouter extends BaseFileSystemRouter {
+    toPath(src: string): string;
+    toRoute(filePath: string): {
+        type: string;
+        parent: string;
+        path: string;
+        $component: {
+            src: string;
+            pick: string[];
+        };
+    } | {
+        type: string;
+        path: string;
+        $component: {
+            src: string;
+            pick: string[];
+        };
+        parent?: undefined;
+    } | undefined;
+}
+//# sourceMappingURL=router.d.ts.map

package/utils/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../utils/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAa,MAAM,iBAAiB,CAAC;AAMlE,qBAAa,YAAa,SAAQ,oBAAoB;IAClD,MAAM,CAAC,GAAG,EAAE,MAAM;IAclB,OAAO,CAAC,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsK3B;AAED,qBAAa,YAAa,SAAQ,oBAAoB;IAClD,MAAM,CAAC,GAAG,EAAE,MAAM;IAgBlB,OAAO,CAAC,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;CA2E3B"}

package/utils/router.js

@@ -0,0 +1,258 @@
+import { BaseFileSystemRouter, cleanPath } from 'vinxi/fs-router';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class ServerRouter extends BaseFileSystemRouter {
+    toPath(src) {
+        const routePath = cleanPath(src, this.config)
+            .replace(new RegExp(`\.(${(this.config.extensions ?? []).join('|')})$`), '')
+            .replace(/\/(page|route|layout|error|not-found|loading)$/, '');
+        // src = src
+        //     .slice((`${__dirname}/app`).length);
+        // const routePath = src
+        //     .replace(new RegExp(`\.(${(this.config.extensions ?? []).join('|')})$`), '')
+        //     .replace(/\/(page|route|layout|error|not-found|loading)$/, '');
+        return routePath?.length > 0 ? routePath : '/';
+    }
+    toRoute(filePath) {
+        const path = this.toPath(filePath);
+        if ((/\/route\.(js|ts)$/).test(filePath)) {
+            return {
+                type: 'route',
+                path: `/route${path}`,
+                $handler: {
+                    src: filePath,
+                    pick: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
+                },
+            };
+        }
+        // biome-ignore lint/correctness/noEmptyCharacterClassInRegex: <explanation>
+        const scopedPackageMatch = path.match(/@[^]+/g);
+        if (scopedPackageMatch) {
+            // Remove the scoped package part
+            const scopedPackage = scopedPackageMatch[0];
+            const parent = path.replace(`/${scopedPackage}`, '');
+            return {
+                type: 'group',
+                parent: parent,
+                path: `/group${path}`,
+                $handler: {
+                    src: filePath,
+                    pick: []
+                },
+                $component: {
+                    src: filePath,
+                    pick: ['default'],
+                },
+                $loader: {
+                    src: filePath,
+                    pick: ['loader'],
+                },
+                $options: {
+                    src: filePath,
+                    pick: ['options'],
+                },
+            };
+        }
+        if ((/\/page\.(jsx|js|tsx|ts)$/).test(filePath)) {
+            return {
+                type: 'route',
+                path: `/route${path}`,
+                $handler: {
+                    src: filePath,
+                    pick: []
+                },
+                $component: {
+                    src: filePath,
+                    pick: ['default'],
+                },
+                $loader: {
+                    src: filePath,
+                    pick: ['loader'],
+                },
+                $generateMeta: {
+                    src: filePath,
+                    pick: ['generateMeta'],
+                },
+                $options: {
+                    src: filePath,
+                    pick: ['options'],
+                },
+            };
+        }
+        if ((/\/layout\.(jsx|js|tsx|ts)$/).test(filePath)) {
+            return {
+                type: 'layout',
+                path: `/layout${path}`,
+                $handler: {
+                    src: filePath,
+                    pick: []
+                },
+                $component: {
+                    src: filePath,
+                    pick: ['default'],
+                },
+                $loader: {
+                    src: filePath,
+                    pick: ['loader'],
+                },
+                $generateMeta: {
+                    src: filePath,
+                    pick: ['generateMeta'],
+                },
+                $options: {
+                    src: filePath,
+                    pick: ['options'],
+                },
+            };
+        }
+        if ((/\/error\.(jsx|js|tsx|ts)$/).test(filePath)) {
+            return {
+                type: 'error',
+                path: `/error${path}`,
+                $handler: {
+                    src: filePath,
+                    pick: []
+                },
+                $component: {
+                    src: filePath,
+                    pick: ['default'],
+                },
+                $generateMeta: {
+                    src: filePath,
+                    pick: ['generateMeta'],
+                },
+                $options: {
+                    src: filePath,
+                    pick: ['options'],
+                },
+            };
+        }
+        if ((/\/loading\.(jsx|js|tsx|ts)$/).test(filePath)) {
+            return {
+                type: 'loading',
+                path: `/loading${path}`,
+                $handler: {
+                    src: filePath,
+                    pick: []
+                },
+                $component: {
+                    src: filePath,
+                    pick: ['default'],
+                },
+                $generateMeta: {
+                    src: filePath,
+                    pick: ['generateMeta'],
+                },
+                $options: {
+                    src: filePath,
+                    pick: ['options'],
+                },
+            };
+        }
+        if ((/\/not-found\.(jsx|js|tsx|ts)$/).test(filePath) && path === '/') {
+            return {
+                type: 'not-found',
+                path: `/not-found${path}`,
+                $handler: {
+                    src: filePath,
+                    pick: []
+                },
+                $component: {
+                    src: filePath,
+                    pick: ['default'],
+                },
+                $generateMeta: {
+                    src: filePath,
+                    pick: ['generateMeta'],
+                },
+                $options: {
+                    src: filePath,
+                    pick: ['options'],
+                },
+            };
+        }
+    }
+}
+export class ClientRouter extends BaseFileSystemRouter {
+    toPath(src) {
+        const routePath = cleanPath(src, this.config)
+            .replace(new RegExp(`\.(${(this.config.extensions ?? []).join('|')})$`), '')
+            .replace(/\/(page|route|layout|error|not-found|loading)$/, '');
+        // src = src
+        //     .slice((`${__dirname}/app`).length);
+        // const routePath = src
+        //     .replace(new RegExp(`\.(${(this.config.extensions ?? []).join('|')})$`), '')
+        //     .replace(/\/(page|layout|error|not-found|loading)$/, '');
+        return routePath?.length > 0 ? routePath : '/';
+    }
+    toRoute(filePath) {
+        const path = this.toPath(filePath);
+        // biome-ignore lint/correctness/noEmptyCharacterClassInRegex: <explanation>
+        const scopedPackageMatch = path.match(/@[^]+/g);
+        if (scopedPackageMatch) {
+            // Remove the scoped package part
+            const scopedPackage = scopedPackageMatch[0];
+            const parent = path.replace(`/${scopedPackage}`, '');
+            return {
+                type: 'group',
+                parent: parent,
+                path: `/group${path}`,
+                $component: {
+                    src: filePath,
+                    pick: ['default', '$css'],
+                },
+            };
+        }
+        if ((/\/page\.(jsx|js|tsx|ts)$/).test(filePath)) {
+            return {
+                type: 'route',
+                path: `/route${path}`,
+                $component: {
+                    src: filePath,
+                    pick: ['default', '$css'],
+                },
+            };
+        }
+        if ((/\/layout\.(jsx|js|tsx|ts)$/).test(filePath)) {
+            return {
+                type: 'layout',
+                path: `/layout${path}`,
+                $component: {
+                    src: filePath,
+                    pick: ['default', '$css'],
+                },
+            };
+        }
+        if ((/\/error\.(jsx|js|tsx|ts)$/).test(filePath)) {
+            return {
+                type: 'error',
+                path: `/error${path}`,
+                $component: {
+                    src: filePath,
+                    pick: ['default', '$css'],
+                },
+            };
+        }
+        if ((/\/loading\.(jsx|js|tsx|ts)$/).test(filePath)) {
+            return {
+                type: 'loading',
+                path: `/loading${path}`,
+                $component: {
+                    src: filePath,
+                    pick: ['default', '$css'],
+                },
+            };
+        }
+        if ((/\/not-found\.(jsx|js|tsx|ts)$/).test(filePath) && path === '/') {
+            return {
+                type: 'not-found',
+                path: `/not-found${path}`,
+                $component: {
+                    src: filePath,
+                    pick: ['default'],
+                },
+            };
+        }
+    }
+}

package/utils/server-action.client.d.ts

@@ -0,0 +1,2 @@
+export declare function createServerReference(fn: Function, id: string, name: string): Function;
+//# sourceMappingURL=server-action.client.d.ts.map

package/utils/server-action.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-action.client.d.ts","sourceRoot":"","sources":["../../utils/server-action.client.ts"],"names":[],"mappings":"AA2MA,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,YAyC3E"}