@fragno-dev/core 0.0.1

package/src/util/content-type.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it } from "vitest";
+import { parseContentType } from "./content-type";
+
+describe("parseContentType", () => {
+  it("should parse simple content types", () => {
+    const result = parseContentType("application/json");
+    expect(result).toEqual({
+      type: "application",
+      subtype: "json",
+      mediaType: "application/json",
+      parameters: {},
+    });
+  });
+
+  it("should parse content types with parameters", () => {
+    const result = parseContentType("application/x-ndjson; charset=utf-8");
+    expect(result).toEqual({
+      type: "application",
+      subtype: "x-ndjson",
+      mediaType: "application/x-ndjson",
+      parameters: { charset: "utf-8" },
+    });
+  });
+
+  it("should parse multiple parameters", () => {
+    const result = parseContentType(
+      "multipart/form-data; boundary=----WebKitFormBoundary; charset=utf-8",
+    );
+    expect(result).toEqual({
+      type: "multipart",
+      subtype: "form-data",
+      mediaType: "multipart/form-data",
+      parameters: {
+        boundary: "----WebKitFormBoundary",
+        charset: "utf-8",
+      },
+    });
+  });
+
+  it("should handle quoted parameter values", () => {
+    const result = parseContentType('text/plain; charset="utf-8"');
+    expect(result).toEqual({
+      type: "text",
+      subtype: "plain",
+      mediaType: "text/plain",
+      parameters: { charset: "utf-8" },
+    });
+  });
+
+  it("should normalize to lowercase", () => {
+    const result = parseContentType("Application/JSON; Charset=UTF-8");
+    expect(result).toEqual({
+      type: "application",
+      subtype: "json",
+      mediaType: "application/json",
+      parameters: { charset: "UTF-8" },
+    });
+  });
+
+  it("should handle extra whitespace", () => {
+    const result = parseContentType("  text/html  ;  charset = utf-8  ");
+    expect(result).toEqual({
+      type: "text",
+      subtype: "html",
+      mediaType: "text/html",
+      parameters: { charset: "utf-8" },
+    });
+  });
+
+  it("should return null for invalid input", () => {
+    expect(parseContentType("")).toBeNull();
+    expect(parseContentType(null as unknown as string)).toBeNull();
+    expect(parseContentType(undefined as unknown as string)).toBeNull();
+    expect(parseContentType(123 as unknown as string)).toBeNull();
+  });
+
+  it("should return null for invalid media types", () => {
+    expect(parseContentType("invalid")).toBeNull();
+    expect(parseContentType("/")).toBeNull();
+    expect(parseContentType("text/")).toBeNull();
+    expect(parseContentType("/json")).toBeNull();
+  });
+
+  it("should handle parameters without values gracefully", () => {
+    const result = parseContentType("text/plain; charset");
+    expect(result).toEqual({
+      type: "text",
+      subtype: "plain",
+      mediaType: "text/plain",
+      parameters: {},
+    });
+  });
+
+  it("should handle complex real-world examples", () => {
+    const result = parseContentType("application/vnd.api+json; charset=utf-8; version=1");
+    expect(result).toEqual({
+      type: "application",
+      subtype: "vnd.api+json",
+      mediaType: "application/vnd.api+json",
+      parameters: {
+        charset: "utf-8",
+        version: "1",
+      },
+    });
+  });
+
+  it("should handle text/event-stream", () => {
+    const result = parseContentType("text/event-stream; charset=utf-8");
+    expect(result).toEqual({
+      type: "text",
+      subtype: "event-stream",
+      mediaType: "text/event-stream",
+      parameters: { charset: "utf-8" },
+    });
+  });
+
+  it("should parse application/octet-stream", () => {
+    const result = parseContentType("application/octet-stream");
+    expect(result).toEqual({
+      type: "application",
+      subtype: "octet-stream",
+      mediaType: "application/octet-stream",
+      parameters: {},
+    });
+  });
+
+  it("should handle empty string parameters", () => {
+    const result = parseContentType('text/plain; charset=""');
+    expect(result).toEqual({
+      type: "text",
+      subtype: "plain",
+      mediaType: "text/plain",
+      parameters: { charset: "" },
+    });
+  });
+});

package/src/util/content-type.ts

@@ -0,0 +1,84 @@
+/**
+ * Represents a parsed content-type header
+ */
+export interface ParsedContentType {
+  /** The main type (e.g., "application", "text", "image") */
+  type: string;
+  /** The subtype (e.g., "json", "html", "png") */
+  subtype: string;
+  /** The full media type (e.g., "application/json") */
+  mediaType: string;
+  /** Additional parameters like charset, boundary, etc. */
+  parameters: Record<string, string>;
+}
+
+/**
+ * Parses a content-type header string into its components
+ *
+ * @param contentType - The content-type header value to parse
+ * @returns A ParsedContentType object or null if the input is invalid
+ *
+ * @example
+ * ```ts
+ * const { type, subtype, mediaType, parameters }
+ *        = parseContentType("application/json; charset=utf-8");
+ * console.assert(type === "application");
+ * console.assert(subtype === "json");
+ * console.assert(mediaType === "application/json");
+ * console.assert(parameters["charset"] === "utf-8");
+ */
+export function parseContentType(contentType: string | null | undefined): ParsedContentType | null {
+  if (!contentType || typeof contentType !== "string") {
+    return null;
+  }
+
+  const trimmed = contentType.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  const parts = trimmed.split(";").map((part) => part.trim());
+  const mediaType = parts[0];
+
+  if (!mediaType) {
+    return null;
+  }
+
+  const typeParts = mediaType.split("/");
+  if (typeParts.length !== 2) {
+    return null;
+  }
+
+  const [type, subtype] = typeParts.map((part) => part.trim().toLowerCase());
+
+  if (!type || !subtype) {
+    return null;
+  }
+
+  const parameters: Record<string, string> = {};
+
+  for (let i = 1; i < parts.length; i++) {
+    const param = parts[i];
+    const equalIndex = param.indexOf("=");
+
+    if (equalIndex > 0) {
+      const key = param.slice(0, equalIndex).trim().toLowerCase();
+      let value = param.slice(equalIndex + 1).trim();
+
+      if (value.startsWith('"') && value.endsWith('"')) {
+        value = value.slice(1, -1);
+      }
+
+      if (key) {
+        parameters[key] = value;
+      }
+    }
+  }
+
+  return {
+    type,
+    subtype,
+    mediaType: `${type}/${subtype}`,
+    parameters,
+  };
+}

package/src/util/nanostores.test.ts

@@ -0,0 +1,28 @@
+import { describe, test, expect } from "vitest";
+import { isReadableAtom } from "./nanostores";
+import { atom, map } from "nanostores";
+
+describe("nanostores", () => {
+  test("isReadableAtom should return true for a readable atom", () => {
+    const store = atom(0);
+    expect(isReadableAtom(store)).toBe(true);
+  });
+
+  test("isReadableAtom should return false for a non-readable atom", () => {
+    const store = { get: () => 0 };
+    expect(isReadableAtom(store)).toBe(false);
+  });
+
+  test("isReadableAtom should return false for a non-object", () => {
+    expect(isReadableAtom(0)).toBe(false);
+  });
+
+  test("isReadableAtom should return false for a null value", () => {
+    expect(isReadableAtom(null)).toBe(false);
+  });
+
+  test("isReadableAtom should return true for map", () => {
+    const store = map({ a: 1 });
+    expect(isReadableAtom(store)).toBe(true);
+  });
+});

package/src/util/nanostores.ts

@@ -0,0 +1,65 @@
+import type { ReadableAtom } from "nanostores";
+
+type MaybeAtom<T> = T | ReadableAtom<T>;
+
+/**
+ * Normalizes a value that could be a plain value, an Atom, or a Vue Ref to a plain value.
+ */
+export function unwrapAtom<T>(value: MaybeAtom<T>): T {
+  // Check if it's an Atom (has .get method)
+  if (value && typeof value === "object" && "get" in value && typeof value.get === "function") {
+    return value.get();
+  }
+
+  return value as T;
+}
+
+/**
+ * Normalizes an object where values can be plain values, Atoms, or Vue Refs.
+ * Returns a new object with all values normalized to plain values.
+ */
+export function unwrapObject<T>(
+  params: Record<string, MaybeAtom<T>> | undefined,
+): Record<string, T> | undefined {
+  if (!params) {
+    return undefined;
+  }
+
+  return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, unwrapAtom(value)]));
+}
+
+export function isReadableAtom(value: unknown): value is ReadableAtom<unknown> {
+  if (!value) {
+    return false;
+  }
+
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  if (!("get" in value) || typeof value.get !== "function") {
+    return false;
+  }
+
+  if (!("lc" in value) || typeof value.lc !== "number") {
+    return false;
+  }
+
+  if (!("notify" in value) || typeof value.notify !== "function") {
+    return false;
+  }
+
+  if (!("off" in value) || typeof value.off !== "function") {
+    return false;
+  }
+
+  if (!("subscribe" in value) || typeof value.subscribe !== "function") {
+    return false;
+  }
+
+  if (!("value" in value)) {
+    return false;
+  }
+
+  return true;
+}

package/src/util/ssr.ts

@@ -0,0 +1,75 @@
+import { allTasks } from "nanostores";
+import type { FetcherStore } from "@nanostores/query";
+
+let stores: FetcherStore[] = [];
+
+export const SSR_ENABLED = false;
+
+export function getStores() {
+  return stores;
+}
+
+export function addStore(store: FetcherStore) {
+  stores.push(store);
+}
+
+export function cleanStores() {
+  stores = [];
+}
+
+// Client side
+declare global {
+  interface Window {
+    __FRAGNO_INITIAL_DATA__?: [string, unknown][];
+  }
+}
+
+let clientInitialData: Map<string, unknown> | undefined;
+
+export function hydrateFromWindow() {
+  if (typeof window !== "undefined" && window.__FRAGNO_INITIAL_DATA__) {
+    clientInitialData = new Map(window.__FRAGNO_INITIAL_DATA__);
+    delete window.__FRAGNO_INITIAL_DATA__;
+    console.warn("hydrateFromWindow", {
+      clientInitialData: Array.from(clientInitialData.entries()),
+    });
+  }
+}
+
+export function getInitialData(key: string): unknown | undefined {
+  if (clientInitialData?.has(key)) {
+    const data = clientInitialData.get(key);
+    clientInitialData.delete(key);
+    return data;
+  }
+  return undefined;
+}
+
+function listenToStores(): void {
+  for (const store of getStores()) {
+    // By calling `listen`, we trigger the fetcher function of the store.
+    // This will start the data fetching process on the server.
+    // We don't need to do anything with the return value of `listen`, as we
+    // are only interested in starting the data fetching.
+    store.listen(() => {});
+  }
+}
+
+// Server side
+export async function getFinalStoreValues(): Promise<Map<string, unknown>> {
+  listenToStores();
+  await allTasks();
+
+  const stores = getStores();
+  const storesInitialValue = new Map<string, unknown>();
+
+  for (const store of stores) {
+    const value = store.get();
+    if (!value || !store.key || value.loading) {
+      continue;
+    }
+    storesInitialValue.set(store.key, value.data);
+  }
+
+  return storesInitialValue;
+}

package/src/util/types-util.ts

@@ -0,0 +1,16 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+export type InferOr<T, U> =
+  T extends NonNullable<StandardSchemaV1>
+    ? StandardSchemaV1.InferOutput<T>
+    : T extends undefined
+      ? U
+      : U;
+
+export type InferOrUnknown<T> = InferOr<T, unknown>;
+
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+export type EmptyObject = Record<never, never>;

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "@fragno-private/typescript-config/tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "composite": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsdown.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: [
+    "./src/mod.ts",
+    "./src/api/api.ts",
+    "./src/client/client.ts",
+    "./src/client/vanilla.ts",
+    "./src/client/client.svelte.ts",
+    "./src/client/react.ts",
+    "./src/client/vue.ts",
+    "./src/integrations/astro.ts",
+    "./src/integrations/next-js.ts",
+    "./src/integrations/react-ssr.ts",
+    "./src/integrations/svelte-kit.ts",
+  ],
+  dts: true,
+  // TODO: This should be true, but we need some additional type exports in chatno/src/index.ts
+  // to make it work.
+  unbundle: false,
+});

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+import { svelte } from "@sveltejs/vite-plugin-svelte";
+import { svelteTesting } from "@testing-library/svelte/vite";
+
+export default defineConfig({
+  plugins: [svelte(), svelteTesting()],
+  test: {
+    environment: "happy-dom",
+  },
+});