effect-start 0.16.0 → 0.17.1

package/dist/ContentNegotiation.js

@@ -0,0 +1,364 @@
+/**
+ * RFC 7231 Content Negotiation compatible with Express/Node.js ecosystem.
+ * Based on {@link https://github.com/jshttp/negotiator}
+ */
+const simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
+const simpleLanguageRegExp = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/;
+const simpleEncodingRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
+const simpleCharsetRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
+function parseQuality(params) {
+    if (!params)
+        return 1;
+    const match = params.match(/q\s*=\s*([0-9.]+)/);
+    if (!match)
+        return 1;
+    const q = parseFloat(match[1]);
+    return isNaN(q) ? 1 : Math.min(Math.max(q, 0), 1);
+}
+function splitMediaTypeParams(params) {
+    const result = {};
+    let q = 1;
+    const parts = params.split(";");
+    for (const part of parts) {
+        const trimmed = part.trim();
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.slice(0, eqIndex).trim().toLowerCase();
+        let value = trimmed.slice(eqIndex + 1).trim();
+        if (value.startsWith("\"") && value.endsWith("\"")) {
+            value = value.slice(1, -1);
+        }
+        if (key === "q") {
+            q = parseFloat(value);
+            if (isNaN(q))
+                q = 1;
+            q = Math.min(Math.max(q, 0), 1);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return { params: result, q };
+}
+function parseAccept(accept) {
+    const specs = [];
+    const parts = accept.split(",");
+    for (let o = 0; o < parts.length; o++) {
+        const part = parts[o].trim();
+        if (!part)
+            continue;
+        const match = simpleMediaTypeRegExp.exec(part);
+        if (!match)
+            continue;
+        const type = match[1].toLowerCase();
+        const subtype = match[2].toLowerCase();
+        const { params, q } = match[3]
+            ? splitMediaTypeParams(match[3])
+            : { params: {}, q: 1 };
+        if (q > 0) {
+            specs.push({ type, subtype, params, q, o });
+        }
+    }
+    return specs;
+}
+function specifyMediaType(type, subtype, params, spec) {
+    let s = 0;
+    if (spec.type === type) {
+        s |= 4; // exact match: highest specificity
+    }
+    else if (type === "*") {
+        s |= 0; // server offers wildcard (e.g. */*): matches any client type
+    }
+    else if (spec.type !== "*") {
+        // client is NOT requesting wildcard: no match
+        return null;
+    }
+    // client requests wildcard (e.g. Accept: */*)
+    if (spec.subtype === subtype) {
+        s |= 2; // // exact match: highest specificity
+    }
+    else if (subtype === "*") {
+        s |= 1; // server offers wildcard (e.g. text/*)
+    }
+    else if (spec.subtype !== "*") {
+        return null; // client is NOT requesting wildcard
+    }
+    // client requests wildcard (e.g. Accept: text/*): matches any server subtype
+    const specParams = Object.keys(spec.params);
+    if (specParams.length > 0) {
+        if (specParams.every((key) => spec.params[key].toLowerCase() === (params[key] || "").toLowerCase())) {
+            s |= 1;
+        }
+        else {
+            return null;
+        }
+    }
+    return { q: spec.q, s, o: spec.o };
+}
+function getMediaTypePriority(mediaType, accepted, index) {
+    let best = null;
+    const match = simpleMediaTypeRegExp.exec(mediaType);
+    if (!match) {
+        return { value: mediaType, q: 0, s: 0, o: -1, i: index };
+    }
+    const type = match[1].toLowerCase();
+    const subtype = match[2].toLowerCase();
+    const { params } = match[3]
+        ? splitMediaTypeParams(match[3])
+        : { params: {} };
+    for (const spec of accepted) {
+        const result = specifyMediaType(type, subtype, params, spec);
+        if (result
+            && (best === null
+                || result.s > best.s
+                || (result.s === best.s && result.q > best.q)
+                || (result.s === best.s && result.q === best.q && result.o < best.o))) {
+            best = result;
+        }
+    }
+    return {
+        value: mediaType,
+        q: best?.q ?? 0,
+        s: best?.s ?? 0,
+        o: best?.o ?? -1,
+        i: index,
+    };
+}
+function parseAcceptLanguage(accept) {
+    const specs = [];
+    const parts = accept.split(",");
+    for (let o = 0; o < parts.length; o++) {
+        const part = parts[o].trim();
+        if (!part)
+            continue;
+        const match = simpleLanguageRegExp.exec(part);
+        if (!match)
+            continue;
+        const prefix = match[1].toLowerCase();
+        const suffix = match[2]?.toLowerCase();
+        const q = parseQuality(match[3]);
+        if (q > 0) {
+            specs.push({ prefix, suffix, q, o });
+        }
+    }
+    return specs;
+}
+function specifyLanguage(language, spec) {
+    const match = simpleLanguageRegExp.exec(language);
+    if (!match)
+        return null;
+    const prefix = match[1].toLowerCase();
+    const suffix = match[2]?.toLowerCase();
+    if (spec.prefix === "*") {
+        return { q: spec.q, s: 0, o: spec.o };
+    }
+    if (spec.prefix !== prefix) {
+        return null;
+    }
+    if (spec.suffix === undefined) {
+        return { q: spec.q, s: suffix ? 2 : 4, o: spec.o };
+    }
+    if (spec.suffix === suffix) {
+        return { q: spec.q, s: 4, o: spec.o };
+    }
+    return null;
+}
+function getLanguagePriority(language, accepted, index) {
+    let best = null;
+    for (const spec of accepted) {
+        const result = specifyLanguage(language, spec);
+        if (result
+            && (best === null
+                || result.s > best.s
+                || (result.s === best.s && result.q > best.q)
+                || (result.s === best.s && result.q === best.q && result.o < best.o))) {
+            best = result;
+        }
+    }
+    return {
+        value: language,
+        q: best?.q ?? 0,
+        s: best?.s ?? 0,
+        o: best?.o ?? -1,
+        i: index,
+    };
+}
+function parseAcceptEncoding(accept) {
+    const specs = [];
+    const parts = accept.split(",");
+    let hasIdentity = false;
+    for (let o = 0; o < parts.length; o++) {
+        const part = parts[o].trim();
+        if (!part)
+            continue;
+        const match = simpleEncodingRegExp.exec(part);
+        if (!match)
+            continue;
+        const encoding = match[1].toLowerCase();
+        const q = parseQuality(match[2]);
+        if (encoding === "identity")
+            hasIdentity = true;
+        if (encoding === "*")
+            hasIdentity = true;
+        if (q > 0) {
+            specs.push({ encoding, q, o });
+        }
+    }
+    if (!hasIdentity) {
+        specs.push({ encoding: "identity", q: 0.0001, o: specs.length });
+    }
+    return specs;
+}
+function specifyEncoding(encoding, spec) {
+    const e = encoding.toLowerCase();
+    const s = spec.encoding;
+    if (s === "*" || s === e) {
+        return { q: spec.q, s: s === e ? 1 : 0, o: spec.o };
+    }
+    return null;
+}
+function getEncodingPriority(encoding, accepted, index) {
+    let best = null;
+    for (const spec of accepted) {
+        const result = specifyEncoding(encoding, spec);
+        if (result
+            && (best === null
+                || result.s > best.s
+                || (result.s === best.s && result.q > best.q)
+                || (result.s === best.s && result.q === best.q && result.o < best.o))) {
+            best = result;
+        }
+    }
+    return {
+        value: encoding,
+        q: best?.q ?? 0,
+        s: best?.s ?? 0,
+        o: best?.o ?? -1,
+        i: index,
+    };
+}
+function parseAcceptCharset(accept) {
+    const specs = [];
+    const parts = accept.split(",");
+    for (let o = 0; o < parts.length; o++) {
+        const part = parts[o].trim();
+        if (!part)
+            continue;
+        const match = simpleCharsetRegExp.exec(part);
+        if (!match)
+            continue;
+        const charset = match[1].toLowerCase();
+        const q = parseQuality(match[2]);
+        if (q > 0) {
+            specs.push({ charset, q, o });
+        }
+    }
+    return specs;
+}
+function specifyCharset(charset, spec) {
+    const c = charset.toLowerCase();
+    const s = spec.charset;
+    if (s === "*" || s === c) {
+        return { q: spec.q, s: s === c ? 1 : 0, o: spec.o };
+    }
+    return null;
+}
+function getCharsetPriority(charset, accepted, index) {
+    let best = null;
+    for (const spec of accepted) {
+        const result = specifyCharset(charset, spec);
+        if (result
+            && (best === null
+                || result.s > best.s
+                || (result.s === best.s && result.q > best.q)
+                || (result.s === best.s && result.q === best.q && result.o < best.o))) {
+            best = result;
+        }
+    }
+    return {
+        value: charset,
+        q: best?.q ?? 0,
+        s: best?.s ?? 0,
+        o: best?.o ?? -1,
+        i: index,
+    };
+}
+function compareSpecs(a, b) {
+    return (b.q - a.q
+        || b.s - a.s
+        || a.o - b.o
+        || a.i - b.i);
+}
+export function media(accept, available) {
+    const parsed = parseAccept(accept);
+    if (parsed.length === 0) {
+        return [];
+    }
+    if (!available) {
+        return parsed.sort((a, b) => b.q - a.q || a.o - b.o).map((p) => `${p.type}/${p.subtype}`);
+    }
+    const priorities = available.map((t, i) => getMediaTypePriority(t, parsed, i));
+    const sorted = priorities.filter((p) => p.q > 0).sort(compareSpecs);
+    return sorted.map((p) => p.value);
+}
+export function language(accept, available) {
+    const parsed = parseAcceptLanguage(accept);
+    if (parsed.length === 0) {
+        return [];
+    }
+    if (!available) {
+        return parsed.sort((a, b) => b.q - a.q || a.o - b.o).map((p) => p.suffix ? `${p.prefix}-${p.suffix}` : p.prefix);
+    }
+    const priorities = available.map((l, i) => getLanguagePriority(l, parsed, i));
+    const sorted = priorities.filter((p) => p.q > 0).sort(compareSpecs);
+    return sorted.map((p) => p.value);
+}
+export function encoding(accept, available) {
+    const parsed = parseAcceptEncoding(accept);
+    if (parsed.length === 0) {
+        return [];
+    }
+    if (!available) {
+        return parsed.sort((a, b) => b.q - a.q || a.o - b.o).map((p) => p.encoding);
+    }
+    const priorities = available.map((e, i) => getEncodingPriority(e, parsed, i));
+    const sorted = priorities.filter((p) => p.q > 0).sort(compareSpecs);
+    return sorted.map((p) => p.value);
+}
+export function charset(accept, available) {
+    const parsed = parseAcceptCharset(accept);
+    if (parsed.length === 0) {
+        return [];
+    }
+    if (!available) {
+        return parsed.sort((a, b) => b.q - a.q || a.o - b.o).map((p) => p.charset);
+    }
+    const priorities = available.map((c, i) => getCharsetPriority(c, parsed, i));
+    const sorted = priorities.filter((p) => p.q > 0).sort(compareSpecs);
+    return sorted.map((p) => p.value);
+}
+export function headerMedia(headers, available) {
+    const accept = headers["accept"];
+    if (!accept)
+        return [];
+    return media(accept, available);
+}
+export function headerLanguage(headers, available) {
+    const accept = headers["accept-language"];
+    if (!accept)
+        return [];
+    return language(accept, available);
+}
+export function headerEncoding(headers, available) {
+    const accept = headers["accept-encoding"];
+    if (!accept)
+        return [];
+    return encoding(accept, available);
+}
+export function headerCharset(headers, available) {
+    const accept = headers["accept-charset"];
+    if (!accept)
+        return [];
+    return charset(accept, available);
+}

package/dist/Development.d.ts

@@ -0,0 +1,34 @@
+import { Context, Effect, Layer, PubSub, Stream } from "effect";
+import { Error, FileSystem } from "./node/FileSystem.ts";
+export type DevelopmentEvent = FileSystem.WatchEvent | {
+    readonly _tag: "Reload";
+};
+/** @internal */
+export declare const _resetForTesting: () => void;
+export type DevelopmentService = {
+    events: PubSub.PubSub<DevelopmentEvent>;
+};
+declare const Development_base: Context.TagClass<Development, "effect-start/Development", DevelopmentService>;
+export declare class Development extends Development_base {
+}
+export declare const filterSourceFiles: (event: FileSystem.WatchEvent) => boolean;
+export declare const filterDirectory: (event: FileSystem.WatchEvent) => boolean;
+export declare const watchSource: (opts?: {
+    path?: string;
+    recursive?: boolean;
+    filter?: (event: FileSystem.WatchEvent) => boolean;
+}) => Stream.Stream<FileSystem.WatchEvent, Error.PlatformError, FileSystem.FileSystem>;
+export declare const watch: (opts?: {
+    path?: string;
+    recursive?: boolean;
+    filter?: (event: FileSystem.WatchEvent) => boolean;
+}) => Effect.Effect<{
+    events: PubSub.PubSub<DevelopmentEvent>;
+}, never, FileSystem.FileSystem>;
+export declare const layerWatch: (opts?: {
+    path?: string;
+    recursive?: boolean;
+    filter?: (event: FileSystem.WatchEvent) => boolean;
+}) => Layer.Layer<Development, never, FileSystem.FileSystem>;
+export declare const stream: () => Stream.Stream<DevelopmentEvent>;
+export {};

package/dist/Development.js

@@ -0,0 +1,52 @@
+import { Context, Effect, Function, Layer, Option, pipe, PubSub, Stream, } from "effect";
+import { globalValue } from "effect/GlobalValue";
+import { FileSystem, } from "./node/FileSystem.js";
+const devState = globalValue(Symbol.for("effect-start/Development"), () => ({
+    count: 0,
+    pubsub: null,
+}));
+/** @internal */
+export const _resetForTesting = () => {
+    devState.count = 0;
+    devState.pubsub = null;
+};
+export class Development extends Context.Tag("effect-start/Development")() {
+}
+const SOURCE_FILENAME = /\.(tsx?|jsx?|html?|css|json)$/;
+export const filterSourceFiles = (event) => {
+    return SOURCE_FILENAME.test(event.path);
+};
+export const filterDirectory = (event) => {
+    return event.path.endsWith("/");
+};
+export const watchSource = (opts) => {
+    const baseDir = opts?.path ?? process.cwd();
+    const customFilter = opts?.filter;
+    return Function.pipe(Stream.unwrap(Effect.map(FileSystem.FileSystem, fs => fs.watch(baseDir, { recursive: opts?.recursive ?? true }))), customFilter ? Stream.filter(customFilter) : Function.identity, Stream.rechunk(1), Stream.throttle({
+        units: 1,
+        cost: () => 1,
+        duration: "400 millis",
+        strategy: "enforce",
+    }));
+};
+export const watch = (opts) => Effect.gen(function* () {
+    devState.count++;
+    if (devState.count === 1) {
+        const pubsub = yield* PubSub.unbounded();
+        devState.pubsub = pubsub;
+        yield* pipe(watchSource({
+            path: opts?.path,
+            recursive: opts?.recursive,
+            filter: opts?.filter ?? filterSourceFiles,
+        }), Stream.runForEach((event) => PubSub.publish(pubsub, event)), Effect.fork);
+    }
+    else {
+        yield* PubSub.publish(devState.pubsub, { _tag: "Reload" });
+    }
+    return { events: devState.pubsub };
+});
+export const layerWatch = (opts) => Layer.scoped(Development, watch(opts));
+export const stream = () => Stream.unwrap(pipe(Effect.serviceOption(Development), Effect.map(Option.match({
+    onNone: () => Stream.empty,
+    onSome: (dev) => Stream.fromPubSub(dev.events),
+}))));

package/dist/Entity.d.ts

@@ -0,0 +1,47 @@
+import * as Effect from "effect/Effect";
+import * as ParseResult from "effect/ParseResult";
+import * as Pipeable from "effect/Pipeable";
+import * as Stream from "effect/Stream";
+import * as Values from "./Values.ts";
+export declare const TypeId: unique symbol;
+export type TypeId = typeof TypeId;
+/**
+ * Header keys are guaranteed to be lowercase.
+ */
+export type Headers = {
+    [header: string]: string | null | undefined;
+};
+export interface Entity<T = unknown, E = never> extends Pipeable.Pipeable {
+    readonly [TypeId]: TypeId;
+    readonly body: T;
+    readonly headers: Headers;
+    /**
+     * Accepts any valid URI (Uniform Resource Identifier), including URLs
+     * (http://, https://, file://), URNs (urn:isbn:...), S3 URIs (s3://bucket/key),
+     * data URIs, and other schemes. While commonly called "URL" in many APIs,
+     * this property handles URIs as the correct superset term per RFC 3986.
+     */
+    readonly url: string | undefined;
+    readonly status: number | undefined;
+    readonly text: T extends string ? Effect.Effect<T, ParseResult.ParseError | E> : Effect.Effect<string, ParseResult.ParseError | E>;
+    readonly json: [T] extends [Effect.Effect<infer A, any, any>] ? Effect.Effect<A extends string | Uint8Array | ArrayBuffer ? unknown : A, ParseResult.ParseError | E> : [T] extends [Stream.Stream<any, any, any>] ? Effect.Effect<unknown, ParseResult.ParseError | E> : [T] extends [string | Uint8Array | ArrayBuffer] ? Effect.Effect<unknown, ParseResult.ParseError | E> : [T] extends [Values.Json] ? Effect.Effect<T, ParseResult.ParseError | E> : Effect.Effect<unknown, ParseResult.ParseError | E>;
+    readonly bytes: Effect.Effect<Uint8Array, ParseResult.ParseError | E>;
+    readonly stream: T extends Stream.Stream<infer A, infer E1, any> ? Stream.Stream<A, ParseResult.ParseError | E | E1> : Stream.Stream<Uint8Array, ParseResult.ParseError | E>;
+}
+export interface Proto extends Pipeable.Pipeable {
+    readonly [TypeId]: TypeId;
+}
+export declare function isEntity(input: unknown): input is Entity;
+interface Options {
+    readonly headers?: Headers;
+    readonly url?: string;
+    readonly status?: number;
+}
+export declare function make<A, E>(body: Effect.Effect<A, E, never>, options?: Options): Entity<Effect.Effect<A, E, never>, E>;
+export declare function make<A extends Uint8Array | string, E>(body: Stream.Stream<A, E, never>, options?: Options): Entity<Stream.Stream<A, E, never>, E>;
+export declare function make<T>(body: T, options?: Options): Entity<T, never>;
+export declare function effect<A, E, R>(body: Effect.Effect<Entity<A> | A, E, R>): Entity<A, E>;
+export declare function resolve<A, E>(entity: Entity<A, E>): Effect.Effect<Entity<A, E>, E, never>;
+export declare function type(self: Entity): string;
+export declare function length(self: Entity): number | undefined;
+export {};