fromsrc 0.0.0 → 0.0.2

package/dist/openapi.js

@@ -0,0 +1,141 @@
+import { resolveSchema, resolveRef, resolveContent } from './openapiutil';
+export { generateEndpointSlug } from './openapiutil';
+import { parsespec, rootschema } from './openapiguard';
+
+const HTTP_METHODS = ["get", "post", "put", "patch", "delete", "head", "options", "trace"];
+function isrecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function asrecord(value) {
+  return isrecord(value) ? value : {};
+}
+function extractParameters(root, raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.flatMap((item) => {
+    const input = asrecord(item);
+    const ref = typeof input.$ref === "string" ? resolveRef(root, input.$ref) : input;
+    const resolved = asrecord(ref);
+    const name = typeof resolved.name === "string" ? resolved.name : "";
+    const location = resolved.in;
+    if (!["query", "path", "header", "cookie"].includes(String(location))) return [];
+    return [{
+      name,
+      in: location,
+      required: typeof resolved.required === "boolean" ? resolved.required : void 0,
+      description: typeof resolved.description === "string" ? resolved.description : void 0,
+      schema: resolved.schema ? resolveSchema(root, resolved.schema) : void 0
+    }];
+  });
+}
+function extractRequestBody(root, raw) {
+  if (!raw) return void 0;
+  const input = asrecord(raw);
+  const ref = typeof input.$ref === "string" ? resolveRef(root, input.$ref) : input;
+  const resolved = asrecord(ref);
+  return {
+    description: typeof resolved.description === "string" ? resolved.description : void 0,
+    required: typeof resolved.required === "boolean" ? resolved.required : void 0,
+    content: resolveContent(root, resolved.content) ?? {}
+  };
+}
+function extractResponses(root, raw) {
+  if (!isrecord(raw)) return [];
+  const list = Object.entries(raw).map(([status, val]) => {
+    const input = asrecord(val);
+    const ref = typeof input.$ref === "string" ? resolveRef(root, input.$ref) : input;
+    const resolved = asrecord(ref);
+    return {
+      status,
+      description: typeof resolved.description === "string" ? resolved.description : void 0,
+      content: resolveContent(root, resolved.content)
+    };
+  });
+  const rank = (status) => {
+    if (status === "default") return Number.MAX_SAFE_INTEGER;
+    const numeric = Number(status);
+    return Number.isFinite(numeric) ? numeric : Number.MAX_SAFE_INTEGER - 1;
+  };
+  return list.sort((left, right) => rank(left.status) - rank(right.status));
+}
+function extractSecurity(raw) {
+  if (!Array.isArray(raw) || raw.length === 0) return void 0;
+  const names = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    if (!isrecord(item)) continue;
+    for (const key of Object.keys(item)) {
+      names.add(key);
+    }
+  }
+  return Array.from(names);
+}
+function extractEndpoints(root) {
+  const doc = asrecord(root);
+  const paths = asrecord(doc.paths);
+  const endpoints = [];
+  for (const [path, methodset] of Object.entries(paths)) {
+    const methods = asrecord(methodset);
+    const shared = methods.parameters;
+    for (const method of HTTP_METHODS) {
+      const op = asrecord(methods[method]);
+      if (Object.keys(op).length === 0) continue;
+      const opParams = Array.isArray(op.parameters) ? op.parameters : [];
+      const sharedParams = Array.isArray(shared) ? shared : [];
+      const params = [...sharedParams, ...opParams];
+      const tags = Array.isArray(op.tags) ? op.tags.filter((item) => typeof item === "string") : [];
+      endpoints.push({
+        method: method.toUpperCase(),
+        path,
+        operationId: typeof op.operationId === "string" ? op.operationId : void 0,
+        summary: typeof op.summary === "string" ? op.summary : void 0,
+        description: typeof op.description === "string" ? op.description : void 0,
+        tags,
+        parameters: extractParameters(root, params),
+        requestBody: extractRequestBody(root, op.requestBody),
+        responses: extractResponses(root, op.responses),
+        deprecated: typeof op.deprecated === "boolean" ? op.deprecated : void 0,
+        security: extractSecurity(op.security)
+      });
+    }
+  }
+  return endpoints;
+}
+function extractSchemas(root) {
+  const parsed = rootschema.parse(root);
+  const raw = asrecord(parsed.components?.schemas ?? parsed.definitions);
+  const schemas = {};
+  for (const [name, val] of Object.entries(raw)) {
+    schemas[name] = resolveSchema(root, val);
+  }
+  return schemas;
+}
+function extractTags(root, endpoints) {
+  const parsed = rootschema.parse(root);
+  const explicit = parsed.tags;
+  const named = new Set(explicit.map((t) => t.name));
+  for (const ep of endpoints) {
+    for (const tag of ep.tags) {
+      if (!named.has(tag)) {
+        explicit.push({ name: tag });
+        named.add(tag);
+      }
+    }
+  }
+  return explicit;
+}
+function parseOpenApi(spec) {
+  const root = parsespec(spec);
+  const parsed = rootschema.parse(root);
+  const endpoints = extractEndpoints(root);
+  return {
+    info: {
+      title: parsed.info.title,
+      version: parsed.info.version,
+      description: parsed.info.description
+    },
+    endpoints,
+    tags: extractTags(root, endpoints),
+    schemas: extractSchemas(root)
+  };
+}
+
+export { parseOpenApi };

package/dist/openapiguard.d.ts

@@ -0,0 +1,22 @@
+import { OpenApiTag } from './openapiutil.js';
+
+interface rootvalue {
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    paths: Record<string, unknown>;
+    tags: OpenApiTag[];
+    components?: {
+        schemas?: Record<string, unknown>;
+    };
+    definitions?: Record<string, unknown>;
+}
+declare function parseroot(value: unknown): rootvalue;
+declare const rootschema: {
+    parse: typeof parseroot;
+};
+declare function parsespec(spec: string | object): unknown;
+
+export { parsespec, rootschema };

package/dist/openapiguard.js

@@ -0,0 +1,87 @@
+function isrecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function totext(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function torecord(value) {
+  return isrecord(value) ? value : void 0;
+}
+function parseinfo(value) {
+  const input = torecord(value) ?? {};
+  return {
+    title: totext(input.title) ?? "",
+    version: totext(input.version) ?? "",
+    description: totext(input.description)
+  };
+}
+function parsetags(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const input = torecord(item);
+    if (!input) return [];
+    const name = totext(input.name);
+    if (!name || name.length === 0) return [];
+    return [{ name, description: totext(input.description) }];
+  });
+}
+function parsepaths(value) {
+  return torecord(value) ?? {};
+}
+function parsecomponents(value) {
+  const input = torecord(value);
+  if (!input) return void 0;
+  const schemas = torecord(input.schemas);
+  if (!schemas) return void 0;
+  return { schemas };
+}
+function parsedefinitions(value) {
+  return torecord(value);
+}
+function parseroot(value) {
+  if (!isrecord(value)) {
+    throw new Error("invalid openapi specification");
+  }
+  return {
+    info: parseinfo(value.info),
+    paths: parsepaths(value.paths),
+    tags: parsetags(value.tags),
+    components: parsecomponents(value.components),
+    definitions: parsedefinitions(value.definitions)
+  };
+}
+const rootschema = {
+  parse: parseroot
+};
+function parseyaml(spec) {
+  const runtime = globalThis;
+  const parser = runtime.Bun?.YAML?.parse;
+  if (!parser) {
+    throw new Error("invalid openapi specification");
+  }
+  return parser(spec);
+}
+function parsespec(spec) {
+  if (typeof spec === "string") {
+    const text = spec.trim();
+    if (text.length === 0) {
+      throw new Error("invalid openapi specification");
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      try {
+        const parsed = parseyaml(text);
+        if (!isrecord(parsed)) {
+          throw new Error("invalid openapi specification");
+        }
+        return parsed;
+      } catch {
+        throw new Error("invalid openapi specification");
+      }
+    }
+  }
+  return spec;
+}
+
+export { parsespec, rootschema };

package/dist/openapiutil.d.ts

@@ -0,0 +1,72 @@
+type OpenApiMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS" | "TRACE";
+interface OpenApiSchema {
+    type?: string;
+    format?: string;
+    description?: string;
+    properties?: Record<string, OpenApiSchema>;
+    items?: OpenApiSchema;
+    required?: string[];
+    enum?: string[];
+    oneOf?: OpenApiSchema[];
+    anyOf?: OpenApiSchema[];
+    allOf?: OpenApiSchema[];
+    nullable?: boolean;
+    default?: unknown;
+    example?: unknown;
+}
+interface OpenApiParameter {
+    name: string;
+    in: "query" | "path" | "header" | "cookie";
+    required?: boolean;
+    description?: string;
+    schema?: OpenApiSchema;
+}
+interface OpenApiRequestBody {
+    description?: string;
+    required?: boolean;
+    content: Record<string, {
+        schema: OpenApiSchema;
+    }>;
+}
+interface OpenApiResponse {
+    status: string;
+    description?: string;
+    content?: Record<string, {
+        schema: OpenApiSchema;
+    }>;
+}
+interface OpenApiEndpoint {
+    method: OpenApiMethod;
+    path: string;
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags: string[];
+    parameters: OpenApiParameter[];
+    requestBody?: OpenApiRequestBody;
+    responses: OpenApiResponse[];
+    deprecated?: boolean;
+    security?: string[];
+}
+interface OpenApiTag {
+    name: string;
+    description?: string;
+}
+interface OpenApiSpec {
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    endpoints: OpenApiEndpoint[];
+    tags: OpenApiTag[];
+    schemas: Record<string, OpenApiSchema>;
+}
+declare function generateEndpointSlug(method: string, path: string): string;
+declare function resolveRef(root: unknown, ref: string): unknown;
+declare function resolveSchema(root: unknown, raw: unknown, depth?: number, refs?: Set<string>): OpenApiSchema;
+declare function resolveContent(root: unknown, raw: unknown): Record<string, {
+    schema: OpenApiSchema;
+}> | undefined;
+
+export { type OpenApiEndpoint, type OpenApiMethod, type OpenApiParameter, type OpenApiRequestBody, type OpenApiResponse, type OpenApiSchema, type OpenApiSpec, type OpenApiTag, generateEndpointSlug, resolveContent, resolveRef, resolveSchema };

package/dist/openapiutil.js

@@ -0,0 +1,61 @@
+function generateEndpointSlug(method, path) {
+  return `${method.toLowerCase()}-${path.replace(/^\//, "").replace(/[/{}}]/g, "-").replace(/-+/g, "-").replace(/-$/, "")}`;
+}
+const MAX_SCHEMA_DEPTH = 40;
+function isrecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function resolveRef(root, ref) {
+  if (!ref.startsWith("#/")) return {};
+  const parts = ref.slice(2).split("/");
+  let current = root;
+  for (const part of parts) {
+    if (!isrecord(current)) return {};
+    current = current[part];
+    if (current === void 0) return {};
+  }
+  return current;
+}
+function resolveSchema(root, raw, depth = 0, refs = /* @__PURE__ */ new Set()) {
+  if (depth > MAX_SCHEMA_DEPTH) return {};
+  if (!isrecord(raw)) return {};
+  if (typeof raw.$ref === "string") {
+    if (refs.has(raw.$ref)) return {};
+    const next = new Set(refs);
+    next.add(raw.$ref);
+    return resolveSchema(root, resolveRef(root, raw.$ref), depth + 1, next);
+  }
+  const schema = {};
+  if (typeof raw.type === "string") schema.type = raw.type;
+  if (typeof raw.format === "string") schema.format = raw.format;
+  if (typeof raw.description === "string") schema.description = raw.description;
+  if (typeof raw.nullable === "boolean") schema.nullable = raw.nullable;
+  if (raw.default !== void 0) schema.default = raw.default;
+  if (raw.example !== void 0) schema.example = raw.example;
+  if (Array.isArray(raw.enum)) schema.enum = raw.enum.filter((item) => typeof item === "string");
+  if (Array.isArray(raw.required)) {
+    schema.required = raw.required.filter((item) => typeof item === "string");
+  }
+  if (isrecord(raw.properties)) {
+    schema.properties = {};
+    for (const [key, val] of Object.entries(raw.properties)) {
+      schema.properties[key] = resolveSchema(root, val, depth + 1, refs);
+    }
+  }
+  if (raw.items) schema.items = resolveSchema(root, raw.items, depth + 1, refs);
+  if (Array.isArray(raw.oneOf)) schema.oneOf = raw.oneOf.map((schemaitem) => resolveSchema(root, schemaitem, depth + 1, refs));
+  if (Array.isArray(raw.anyOf)) schema.anyOf = raw.anyOf.map((schemaitem) => resolveSchema(root, schemaitem, depth + 1, refs));
+  if (Array.isArray(raw.allOf)) schema.allOf = raw.allOf.map((schemaitem) => resolveSchema(root, schemaitem, depth + 1, refs));
+  return schema;
+}
+function resolveContent(root, raw) {
+  if (!isrecord(raw)) return void 0;
+  const result = {};
+  for (const [mediaType, val] of Object.entries(raw)) {
+    const value = isrecord(val) ? val.schema : void 0;
+    result[mediaType] = { schema: resolveSchema(root, value) };
+  }
+  return result;
+}
+
+export { generateEndpointSlug, resolveContent, resolveRef, resolveSchema };

package/dist/orama.d.ts

@@ -0,0 +1,16 @@
+import { SearchAdapter } from './search.js';
+import './content.js';
+import 'zod';
+import './schema.js';
+import './searchscore.js';
+
+interface OramaConfig {
+    endpoint: string;
+    readonly key?: string;
+    index?: string;
+    headers?: Record<string, string>;
+}
+declare function createOramaAdapter(config: OramaConfig): SearchAdapter;
+declare const createoramaadapter: typeof createOramaAdapter;
+
+export { type OramaConfig, createOramaAdapter, createoramaadapter };

package/dist/orama.js

@@ -0,0 +1,100 @@
+const MAX_DEPTH = 10;
+function isrecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function getstring(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function getnumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function parsehit(value, depth = 0) {
+  if (!isrecord(value)) return null;
+  if (depth > MAX_DEPTH) return null;
+  const nested = isrecord(value.document) ? parsehit(value.document, depth + 1) : null;
+  const document = nested ?? void 0;
+  return {
+    slug: getstring(value.slug),
+    path: getstring(value.path),
+    title: getstring(value.title),
+    description: getstring(value.description),
+    content: getstring(value.content),
+    anchor: getstring(value.anchor),
+    heading: getstring(value.heading),
+    snippet: getstring(value.snippet),
+    score: getnumber(value.score),
+    document
+  };
+}
+function parsehits(value) {
+  if (Array.isArray(value)) return value.map(parsehit).filter((item) => item !== null);
+  if (!isrecord(value)) return [];
+  const hits = Array.isArray(value.hits) ? value.hits : Array.isArray(value.results) ? value.results : [];
+  return hits.map(parsehit).filter((item) => item !== null);
+}
+function normalize(doc) {
+  return {
+    slug: doc.slug,
+    title: doc.title,
+    description: doc.description,
+    content: doc.content ?? "",
+    headings: doc.headings
+  };
+}
+function fallback(docs, limit) {
+  return docs.slice(0, limit).map((doc) => ({ doc, score: 0 }));
+}
+function maphit(entry, index, total) {
+  const source = entry.document ?? entry;
+  const slug = source.slug ?? source.path;
+  const title = source.title ?? source.heading ?? slug;
+  if (!slug || !title) return null;
+  return {
+    doc: normalize({
+      slug,
+      title,
+      description: source.description,
+      content: source.content ?? ""
+    }),
+    score: source.score ?? Math.max(1, total - index),
+    snippet: source.snippet ?? source.description ?? source.content,
+    anchor: source.anchor,
+    heading: source.heading
+  };
+}
+function createOramaAdapter(config) {
+  return {
+    async search(query, docs, limit = 8) {
+      const value = query.trim();
+      if (!value) return fallback(docs, limit);
+      const response = await fetch(config.endpoint, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...config.key ? { authorization: `Bearer ${config.key}` } : {},
+          ...config.headers ?? {}
+        },
+        body: JSON.stringify({
+          query: value,
+          term: value,
+          limit,
+          index: config.index
+        })
+      });
+      if (!response.ok) return [];
+      const json = await response.json();
+      const hits = parsehits(json);
+      const result = [];
+      for (let i = 0; i < hits.length; i++) {
+        const hit = hits[i];
+        if (!hit) continue;
+        const item = maphit(hit, i, hits.length);
+        if (item) result.push(item);
+      }
+      return result;
+    }
+  };
+}
+const createoramaadapter = createOramaAdapter;
+
+export { createOramaAdapter, createoramaadapter };

package/dist/pipeline.d.ts

@@ -0,0 +1,19 @@
+type PipelineContext = {
+    path: string;
+    content: string;
+    frontmatter: Record<string, unknown>;
+    meta: Record<string, unknown>;
+};
+type Transform = (ctx: PipelineContext) => PipelineContext | Promise<PipelineContext>;
+type Pipeline = {
+    use(transform: Transform): Pipeline;
+    process(ctx: PipelineContext): Promise<PipelineContext>;
+    transforms(): Transform[];
+};
+declare function createPipeline(...initial: Transform[]): Pipeline;
+declare function composeTransforms(...transforms: Transform[]): Transform;
+declare function conditionalTransform(predicate: (ctx: PipelineContext) => boolean, transform: Transform): Transform;
+declare function mapContent(fn: (content: string) => string): Transform;
+declare function mapFrontmatter(fn: (fm: Record<string, unknown>) => Record<string, unknown>): Transform;
+
+export { type Pipeline, type PipelineContext, type Transform, composeTransforms, conditionalTransform, createPipeline, mapContent, mapFrontmatter };

package/dist/pipeline.js

@@ -0,0 +1,40 @@
+function createPipeline(...initial) {
+  const list = [...initial];
+  const pipeline = {
+    use(transform) {
+      list.push(transform);
+      return pipeline;
+    },
+    async process(ctx) {
+      let result = ctx;
+      for (const t of list) {
+        result = await t(result);
+      }
+      return result;
+    },
+    transforms() {
+      return [...list];
+    }
+  };
+  return pipeline;
+}
+function composeTransforms(...transforms) {
+  return async (ctx) => {
+    let result = ctx;
+    for (const t of transforms) {
+      result = await t(result);
+    }
+    return result;
+  };
+}
+function conditionalTransform(predicate, transform) {
+  return (ctx) => predicate(ctx) ? transform(ctx) : ctx;
+}
+function mapContent(fn) {
+  return (ctx) => ({ ...ctx, content: fn(ctx.content) });
+}
+function mapFrontmatter(fn) {
+  return (ctx) => ({ ...ctx, frontmatter: fn(ctx.frontmatter) });
+}
+
+export { composeTransforms, conditionalTransform, createPipeline, mapContent, mapFrontmatter };

package/dist/preload.d.ts

@@ -0,0 +1,15 @@
+declare function preloadPage(slug: string): {
+    rel: "prefetch";
+    href: string;
+};
+declare function preloadSearch(): {
+    rel: "prefetch";
+    href: string;
+};
+declare const preloadConfig: {
+    hoverDelay: number;
+    intersectionThreshold: number;
+    maxPreloads: number;
+};
+
+export { preloadConfig, preloadPage, preloadSearch };

package/dist/preload.js

@@ -0,0 +1,19 @@
+function preloadPage(slug) {
+  return {
+    rel: "prefetch",
+    href: `/docs/${slug}`
+  };
+}
+function preloadSearch() {
+  return {
+    rel: "prefetch",
+    href: "/api/search"
+  };
+}
+const preloadConfig = {
+  hoverDelay: 65,
+  intersectionThreshold: 0.1,
+  maxPreloads: 5
+};
+
+export { preloadConfig, preloadPage, preloadSearch };

package/dist/ranking.d.ts

@@ -0,0 +1,28 @@
+type RankableItem = {
+    title: string;
+    description?: string;
+    content?: string;
+    tags?: string[];
+    path: string;
+    weight?: number;
+};
+type RankResult = {
+    item: RankableItem;
+    score: number;
+    matches: {
+        field: string;
+        positions: number[];
+    }[];
+};
+type RankOptions = {
+    titleWeight?: number;
+    descriptionWeight?: number;
+    contentWeight?: number;
+    tagWeight?: number;
+    fuzzy?: boolean;
+};
+declare function rank(items: RankableItem[], query: string, options?: RankOptions): RankResult[];
+declare function bm25(items: RankableItem[], query: string): RankResult[];
+declare function boostRecent(results: RankResult[], dateFn: (item: RankableItem) => Date, maxBoost?: number): RankResult[];
+
+export { type RankOptions, type RankResult, type RankableItem, bm25, boostRecent, rank };