fromsrc 0.0.0 → 0.0.1

package/dist/access.d.ts

@@ -0,0 +1,23 @@
+type AccessRule = {
+    pattern: string;
+    roles: string[];
+    redirect?: string;
+};
+type AccessConfig = {
+    rules: AccessRule[];
+    defaultAccess?: "public" | "private";
+};
+type AccessResult = {
+    allowed: boolean;
+    redirect?: string;
+    requiredRoles?: string[];
+};
+declare function matchPattern(pattern: string, path: string): boolean;
+declare function mergeRoles(rules: AccessRule[], path: string): string[];
+declare function createAccess(config: AccessConfig): {
+    check: (path: string, userRoles: string[]) => AccessResult;
+    addRule: (rule: AccessRule) => void;
+    getRules: () => AccessRule[];
+};
+
+export { type AccessConfig, type AccessResult, type AccessRule, createAccess, matchPattern, mergeRoles };

package/dist/access.js

@@ -0,0 +1,54 @@
+function matchPattern(pattern, path) {
+  const parts = pattern.split("/").filter(Boolean);
+  const segments = path.split("/").filter(Boolean);
+  let pi = 0;
+  let si = 0;
+  while (pi < parts.length && si < segments.length) {
+    if (parts[pi] === "**") {
+      if (pi === parts.length - 1) return true;
+      pi++;
+      while (si < segments.length) {
+        if (matchPattern(parts.slice(pi).join("/"), segments.slice(si).join("/")))
+          return true;
+        si++;
+      }
+      return false;
+    }
+    if (parts[pi] !== "*" && parts[pi] !== segments[si]) return false;
+    pi++;
+    si++;
+  }
+  return pi === parts.length && si === segments.length;
+}
+function mergeRoles(rules, path) {
+  const roles = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (matchPattern(rule.pattern, path)) {
+      for (const role of rule.roles) roles.add(role);
+    }
+  }
+  return [...roles];
+}
+function createAccess(config) {
+  const rules = [...config.rules];
+  const defaultAccess = config.defaultAccess ?? "public";
+  function check(path, userRoles) {
+    const matching = rules.filter((r) => matchPattern(r.pattern, path));
+    if (matching.length === 0) {
+      return { allowed: defaultAccess === "public" };
+    }
+    const required = mergeRoles(matching, path);
+    const allowed = required.some((r) => userRoles.includes(r));
+    const redirect = matching.find((r) => r.redirect && !allowed)?.redirect;
+    return { allowed, redirect, requiredRoles: required };
+  }
+  function addRule(rule) {
+    rules.push(rule);
+  }
+  function getRules() {
+    return rules;
+  }
+  return { check, addRule, getRules };
+}
+
+export { createAccess, matchPattern, mergeRoles };

package/dist/adapter.d.ts

@@ -0,0 +1,31 @@
+import * as react from 'react';
+import { ComponentType, ComponentPropsWithoutRef, ReactNode } from 'react';
+
+type fromsrclinkprops = Omit<ComponentPropsWithoutRef<"a">, "href"> & {
+    href: string;
+    prefetch?: boolean;
+};
+type fromsrcimageprops = Omit<ComponentPropsWithoutRef<"img">, "src" | "alt"> & {
+    src: string;
+    alt: string;
+};
+interface FrameworkAdapter {
+    Link: ComponentType<fromsrclinkprops>;
+    Image?: ComponentType<fromsrcimageprops>;
+    usePathname: () => string;
+    useRouter: () => {
+        push: (url: string) => void;
+        back: () => void;
+    };
+    compileMdx?: (source: string, options?: unknown) => Promise<unknown>;
+}
+declare const defaultAdapter: FrameworkAdapter;
+declare function createadapter(adapter: Partial<FrameworkAdapter>): FrameworkAdapter;
+declare const AdapterContext: react.Context<FrameworkAdapter>;
+declare function AdapterProvider({ adapter, children, }: {
+    adapter: FrameworkAdapter;
+    children: ReactNode;
+}): react.FunctionComponentElement<react.ProviderProps<FrameworkAdapter>>;
+declare function useAdapter(): FrameworkAdapter;
+
+export { AdapterContext, AdapterProvider, type FrameworkAdapter, createadapter, defaultAdapter, type fromsrcimageprops, type fromsrclinkprops, useAdapter };

package/dist/adapter.js

@@ -0,0 +1,59 @@
+"use client";
+import { createContext, createElement, useContext } from 'react';
+import { usepath } from './browser';
+
+function defaultLink({
+  href,
+  children,
+  ...rest
+}) {
+  return createElement("a", { href, ...rest }, children);
+}
+function defaultImage({
+  src,
+  alt,
+  ...rest
+}) {
+  return createElement("img", { src, alt, ...rest });
+}
+function defaultUsePathname() {
+  return usepath();
+}
+function defaultUseRouter() {
+  return {
+    push: (url) => {
+      if (typeof window !== "undefined") {
+        window.location.href = url;
+      }
+    },
+    back: () => {
+      if (typeof window !== "undefined") {
+        window.history.back();
+      }
+    }
+  };
+}
+const defaultAdapter = {
+  Link: defaultLink,
+  Image: defaultImage,
+  usePathname: defaultUsePathname,
+  useRouter: defaultUseRouter
+};
+function createadapter(adapter) {
+  return {
+    ...defaultAdapter,
+    ...adapter
+  };
+}
+const AdapterContext = createContext(defaultAdapter);
+function AdapterProvider({
+  adapter,
+  children
+}) {
+  return createElement(AdapterContext.Provider, { value: adapter }, children);
+}
+function useAdapter() {
+  return useContext(AdapterContext);
+}
+
+export { AdapterContext, AdapterProvider, createadapter, defaultAdapter, useAdapter };

package/dist/adapterastro.d.ts

@@ -0,0 +1,6 @@
+import { FrameworkAdapter } from './adapter.js';
+import 'react';
+
+declare const astroAdapter: FrameworkAdapter;
+
+export { astroAdapter };

package/dist/adapterastro.js

@@ -0,0 +1,6 @@
+"use client";
+import { createbrowseradapter } from './adapterbrowser';
+
+const astroAdapter = createbrowseradapter();
+
+export { astroAdapter };

package/dist/adapterbrowser.d.ts

@@ -0,0 +1,6 @@
+import { FrameworkAdapter } from './adapter.js';
+import 'react';
+
+declare function createbrowseradapter(): FrameworkAdapter;
+
+export { createbrowseradapter };

package/dist/adapterbrowser.js

@@ -0,0 +1,38 @@
+"use client";
+import { createElement } from 'react';
+import { back, push, usepath } from './browser';
+
+function link({
+  href,
+  children,
+  prefetch: _prefetch,
+  ...rest
+}) {
+  return createElement("a", { href, ...rest }, children);
+}
+function image({
+  src,
+  alt,
+  ...rest
+}) {
+  return createElement("img", { src, alt, ...rest });
+}
+function pathname() {
+  return usepath();
+}
+function router() {
+  return {
+    push,
+    back
+  };
+}
+function createbrowseradapter() {
+  return {
+    Link: link,
+    Image: image,
+    usePathname: pathname,
+    useRouter: router
+  };
+}
+
+export { createbrowseradapter };

package/dist/adapternext.d.ts

@@ -0,0 +1,6 @@
+import { FrameworkAdapter } from './adapter.js';
+import 'react';
+
+declare const nextAdapter: FrameworkAdapter;
+
+export { nextAdapter };

package/dist/adapternext.js

@@ -0,0 +1,49 @@
+"use client";
+import NextImage from 'next/image';
+import NextLink from 'next/link';
+import { usePathname, useRouter } from 'next/navigation';
+import { createElement } from 'react';
+
+function Link({
+  href,
+  children,
+  prefetch,
+  ...rest
+}) {
+  return createElement(NextLink, { href, prefetch, ...rest }, children);
+}
+function Image({
+  src,
+  alt,
+  width,
+  height,
+  ...rest
+}) {
+  const nextWidth = Number(width) > 0 ? Number(width) : 1200;
+  const nextHeight = Number(height) > 0 ? Number(height) : 630;
+  return createElement(NextImage, {
+    src,
+    alt,
+    width: nextWidth,
+    height: nextHeight,
+    ...rest
+  });
+}
+function useNextPathname() {
+  return usePathname();
+}
+function useNextRouter() {
+  const router = useRouter();
+  return {
+    push: (url) => router.push(url),
+    back: () => router.back()
+  };
+}
+const nextAdapter = {
+  Link,
+  Image,
+  usePathname: useNextPathname,
+  useRouter: useNextRouter
+};
+
+export { nextAdapter };

package/dist/adapterreactrouter.d.ts

@@ -0,0 +1,6 @@
+import { FrameworkAdapter } from './adapter.js';
+import 'react';
+
+declare const reactRouterAdapter: FrameworkAdapter;
+
+export { reactRouterAdapter };

package/dist/adapterreactrouter.js

@@ -0,0 +1,37 @@
+"use client";
+import { createElement } from 'react';
+import { Link as Link$1, useLocation, useNavigate } from 'react-router';
+
+function Link({
+  href,
+  children,
+  prefetch: _prefetch,
+  ...rest
+}) {
+  return createElement(Link$1, { to: href, ...rest }, children);
+}
+function Image({
+  src,
+  alt,
+  ...rest
+}) {
+  return createElement("img", { src, alt, ...rest });
+}
+function useRouterPathname() {
+  return useLocation().pathname;
+}
+function useRouterNavigation() {
+  const navigate = useNavigate();
+  return {
+    push: (url) => navigate(url),
+    back: () => navigate(-1)
+  };
+}
+const reactRouterAdapter = {
+  Link,
+  Image,
+  usePathname: useRouterPathname,
+  useRouter: useRouterNavigation
+};
+
+export { reactRouterAdapter };

package/dist/adapterremix.d.ts

@@ -0,0 +1,6 @@
+import { FrameworkAdapter } from './adapter.js';
+import 'react';
+
+declare const remixAdapter: FrameworkAdapter;
+
+export { remixAdapter };

package/dist/adapterremix.js

@@ -0,0 +1,41 @@
+"use client";
+import { createElement } from 'react';
+import { Link as Link$1, useLocation, useNavigate } from '@remix-run/react';
+
+function Link({
+  href,
+  children,
+  prefetch,
+  ...rest
+}) {
+  return createElement(
+    Link$1,
+    { to: href, prefetch: prefetch ? "intent" : "none", ...rest },
+    children
+  );
+}
+function Image({
+  src,
+  alt,
+  ...rest
+}) {
+  return createElement("img", { src, alt, ...rest });
+}
+function useRemixPathname() {
+  return useLocation().pathname;
+}
+function useRemixRouter() {
+  const navigate = useNavigate();
+  return {
+    push: (url) => navigate(url),
+    back: () => navigate(-1)
+  };
+}
+const remixAdapter = {
+  Link,
+  Image,
+  usePathname: useRemixPathname,
+  useRouter: useRemixRouter
+};
+
+export { remixAdapter };

package/dist/adaptertanstack.d.ts

@@ -0,0 +1,6 @@
+import { FrameworkAdapter } from './adapter.js';
+import 'react';
+
+declare const tanstackAdapter: FrameworkAdapter;
+
+export { tanstackAdapter };

package/dist/adaptertanstack.js

@@ -0,0 +1,38 @@
+"use client";
+import { createElement } from 'react';
+import { Link as Link$1, useRouterState, useNavigate, useRouter } from '@tanstack/react-router';
+
+function Link({
+  href,
+  children,
+  prefetch: _prefetch,
+  ...rest
+}) {
+  return createElement(Link$1, { to: href, ...rest }, children);
+}
+function Image({
+  src,
+  alt,
+  ...rest
+}) {
+  return createElement("img", { src, alt, ...rest });
+}
+function useTanstackPathname() {
+  return useRouterState({ select: (state) => state.location.pathname });
+}
+function useTanstackRouter() {
+  const navigate = useNavigate();
+  const router = useRouter();
+  return {
+    push: (url) => navigate({ to: url }),
+    back: () => router.history.back()
+  };
+}
+const tanstackAdapter = {
+  Link,
+  Image,
+  usePathname: useTanstackPathname,
+  useRouter: useTanstackRouter
+};
+
+export { tanstackAdapter };

package/dist/adaptervite.d.ts

@@ -0,0 +1,6 @@
+import { FrameworkAdapter } from './adapter.js';
+import 'react';
+
+declare const viteAdapter: FrameworkAdapter;
+
+export { viteAdapter };

package/dist/adaptervite.js

@@ -0,0 +1,6 @@
+"use client";
+import { createbrowseradapter } from './adapterbrowser';
+
+const viteAdapter = createbrowseradapter();
+
+export { viteAdapter };

package/dist/algolia.d.ts

@@ -0,0 +1,16 @@
+import { SearchAdapter } from './search.js';
+import './content.js';
+import 'zod';
+import './schema.js';
+import './searchscore.js';
+
+interface AlgoliaConfig {
+    appid: string;
+    readonly key: string;
+    index: string;
+    attributes?: string[];
+}
+declare function createAlgoliaAdapter(config: AlgoliaConfig): SearchAdapter;
+declare const createalgoliaadapter: typeof createAlgoliaAdapter;
+
+export { type AlgoliaConfig, createAlgoliaAdapter, createalgoliaadapter };

package/dist/algolia.js

@@ -0,0 +1,83 @@
+function isrecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function getstring(value) {
+  return typeof value === "string" ? value : void 0;
+}
+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 parsehits(value) {
+  if (!isrecord(value)) return [];
+  const hits = value.hits;
+  if (!Array.isArray(hits)) return [];
+  return hits.filter(isrecord);
+}
+function maphit(hit, index, total) {
+  const snippetresult = isrecord(hit._snippetResult) ? hit._snippetResult : null;
+  const contentmeta = snippetresult && isrecord(snippetresult.content) ? snippetresult.content : null;
+  const descriptionmeta = snippetresult && isrecord(snippetresult.description) ? snippetresult.description : null;
+  const headingmeta = snippetresult && isrecord(snippetresult.heading) ? snippetresult.heading : null;
+  const slug = getstring(hit.slug) ?? getstring(hit.path);
+  const heading = getstring(hit.heading);
+  const title = getstring(hit.title) ?? heading ?? slug;
+  if (!slug || !title) return null;
+  const snippet = getstring(contentmeta?.value) ?? getstring(descriptionmeta?.value) ?? getstring(headingmeta?.value) ?? getstring(hit.description) ?? getstring(hit.content);
+  return {
+    doc: normalize({
+      slug,
+      title,
+      description: getstring(hit.description),
+      content: getstring(hit.content) ?? ""
+    }),
+    score: Math.max(1, total - index),
+    snippet,
+    anchor: getstring(hit.anchor),
+    heading
+  };
+}
+function createAlgoliaAdapter(config) {
+  const body = {
+    attributesToRetrieve: config.attributes ?? ["slug", "path", "title", "description", "content", "anchor", "heading"],
+    attributesToSnippet: ["content:24", "description:18", "heading:18"]
+  };
+  return {
+    async search(query, docs, limit = 8) {
+      const value = query.trim();
+      if (!value) return fallback(docs, limit);
+      const url = `https://${config.appid}-dsn.algolia.net/1/indexes/${encodeURIComponent(config.index)}/query`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-algolia-api-key": config.key,
+          "x-algolia-application-id": config.appid
+        },
+        body: JSON.stringify({ ...body, query: value, hitsPerPage: limit })
+      });
+      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 createalgoliaadapter = createAlgoliaAdapter;
+
+export { createAlgoliaAdapter, createalgoliaadapter };

package/dist/analytics.d.ts

@@ -0,0 +1,31 @@
+interface AnalyticsEvent {
+    type: "pageview" | "search" | "feedback" | "click";
+    path: string;
+    timestamp: number;
+    data?: Record<string, string>;
+}
+interface AnalyticsConfig {
+    endpoint?: string;
+    sampleRate?: number;
+    respectDnt?: boolean;
+}
+interface AnalyticsSummary {
+    topPages: {
+        path: string;
+        views: number;
+    }[];
+    searchTerms: {
+        term: string;
+        count: number;
+    }[];
+    totalViews: number;
+}
+declare function createAnalytics(config?: AnalyticsConfig): {
+    track: (event: Omit<AnalyticsEvent, "timestamp">) => void;
+    flush: () => Promise<void>;
+    getQueue: () => AnalyticsEvent[];
+};
+declare function generateScript(config?: AnalyticsConfig): string;
+declare function aggregateEvents(events: AnalyticsEvent[]): AnalyticsSummary;
+
+export { type AnalyticsConfig, type AnalyticsEvent, aggregateEvents, createAnalytics, generateScript };

package/dist/analytics.js

@@ -0,0 +1,61 @@
+function createAnalytics(config) {
+  const queue = [];
+  const endpoint = config?.endpoint ?? "/api/analytics";
+  const sampleRate = config?.sampleRate ?? 1;
+  const respectDnt = config?.respectDnt ?? true;
+  let retries = 0;
+  const maxretries = 5;
+  function track(event) {
+    if (respectDnt && typeof navigator !== "undefined" && navigator.doNotTrack === "1") return;
+    if (Math.random() > sampleRate) return;
+    queue.push({ ...event, timestamp: Date.now() });
+  }
+  async function flush() {
+    if (queue.length === 0) return;
+    const batch = queue.splice(0, queue.length);
+    try {
+      await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(batch)
+      });
+      retries = 0;
+    } catch {
+      if (retries < maxretries) {
+        retries += 1;
+        queue.unshift(...batch);
+      }
+    }
+  }
+  function getQueue() {
+    return [...queue];
+  }
+  return { track, flush, getQueue };
+}
+function generateScript(config) {
+  const ep = config?.endpoint ?? "/api/analytics";
+  const sr = config?.sampleRate ?? 1;
+  const dnt = config?.respectDnt ?? true;
+  const safe = JSON.stringify(ep);
+  return `<script>(function(){${dnt ? 'if(navigator.doNotTrack==="1")return;' : ""}${sr < 1 ? `if(Math.random()>${sr})return;` : ""}var q=[],e=${safe},h=history;function t(){q.push({type:"pageview",path:location.pathname,timestamp:+new Date})}function s(){if(q.length){var d=JSON.stringify(q);q=[];navigator.sendBeacon?navigator.sendBeacon(e,d):fetch(e,{method:"POST",body:d})}}t();var o=h.pushState;h.pushState=function(){o.apply(h,arguments);t()};onpopstate=t;setInterval(s,5e3);document.onvisibilitychange=function(){document.hidden&&s()}})()</script>`;
+}
+function aggregateEvents(events) {
+  const pages = /* @__PURE__ */ new Map();
+  const terms = /* @__PURE__ */ new Map();
+  let totalViews = 0;
+  for (const event of events) {
+    if (event.type === "pageview") {
+      totalViews++;
+      pages.set(event.path, (pages.get(event.path) ?? 0) + 1);
+    }
+    if (event.type === "search" && event.data?.term) {
+      const term = event.data.term;
+      terms.set(term, (terms.get(term) ?? 0) + 1);
+    }
+  }
+  const topPages = [...pages.entries()].map(([path, views]) => ({ path, views })).sort((a, b) => b.views - a.views);
+  const searchTerms = [...terms.entries()].map(([term, count]) => ({ term, count })).sort((a, b) => b.count - a.count);
+  return { topPages, searchTerms, totalViews };
+}
+
+export { aggregateEvents, createAnalytics, generateScript };

package/dist/ansi.d.ts

@@ -0,0 +1,5 @@
+import { ShikiTransformer } from '@shikijs/types';
+
+declare function transformerAnsi(): ShikiTransformer;
+
+export { transformerAnsi };