effect-start 0.23.1 → 0.26.0

package/dist/hyper/index.d.ts

@@ -1,6 +0,0 @@
-export * as Hyper from "./Hyper.ts";
-export { html } from "./html.ts";
-export type { HtmlString, HtmlValue } from "./html.ts";
-export * as HyperHtml from "./HyperHtml.ts";
-export * as HyperNode from "./HyperNode.ts";
-export * as HyperRoute from "./HyperRoute.ts";

package/dist/hyper/index.js

@@ -1,5 +0,0 @@
-export * as Hyper from "./Hyper.js";
-export { html } from "./html.js";
-export * as HyperHtml from "./HyperHtml.js";
-export * as HyperNode from "./HyperNode.js";
-export * as HyperRoute from "./HyperRoute.js";

package/dist/hyper/jsx-runtime.d.ts

@@ -1,7 +0,0 @@
-import * as HyperNode from "./HyperNode.ts";
-import type { JSX } from "./jsx.d.ts";
-declare function Fragment(props: {
-    children: JSX.Element;
-}): HyperNode.HyperNode;
-declare function jsx<T extends HyperNode.Type>(type: T, props: T extends string ? HyperNode.Props : T extends (props: infer P) => any ? P : never): HyperNode.HyperNode;
-export { Fragment, type JSX, jsx, jsx as jsxDEV, jsx as jsxs };

package/dist/hyper/jsx-runtime.js

@@ -1,8 +0,0 @@
-import * as HyperNode from "./HyperNode.js";
-function Fragment(props) {
-    return props.children;
-}
-function jsx(type, props) {
-    return HyperNode.make(type, props);
-}
-export { Fragment, jsx, jsx as jsxDEV, jsx as jsxs };

package/dist/index.d.ts

@@ -1,8 +0,0 @@
-export * as Bundle from "./bundler/Bundle.ts";
-export * as Development from "./Development.ts";
-export * as Entity from "./Entity.ts";
-export * as FileRouter from "./FileRouter.ts";
-export * as Route from "./Route.ts";
-export * as Start from "./Start.ts";
-export * as System from "./System.ts";
-export * as Unique from "./Unique.ts";

package/dist/index.js

@@ -1,8 +0,0 @@
-export * as Bundle from "./bundler/Bundle.js";
-export * as Development from "./Development.js";
-export * as Entity from "./Entity.js";
-export * as FileRouter from "./FileRouter.js";
-export * as Route from "./Route.js";
-export * as Start from "./Start.js";
-export * as System from "./System.js";
-export * as Unique from "./Unique.js";

package/dist/inference_check.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/inference_check.js

@@ -1,15 +0,0 @@
-import { Effect, Context } from "effect";
-import * as Route from "./RouteBody";
-const ServiceA = Context.GenericTag("ServiceA");
-const ServiceB = Context.GenericTag("ServiceB");
-const handler = function* () {
-    yield* ServiceA;
-    yield* ServiceB;
-    return "ok";
-};
-// Check 2: What does 'handle' infer?
-const resultHandler = Route.handle(handler);
-// Let's see if we can provide ServiceA and ServiceB and get a runnable effect (R=never)
-const provided = Effect.provideService(Effect.provideService(resultHandler({}, () => null), ServiceA, { status: 200 }), ServiceB, { status: 200 });
-const runnable = (e) => { };
-runnable(provided);

package/dist/lint/plugin.d.ts

@@ -1,86 +0,0 @@
-declare namespace _default {
-    namespace meta {
-        let name: string;
-        let version: string;
-    }
-    let rules: {
-        "prefer-namespace-import": {
-            meta: {
-                type: string;
-                docs: {
-                    description: string;
-                };
-                fixable: string;
-                hasSuggestions: boolean;
-                schema: never[];
-                messages: {
-                    preferNamespace: string;
-                };
-            };
-            create(context: any): {
-                ImportDeclaration(node: any): void;
-            };
-        };
-        "test-space-around": {
-            meta: {
-                type: string;
-                docs: {
-                    description: string;
-                };
-                fixable: string;
-                schema: never[];
-                messages: {
-                    requireBlankBefore: string;
-                    requireBlankAfter: string;
-                };
-            };
-            create(context: any): {
-                Program?: undefined;
-                BlockStatement?: undefined;
-            } | {
-                Program(node: any): void;
-                BlockStatement(node: any): void;
-            };
-        };
-        "export-default-before-functions": {
-            meta: {
-                type: string;
-                docs: {
-                    description: string;
-                };
-                schema: never[];
-                messages: {
-                    defaultAfterFunction: string;
-                };
-            };
-            create(context: any): {
-                Program(node: any): void;
-            };
-        };
-        "test-assertion-newline": {
-            meta: {
-                type: string;
-                docs: {
-                    description: string;
-                };
-                fixable: string;
-                schema: never[];
-                messages: {
-                    requireNewline: string;
-                    requireBlankBefore: string;
-                    requireBlankAfter: string;
-                };
-            };
-            create(context: any): {
-                ExpressionStatement?: undefined;
-                Program?: undefined;
-                BlockStatement?: undefined;
-            } | {
-                ExpressionStatement(node: any): void;
-                Program(node: any): void;
-                BlockStatement(node: any): void;
-            };
-        };
-    };
-}
-export default _default;

package/dist/lint/plugin.js

@@ -1,341 +0,0 @@
-/**
- * @see https://oxc.rs/docs/guide/usage/linter/js-plugins.html#using-js-plugins
- */
-const forceNamespace = new Set(["bun:test"]);
-export default {
-    meta: {
-        name: "effect-start",
-        version: "0.1.0",
-    },
-    rules: {
-        "prefer-namespace-import": {
-            meta: {
-                type: "suggestion",
-                docs: {
-                    description: "Enforce namespace imports for modules with capitalized base names or specific forced modules",
-                },
-                fixable: "code",
-                hasSuggestions: true,
-                schema: [],
-                messages: {
-                    preferNamespace: 'Use namespace import for module "{{source}}": import {{typePrefix}}* as {{baseName}} from "{{source}}"',
-                },
-            },
-            create(context) {
-                return {
-                    ImportDeclaration(node) {
-                        const source = node.source.value;
-                        if (typeof source !== "string")
-                            return;
-                        const baseName = getBaseName(source);
-                        if (!baseName)
-                            return;
-                        const forced = forceNamespace.has(source);
-                        if (!forced && !isCapitalized(baseName))
-                            return;
-                        // Already a namespace import (with or without type-only)
-                        if (node.specifiers.length === 1 &&
-                            node.specifiers[0].type === "ImportNamespaceSpecifier") {
-                            return;
-                        }
-                        // Skip if there are no specifiers (side-effect import)
-                        if (node.specifiers.length === 0)
-                            return;
-                        // Skip if it's only a default import (not applicable for forced modules)
-                        if (!forced) {
-                            const hasNamedImports = node.specifiers.some((s) => s.type === "ImportSpecifier");
-                            if (!hasNamedImports)
-                                return;
-                        }
-                        const typePrefix = node.importKind === "type" ? "type " : "";
-                        context.report({
-                            node,
-                            messageId: "preferNamespace",
-                            data: { source, baseName, typePrefix },
-                            fix(fixer) {
-                                return fixer.replaceText(node, `import ${typePrefix}* as ${baseName} from "${source}"`);
-                            },
-                        });
-                    },
-                };
-            },
-        },
-        "test-space-around": {
-            meta: {
-                type: "layout",
-                docs: {
-                    description: "Enforce blank lines around test calls (test.describe, test.it, etc.)",
-                },
-                fixable: "whitespace",
-                schema: [],
-                messages: {
-                    requireBlankBefore: "Test call should be preceded by a blank line",
-                    requireBlankAfter: "Test call should be followed by a blank line",
-                },
-            },
-            create(context) {
-                const filename = context.filename || context.getFilename();
-                if (!filename.endsWith(".test.ts") && !filename.endsWith(".test.tsx")) {
-                    return {};
-                }
-                function isTestCall(node) {
-                    return (node &&
-                        node.type === "ExpressionStatement" &&
-                        node.expression.type === "CallExpression" &&
-                        node.expression.callee.type === "MemberExpression" &&
-                        node.expression.callee.object.type === "Identifier" &&
-                        node.expression.callee.object.name === "test");
-                }
-                function checkBlankLines(siblings) {
-                    const sourceCode = context.sourceCode || context.getSourceCode();
-                    for (let i = 0; i < siblings.length; i++) {
-                        const node = siblings[i];
-                        if (!isTestCall(node))
-                            continue;
-                        const prev = siblings[i - 1];
-                        const next = siblings[i + 1];
-                        if (prev) {
-                            if (node.loc.start.line - prev.loc.end.line < 2) {
-                                context.report({
-                                    node,
-                                    messageId: "requireBlankBefore",
-                                    fix(fixer) {
-                                        return fixer.insertTextAfter(sourceCode.getLastToken(prev), "\n");
-                                    },
-                                });
-                            }
-                        }
-                        if (next) {
-                            if (next.loc.start.line - node.loc.end.line < 2) {
-                                context.report({
-                                    node,
-                                    messageId: "requireBlankAfter",
-                                    fix(fixer) {
-                                        return fixer.insertTextAfter(sourceCode.getLastToken(node), "\n");
-                                    },
-                                });
-                            }
-                        }
-                    }
-                }
-                return {
-                    Program(node) {
-                        checkBlankLines(node.body);
-                    },
-                    BlockStatement(node) {
-                        checkBlankLines(node.body);
-                    },
-                };
-            },
-        },
-        // this doens't work reliably and may cause runtime errors
-        "export-default-before-functions": {
-            meta: {
-                type: "suggestion",
-                docs: {
-                    description: "Enforce export default appears before any function declarations",
-                },
-                schema: [],
-                messages: {
-                    defaultAfterFunction: "export default should appear before function declarations",
-                },
-            },
-            create(context) {
-                return {
-                    Program(node) {
-                        let seenFunction = false;
-                        for (const stmt of node.body) {
-                            if (!seenFunction && isFunction(stmt)) {
-                                seenFunction = true;
-                            }
-                            if (seenFunction && stmt.type === "ExportDefaultDeclaration") {
-                                context.report({
-                                    node: stmt,
-                                    messageId: "defaultAfterFunction",
-                                });
-                            }
-                        }
-                    },
-                };
-            },
-        },
-        "test-assertion-newline": {
-            meta: {
-                type: "layout",
-                docs: {
-                    description: "Enforce newlines between chained test assertion methods (test.expect().toBe())",
-                },
-                fixable: "whitespace",
-                schema: [],
-                messages: {
-                    requireNewline: "Each chained method in a test assertion should be on its own line",
-                    requireBlankBefore: "Test assertion should be preceded by an empty line (unless preceded by another assertion)",
-                    requireBlankAfter: "Test assertion should be followed by an empty line (unless followed by another assertion)",
-                },
-            },
-            create(context) {
-                const filename = context.filename || context.getFilename();
-                if (!filename.endsWith(".test.ts") && !filename.endsWith(".test.tsx")) {
-                    return {};
-                }
-                /**
-                 * Check if a call expression is rooted in test.expect or test.expectTypeOf
-                 */
-                function isTestAssertionChain(node) {
-                    let current = node;
-                    while (current) {
-                        if (current.type === "CallExpression" && current.callee.type === "MemberExpression") {
-                            const obj = current.callee.object;
-                            // Check for test.expect(...) or test.expectTypeOf(...)
-                            if (obj.type === "CallExpression" &&
-                                obj.callee.type === "MemberExpression" &&
-                                obj.callee.object.type === "Identifier" &&
-                                obj.callee.object.name === "test" &&
-                                obj.callee.property.type === "Identifier" &&
-                                (obj.callee.property.name === "expect" ||
-                                    obj.callee.property.name === "expectTypeOf")) {
-                                return true;
-                            }
-                            // Direct: test.expect(...) or test.expectTypeOf(...)
-                            if (current.callee.object.type === "Identifier" &&
-                                current.callee.object.name === "test" &&
-                                current.callee.property.type === "Identifier" &&
-                                (current.callee.property.name === "expect" ||
-                                    current.callee.property.name === "expectTypeOf")) {
-                                return true;
-                            }
-                            // Walk up the chain
-                            current = current.callee.object;
-                            continue;
-                        }
-                        // Handle non-call member access like .not
-                        if (current.type === "MemberExpression") {
-                            current = current.object;
-                            continue;
-                        }
-                        break;
-                    }
-                    return false;
-                }
-                /**
-                 * Collect all member expressions in a chained call.
-                 */
-                function getChainedMembers(node) {
-                    const members = [];
-                    let current = node;
-                    while (current.type === "CallExpression" && current.callee.type === "MemberExpression") {
-                        members.push(current.callee);
-                        current = current.callee.object;
-                    }
-                    return members;
-                }
-                function isAssertionStatement(stmt) {
-                    return (stmt &&
-                        stmt.type === "ExpressionStatement" &&
-                        stmt.expression.type === "CallExpression" &&
-                        isTestAssertionChain(stmt.expression));
-                }
-                function checkChainedNewlines(node) {
-                    const members = getChainedMembers(node.expression);
-                    for (const member of members) {
-                        const objectEndLine = member.object.loc.end.line;
-                        const propertyStartLine = member.property.loc.start.line;
-                        if (objectEndLine === propertyStartLine) {
-                            const sourceCode = context.sourceCode || context.getSourceCode();
-                            const dot = sourceCode.getTokenBefore(member.property);
-                            if (dot && dot.value === ".") {
-                                context.report({
-                                    node: member.property,
-                                    messageId: "requireNewline",
-                                    fix(fixer) {
-                                        const stmtStartCol = node.loc.start.column;
-                                        const indent = " ".repeat(stmtStartCol + 2);
-                                        return fixer.replaceTextRange([member.object.range[1], member.property.range[0]], "\n" + indent + ".");
-                                    },
-                                });
-                            }
-                        }
-                    }
-                }
-                function checkBlankLines(siblings) {
-                    const sourceCode = context.sourceCode || context.getSourceCode();
-                    for (let i = 0; i < siblings.length; i++) {
-                        const node = siblings[i];
-                        if (!isAssertionStatement(node))
-                            continue;
-                        const prev = siblings[i - 1];
-                        const next = siblings[i + 1];
-                        if (prev && !isAssertionStatement(prev)) {
-                            if (node.loc.start.line - prev.loc.end.line < 2) {
-                                context.report({
-                                    node,
-                                    messageId: "requireBlankBefore",
-                                    fix(fixer) {
-                                        return fixer.insertTextAfter(sourceCode.getLastToken(prev), "\n");
-                                    },
-                                });
-                            }
-                        }
-                        if (next && !isAssertionStatement(next)) {
-                            if (next.loc.start.line - node.loc.end.line < 2) {
-                                context.report({
-                                    node,
-                                    messageId: "requireBlankAfter",
-                                    fix(fixer) {
-                                        return fixer.insertTextAfter(sourceCode.getLastToken(node), "\n");
-                                    },
-                                });
-                            }
-                        }
-                    }
-                }
-                return {
-                    ExpressionStatement(node) {
-                        if (node.expression.type !== "CallExpression")
-                            return;
-                        if (!isTestAssertionChain(node.expression))
-                            return;
-                        checkChainedNewlines(node);
-                    },
-                    Program(node) {
-                        checkBlankLines(node.body);
-                    },
-                    BlockStatement(node) {
-                        checkBlankLines(node.body);
-                    },
-                };
-            },
-        },
-    },
-};
-function getBaseName(source) {
-    // Handle node: and bun: protocols
-    if (source.startsWith("node:")) {
-        return source.slice(5);
-    }
-    if (source.startsWith("bun:")) {
-        return source.slice(4);
-    }
-    // Get last path segment
-    const segments = source.split("/");
-    let last = segments[segments.length - 1];
-    // Strip file extension (.ts, .tsx, .js, .jsx, .mjs, .cjs)
-    last = last.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "");
-    return last;
-}
-function isCapitalized(name) {
-    return name.length > 0 && name[0] >= "A" && name[0] <= "Z";
-}
-function isFunction(stmt) {
-    const decl = stmt.type === "ExportNamedDeclaration" && stmt.declaration ? stmt.declaration : stmt;
-    if (decl.type === "FunctionDeclaration")
-        return true;
-    if (decl.type === "VariableDeclaration" &&
-        decl.declarations.length > 0 &&
-        decl.declarations[0].init &&
-        (decl.declarations[0].init.type === "ArrowFunctionExpression" ||
-            decl.declarations[0].init.type === "FunctionExpression")) {
-        return true;
-    }
-    return false;
-}

package/dist/middlewares/BasicAuthMiddleware.d.ts

@@ -1,8 +0,0 @@
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
-import * as Effect from "effect/Effect";
-export interface BasicAuthConfig {
-    readonly username: string;
-    readonly password: string;
-}
-export declare const make: (config: BasicAuthConfig) => <E, R>(app: import("@effect/platform/HttpApp").Default<E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, HttpServerRequest.HttpServerRequest | R>;

package/dist/middlewares/BasicAuthMiddleware.js

@@ -1,22 +0,0 @@
-import * as HttpMiddleware from "@effect/platform/HttpMiddleware";
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
-import * as Effect from "effect/Effect";
-const unauthorizedResponse = HttpServerResponse.empty({
-    status: 401,
-    headers: { "WWW-Authenticate": "Basic" },
-});
-export const make = (config) => HttpMiddleware.make((app) => Effect.gen(function* () {
-    const request = yield* HttpServerRequest.HttpServerRequest;
-    const authHeader = request.headers.authorization;
-    if (!authHeader || !authHeader.startsWith("Basic ")) {
-        return unauthorizedResponse;
-    }
-    const base64Credentials = authHeader.slice(6);
-    const credentials = atob(base64Credentials);
-    const [username, password] = credentials.split(":");
-    if (username !== config.username || password !== config.password) {
-        return unauthorizedResponse;
-    }
-    return yield* app;
-}));

package/dist/middlewares/index.d.ts

@@ -1 +0,0 @@
-export * as BasicAuthMiddleware from "./BasicAuthMiddleware.ts";

package/dist/middlewares/index.js

@@ -1 +0,0 @@
-export * as BasicAuthMiddleware from "./BasicAuthMiddleware.js";