solidstep 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hamza Varvani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# @varlabs/create-solidstep
+Next Step SolidJS CLI for building web applications.
+
+## Getting Started
+
+To get started with a new SolidJS project using the Next Step CLI, run the following command:
+
+```bash
+npx @varlabs/create-solidstep@latest my-app
+```
+
+or
+
+```bash
+pnpm dlx @varlabs/create-solidstep@latest my-app
+```
+
+Replace `my-app` with the name of your project or if you don't specify a name, it will create a project in the current directory.

package/client.d.ts

@@ -0,0 +1,4 @@
+import 'vinxi/client';
+export declare const main: (modulePath: string, routeParams?: Record<string, string>, searchParams?: Record<string, string>, loaderDataManifest?: Record<string, any>) => Promise<void>;
+export default main;
+//# sourceMappingURL=client.d.ts.map

package/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../client.ts"],"names":[],"mappings":"AACA,OAAO,cAAc,CAAC;AAYtB,eAAO,MAAM,IAAI,GACb,YAAY,MAAM,EAClB,cAAa,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACxC,eAAc,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACzC,qBAAoB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,kBAsF/C,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/client.js

@@ -0,0 +1,91 @@
+import { hydrate } from 'solid-js/web';
+import 'vinxi/client';
+import fileRoutes from 'vinxi/routes';
+import { getManifest } from 'vinxi/manifest';
+const importModule = async (routeModule) => {
+    const manifest = getManifest('client');
+    if (import.meta.env.DEV) {
+        return await manifest.inputs[routeModule.src].import();
+    }
+    return await routeModule.import();
+};
+export const main = async (modulePath, routeParams = {}, searchParams = {}, loaderDataManifest = {}) => {
+    // find the route that matches the path
+    const pageModule = fileRoutes.find((route) => route.path === modulePath);
+    if (!pageModule) {
+        console.error(`No route found for path: ${modulePath}`);
+        return;
+    }
+    const pageLoaderData = loaderDataManifest[modulePath];
+    const segments = modulePath.split('/').slice(2);
+    if (segments.at(0)) {
+        segments.unshift('');
+    }
+    const layouts = [];
+    const layoutLoaderData = [];
+    const groups = {};
+    for (let i = 0; i < segments.length; i++) {
+        const path = `/${segments.slice(1, segments.length - i).join('/')}`;
+        const loaderData = loaderDataManifest[`/layout${path}`];
+        const layoutModule = fileRoutes.find((route) => {
+            const routePath = `/${route.path.split('/').slice(2).join('/')}`;
+            return routePath === path && route.type === 'layout';
+        });
+        if (layoutModule) {
+            layouts.unshift(layoutModule);
+        }
+        if (loaderData) {
+            layoutLoaderData.unshift(loaderData);
+        }
+    }
+    const groupModules = fileRoutes.filter((route) => {
+        const parentPath = route.parent || '';
+        return parentPath === segments.join('/') && route.type === 'group';
+    });
+    if (groupModules && groupModules.length > 0) {
+        for (const groupModule of groupModules) {
+            const groupName = groupModule.path.split('/').at(-1)?.replace('@', '');
+            if (!groupName)
+                continue;
+            groups[groupName] = groupModule;
+        }
+    }
+    const compose = layouts.reduceRight((children, layout, index) => async () => {
+        const { default: layoutModule } = await importModule(layout.$component);
+        const loaderData = layoutLoaderData[index] || {};
+        const slots = {};
+        const slotPromises = [children()];
+        if (index === layouts.length - 1) {
+            // last layout, we can render slots
+            for (const [groupName, group] of Object.entries(groups)) {
+                slotPromises.push((async () => {
+                    const { default: groupPage } = await importModule(group.$component);
+                    const groupLoaderData = loaderDataManifest[group.path] || {};
+                    slots[groupName] = () => groupPage({
+                        routeParams,
+                        searchParams,
+                        loaderData: groupLoaderData,
+                    });
+                })());
+            }
+        }
+        const [childrenRendered] = await Promise.all(slotPromises);
+        return () => layoutModule({
+            children: childrenRendered,
+            routeParams,
+            searchParams,
+            slots: slots,
+            loaderData,
+        });
+    }, async () => {
+        const { default: page } = await importModule(pageModule.$component);
+        return () => page({
+            routeParams,
+            searchParams,
+            loaderData: pageLoaderData || {},
+        });
+    });
+    const composed = await compose();
+    hydrate(() => composed(), document);
+};
+export default main;

package/index.d.ts

@@ -0,0 +1,11 @@
+import type { AppOptions } from 'vinxi';
+type Config = {
+    server?: Omit<AppOptions['server'], 'experimental'>;
+    plugins?: {
+        type: 'client' | 'server' | 'both';
+        plugin: any;
+    }[];
+};
+export declare const defineConfig: (config?: Config) => import("vinxi").App;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAWxC,KAAK,MAAM,GAAG;IACV,MAAM,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC,CAAC;IACpD,OAAO,CAAC,EAAE;QACN,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;QACnC,MAAM,EAAE,GAAG,CAAC;KACf,EAAE,CAAC;CACP,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,SAAQ,MAGpC,wBAoGA,CAAC"}

package/index.js

@@ -0,0 +1,97 @@
+import { createApp } from 'vinxi';
+import solid from 'vite-plugin-solid';
+// @ts-expect-error
+import { serverFunctions } from '@vinxi/server-functions/plugin';
+import { ServerRouter, ClientRouter } from './utils/router.js';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { cpSync, mkdirSync, existsSync } from 'node:fs';
+import { normalize } from 'vinxi/lib/path';
+export const defineConfig = (config = {
+    server: {},
+    plugins: [],
+}) => {
+    let middlewarePath = join(process.cwd(), 'app', 'middleware.ts');
+    if (!existsSync(middlewarePath)) {
+        middlewarePath = join(process.cwd(), 'app', 'middleware.js');
+    }
+    const app = createApp({
+        server: {
+            ...config.server,
+            experimental: {
+                asyncContext: true,
+            },
+        },
+        routers: [
+            {
+                name: 'public',
+                type: 'static',
+                dir: './public',
+                base: '/',
+            },
+            {
+                name: 'client',
+                type: 'client',
+                target: 'browser',
+                handler: normalize(fileURLToPath(new URL('./client.js', import.meta.url))),
+                plugins: () => [
+                    ...(config.plugins
+                        ?.filter(p => p.type === 'client' || p.type === 'both')
+                        .map(p => p.plugin) || []),
+                    serverFunctions.client({
+                        runtime: normalize(fileURLToPath(new URL('./utils/server-action.client.js', import.meta.url))),
+                    }),
+                    solid({ ssr: true }),
+                ],
+                base: '/_build',
+                routes: (router, app) => {
+                    return new ClientRouter({
+                        dir: join(process.cwd(), 'app'),
+                        extensions: ['jsx', 'js', 'tsx', 'ts'],
+                    }, router, app);
+                }
+            },
+            {
+                name: 'ssr',
+                type: 'http',
+                base: '/',
+                handler: normalize(fileURLToPath(new URL('./server.js', import.meta.url))),
+                target: 'server',
+                plugins: () => [
+                    ...(config.plugins
+                        ?.filter(p => p.type === 'server' || p.type === 'both')
+                        .map(p => p.plugin) || []),
+                    serverFunctions.server(),
+                    solid({ ssr: true }),
+                ],
+                middleware: './app/middleware.ts',
+                routes: (router, app) => {
+                    return new ServerRouter({
+                        dir: join(process.cwd(), 'app'),
+                        extensions: ['jsx', 'js', 'tsx', 'ts'],
+                    }, router, app);
+                }
+            },
+        ],
+    });
+    app.hooks.afterEach(event => {
+        if (event.name === 'app:build:nitro:end') {
+            const [{ nitro }] = event.args;
+            const serverDir = nitro.options.output.serverDir;
+            const fromDir = join(process.cwd(), 'server-assets');
+            if (existsSync(fromDir)) {
+                const toDir = join(serverDir, 'server-assets');
+                mkdirSync(toDir, { recursive: true });
+                cpSync(fromDir, toDir, {
+                    recursive: true,
+                    force: true,
+                });
+                console.log(`✔ Copied server assets from ${fromDir} to ${toDir}`);
+            }
+            else {
+                console.log(`ℹ No server assets to copy from ${fromDir}`);
+            }
+        }
+    });
+    return app;
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "solidstep",
+    "version": "0.1.0",
+    "description": "Next Step SolidJS Framework for building web applications.",
+    "type": "module",
+    "author": "HamzaKV <hamzakv333@gmail.com>",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/HamzaKV/solidstep.git"
+    },
+    "license": "MIT",
+    "exports": {
+        ".": "./index.js",
+        "./utils/hooks/action-state": "./utils/hooks/action-state.js",
+        "./utils/cache": "./utils/cache.js",
+        "./utils/cookies": "./utils/cookies.js",
+        "./utils/cors": "./utils/cors.js",
+        "./utils/csp": "./utils/csp.js",
+        "./utils/csrf": "./utils/csrf.js",
+        "./utils/error-handler": "./utils/error-handler.js",
+        "./utils/fetch.client": "./utils/fetch.client.js",
+        "./utils/fetch.server": "./utils/fetch.server.js",
+        "./utils/loader": "./utils/loader.js",
+        "./utils/redirect": "./utils/redirect.js",
+        "./utils/server-only": "./utils/server-only.js",
+        "./utils/types": "./utils/types.js"
+    },
+    "scripts": {
+        "clean": "rimraf ./dist",
+        "copy-files:root": "copyfiles -u 0 README.md package.json generate/**/* LICENSE ./dist",
+        "build": "pnpm clean && tsc && pnpm copy-files:root",
+        "test:local": "pnpm build && cd ./dist && pnpm link --global",
+        "test:local:clean": "pnpm unlink && pnpm clean",
+        "roll": "pnpm build && cd dist && npm publish"
+    },
+    "keywords": [
+        "solidjs",
+        "web-development",
+        "typescript",
+        "npm",
+        "solidstep",
+        "framework"
+    ],
+    "dependencies": {
+        "@vinxi/server-functions": "0.5.1",
+        "seroval": "^1.3.2",
+        "seroval-plugins": "^1.3.2",
+        "solid-js": "^1.9.7",
+        "undici": "^7.15.0",
+        "vinxi": "^0.5.8"
+    },
+    "devDependencies": {
+        "copyfiles": "^2.4.1",
+        "rimraf": "^6.0.1",
+        "typescript": "^5.8.3",
+        "vite-plugin-solid": "^2.11.7"
+    }
+}

package/server.d.ts

@@ -0,0 +1,3 @@
+declare const handler: import("vinxi/http").EventHandler<import("vinxi/http").EventHandlerRequest, Promise<unknown>>;
+export default handler;
+//# sourceMappingURL=server.d.ts.map

package/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../server.ts"],"names":[],"mappings":"AAggBA,QAAA,MAAM,OAAO,+FA+TX,CAAC;AAEH,eAAe,OAAO,CAAC"}