fromsrc 0.0.2 → 0.0.21

package/dist/ogimage.js

@@ -11,38 +11,38 @@ function generateOgMeta(base, config) {
   const width = config.width ?? 1200;
   const height = config.height ?? 630;
   const url = ogImageUrl(base, {
-    title: config.title,
+    accentColor: config.accentColor,
     description: config.description,
-    siteName: config.siteName,
+    height: String(height),
     logo: config.logo,
+    siteName: config.siteName,
     theme: config.theme,
-    accentColor: config.accentColor,
-    width: String(width),
-    height: String(height)
+    title: config.title,
+    width: String(width)
   });
   return {
-    url,
-    width,
-    height,
     alt: config.description ?? config.title,
-    type: "image/png"
+    height,
+    type: "image/png",
+    url,
+    width
   };
 }
 function defaultTemplate(config) {
   const dark = config.theme === "dark";
   return {
-    title: config.title,
-    description: config.description ?? "",
-    siteName: config.siteName ?? "",
-    logo: config.logo ?? "",
-    width: config.width ?? 1200,
-    height: config.height ?? 630,
     colors: {
+      accent: config.accentColor ?? (dark ? "#3b82f6" : "#2563eb"),
       background: dark ? "#0a0a0a" : "#ffffff",
       foreground: dark ? "#fafafa" : "#0a0a0a",
-      muted: dark ? "#a1a1aa" : "#71717a",
-      accent: config.accentColor ?? (dark ? "#3b82f6" : "#2563eb")
-    }
+      muted: dark ? "#a1a1aa" : "#71717a"
+    },
+    description: config.description ?? "",
+    height: config.height ?? 630,
+    logo: config.logo ?? "",
+    siteName: config.siteName ?? "",
+    title: config.title,
+    width: config.width ?? 1200
   };
 }
 function socialMeta(config) {
@@ -50,12 +50,12 @@ function socialMeta(config) {
   const height = config.height ?? 630;
   const alt = config.description ?? config.title;
   return [
-    { property: "og:image", content: config.url },
-    { property: "og:image:width", content: String(width) },
-    { property: "og:image:height", content: String(height) },
-    { property: "og:image:alt", content: alt },
-    { name: "twitter:card", content: "summary_large_image" },
-    { name: "twitter:image", content: config.url }
+    { content: config.url, property: "og:image" },
+    { content: String(width), property: "og:image:width" },
+    { content: String(height), property: "og:image:height" },
+    { content: alt, property: "og:image:alt" },
+    { content: "summary_large_image", name: "twitter:card" },
+    { content: config.url, name: "twitter:image" }
   ];
 }
 

package/dist/openapi.js

@@ -1,8 +1,17 @@
+import { parsespec, rootschema } from './openapiguard';
 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"];
+const HTTP_METHODS = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "head",
+  "options",
+  "trace"
+];
 function isrecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -10,63 +19,79 @@ function asrecord(value) {
   return isrecord(value) ? value : {};
 }
 function extractParameters(root, raw) {
-  if (!Array.isArray(raw)) return [];
+  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
-    }];
+    if (!["query", "path", "header", "cookie"].includes(String(location))) {
+      return [];
+    }
+    return [
+      {
+        description: typeof resolved.description === "string" ? resolved.description : void 0,
+        in: location,
+        name,
+        required: typeof resolved.required === "boolean" ? resolved.required : void 0,
+        schema: resolved.schema ? resolveSchema(root, resolved.schema) : void 0
+      }
+    ];
   });
 }
 function extractRequestBody(root, raw) {
-  if (!raw) return void 0;
+  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 {
+    content: resolveContent(root, resolved.content) ?? {},
     description: typeof resolved.description === "string" ? resolved.description : void 0,
-    required: typeof resolved.required === "boolean" ? resolved.required : void 0,
-    content: resolveContent(root, resolved.content) ?? {}
+    required: typeof resolved.required === "boolean" ? resolved.required : void 0
   };
 }
 function extractResponses(root, raw) {
-  if (!isrecord(raw)) return [];
+  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,
+      content: resolveContent(root, resolved.content),
       description: typeof resolved.description === "string" ? resolved.description : void 0,
-      content: resolveContent(root, resolved.content)
+      status
     };
   });
   const rank = (status) => {
-    if (status === "default") return Number.MAX_SAFE_INTEGER;
+    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;
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return void 0;
+  }
   const names = /* @__PURE__ */ new Set();
   for (const item of raw) {
-    if (!isrecord(item)) continue;
+    if (!isrecord(item)) {
+      continue;
+    }
     for (const key of Object.keys(item)) {
       names.add(key);
     }
   }
-  return Array.from(names);
+  return [...names];
 }
 function extractEndpoints(root) {
   const doc = asrecord(root);
@@ -77,23 +102,25 @@ function extractEndpoints(root) {
     const shared = methods.parameters;
     for (const method of HTTP_METHODS) {
       const op = asrecord(methods[method]);
-      if (Object.keys(op).length === 0) continue;
+      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({
+        deprecated: typeof op.deprecated === "boolean" ? op.deprecated : void 0,
+        description: typeof op.description === "string" ? op.description : void 0,
         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),
+        path,
         requestBody: extractRequestBody(root, op.requestBody),
         responses: extractResponses(root, op.responses),
-        deprecated: typeof op.deprecated === "boolean" ? op.deprecated : void 0,
-        security: extractSecurity(op.security)
+        security: extractSecurity(op.security),
+        summary: typeof op.summary === "string" ? op.summary : void 0,
+        tags
       });
     }
   }
@@ -127,14 +154,14 @@ function parseOpenApi(spec) {
   const parsed = rootschema.parse(root);
   const endpoints = extractEndpoints(root);
   return {
+    endpoints,
     info: {
+      description: parsed.info.description,
       title: parsed.info.title,
-      version: parsed.info.version,
-      description: parsed.info.description
+      version: parsed.info.version
     },
-    endpoints,
-    tags: extractTags(root, endpoints),
-    schemas: extractSchemas(root)
+    schemas: extractSchemas(root),
+    tags: extractTags(root, endpoints)
   };
 }
 

package/dist/openapiguard.js

@@ -10,19 +10,25 @@ function torecord(value) {
 function parseinfo(value) {
   const input = torecord(value) ?? {};
   return {
+    description: totext(input.description),
     title: totext(input.title) ?? "",
-    version: totext(input.version) ?? "",
-    description: totext(input.description)
+    version: totext(input.version) ?? ""
   };
 }
 function parsetags(value) {
-  if (!Array.isArray(value)) return [];
+  if (!Array.isArray(value)) {
+    return [];
+  }
   return value.flatMap((item) => {
     const input = torecord(item);
-    if (!input) return [];
+    if (!input) {
+      return [];
+    }
     const name = totext(input.name);
-    if (!name || name.length === 0) return [];
-    return [{ name, description: totext(input.description) }];
+    if (!name || name.length === 0) {
+      return [];
+    }
+    return [{ description: totext(input.description), name }];
   });
 }
 function parsepaths(value) {
@@ -30,9 +36,13 @@ function parsepaths(value) {
 }
 function parsecomponents(value) {
   const input = torecord(value);
-  if (!input) return void 0;
+  if (!input) {
+    return void 0;
+  }
   const schemas = torecord(input.schemas);
-  if (!schemas) return void 0;
+  if (!schemas) {
+    return void 0;
+  }
   return { schemas };
 }
 function parsedefinitions(value) {
@@ -43,11 +53,11 @@ function parseroot(value) {
     throw new Error("invalid openapi specification");
   }
   return {
+    components: parsecomponents(value.components),
+    definitions: parsedefinitions(value.definitions),
     info: parseinfo(value.info),
     paths: parsepaths(value.paths),
-    tags: parsetags(value.tags),
-    components: parsecomponents(value.components),
-    definitions: parsedefinitions(value.definitions)
+    tags: parsetags(value.tags)
   };
 }
 const rootschema = {

package/dist/openapiutil.js

@@ -1,40 +1,70 @@
 function generateEndpointSlug(method, path) {
-  return `${method.toLowerCase()}-${path.replace(/^\//, "").replace(/[/{}}]/g, "-").replace(/-+/g, "-").replace(/-$/, "")}`;
+  return `${method.toLowerCase()}-${path.replace(/^\//, "").replaceAll(/[/{}}]/g, "-").replaceAll(/-+/g, "-").replace(/-$/, "")}`;
 }
 const MAX_SCHEMA_DEPTH = 40;
 function isrecord(value) {
   return typeof value === "object" && value !== null;
 }
 function resolveRef(root, ref) {
-  if (!ref.startsWith("#/")) return {};
+  if (!ref.startsWith("#/")) {
+    return {};
+  }
   const parts = ref.slice(2).split("/");
   let current = root;
   for (const part of parts) {
-    if (!isrecord(current)) return {};
+    if (!isrecord(current)) {
+      return {};
+    }
     current = current[part];
-    if (current === void 0) return {};
+    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 (depth > MAX_SCHEMA_DEPTH) {
+    return {};
+  }
+  if (!isrecord(raw)) {
+    return {};
+  }
   if (typeof raw.$ref === "string") {
-    if (refs.has(raw.$ref)) return {};
+    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 (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");
+    schema.required = raw.required.filter(
+      (item) => typeof item === "string"
+    );
   }
   if (isrecord(raw.properties)) {
     schema.properties = {};
@@ -42,14 +72,30 @@ function resolveSchema(root, raw, depth = 0, refs = /* @__PURE__ */ new Set()) {
       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));
+  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;
+  if (!isrecord(raw)) {
+    return void 0;
+  }
   const result = {};
   for (const [mediaType, val] of Object.entries(raw)) {
     const value = isrecord(val) ? val.schema : void 0;

package/dist/orama.js

@@ -9,36 +9,44 @@ 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;
+  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),
+    content: getstring(value.content),
+    description: getstring(value.description),
+    document,
     heading: getstring(value.heading),
-    snippet: getstring(value.snippet),
+    path: getstring(value.path),
     score: getnumber(value.score),
-    document
+    slug: getstring(value.slug),
+    snippet: getstring(value.snippet),
+    title: getstring(value.title)
   };
 }
 function parsehits(value) {
-  if (Array.isArray(value)) return value.map(parsehit).filter((item) => item !== null);
-  if (!isrecord(value)) return [];
+  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
+    description: doc.description,
+    headings: doc.headings,
+    slug: doc.slug,
+    title: doc.title
   };
 }
 function fallback(docs, limit) {
@@ -48,48 +56,58 @@ 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;
+  if (!slug || !title) {
+    return null;
+  }
   return {
+    anchor: source.anchor,
     doc: normalize({
-      slug,
-      title,
+      content: source.content ?? "",
       description: source.description,
-      content: source.content ?? ""
+      slug,
+      title
     }),
+    heading: source.heading,
     score: source.score ?? Math.max(1, total - index),
-    snippet: source.snippet ?? source.description ?? source.content,
-    anchor: source.anchor,
-    heading: source.heading
+    snippet: source.snippet ?? source.description ?? source.content
   };
 }
 function createOramaAdapter(config) {
   return {
     async search(query, docs, limit = 8) {
       const value = query.trim();
-      if (!value) return fallback(docs, limit);
+      if (!value) {
+        return fallback(docs, limit);
+      }
       const response = await fetch(config.endpoint, {
-        method: "POST",
+        body: JSON.stringify({
+          index: config.index,
+          limit,
+          query: value,
+          term: value
+        }),
         headers: {
           "content-type": "application/json",
           ...config.key ? { authorization: `Bearer ${config.key}` } : {},
-          ...config.headers ?? {}
+          ...config.headers
         },
-        body: JSON.stringify({
-          query: value,
-          term: value,
-          limit,
-          index: config.index
-        })
+        method: "POST"
       });
-      if (!response.ok) return [];
+      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;
+        if (!hit) {
+          continue;
+        }
         const item = maphit(hit, i, hits.length);
-        if (item) result.push(item);
+        if (item) {
+          result.push(item);
+        }
       }
       return result;
     }

package/dist/pipeline.d.ts

@@ -1,15 +1,15 @@
-type PipelineContext = {
+interface PipelineContext {
     path: string;
     content: string;
     frontmatter: Record<string, unknown>;
     meta: Record<string, unknown>;
-};
+}
 type Transform = (ctx: PipelineContext) => PipelineContext | Promise<PipelineContext>;
-type Pipeline = {
+interface 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;

package/dist/pipeline.js

@@ -1,10 +1,6 @@
 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) {
@@ -14,6 +10,10 @@ function createPipeline(...initial) {
     },
     transforms() {
       return [...list];
+    },
+    use(transform) {
+      list.push(transform);
+      return pipeline;
     }
   };
   return pipeline;

package/dist/preload.d.ts

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

package/dist/preload.js

@@ -1,13 +1,13 @@
 function preloadPage(slug) {
   return {
-    rel: "prefetch",
-    href: `/docs/${slug}`
+    href: `/docs/${slug}`,
+    rel: "prefetch"
   };
 }
 function preloadSearch() {
   return {
-    rel: "prefetch",
-    href: "/api/search"
+    href: "/api/search",
+    rel: "prefetch"
   };
 }
 const preloadConfig = {

package/dist/ranking.d.ts

@@ -1,26 +1,26 @@
-type RankableItem = {
+interface RankableItem {
     title: string;
     description?: string;
     content?: string;
     tags?: string[];
     path: string;
     weight?: number;
-};
-type RankResult = {
+}
+interface RankResult {
     item: RankableItem;
     score: number;
     matches: {
         field: string;
         positions: number[];
     }[];
-};
-type RankOptions = {
+}
+interface 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[];