@youtyan/code-viewer 0.1.16 → 0.1.17

package/web-src/server/range.ts

@@ -1,236 +0,0 @@
-export type DiffRange = {
-  from?: string;
-  to?: string;
-};
-
-export type ByteRange = {
-  start: number;
-  end: number;
-};
-
-export type ByteRangeParseResult =
-  | { kind: 'range'; range: ByteRange }
-  | { kind: 'invalid' }
-  | { kind: 'unsatisfiable' };
-
-export type LineRangeResult = {
-  lines: string[];
-  total: number;
-  complete: boolean;
-};
-
-export type LineOffsetIndex = {
-  size: number;
-  total: number;
-  newlines: Uint32Array | Float64Array;
-};
-
-export type IndexedLineByteRange = {
-  start: number;
-  endExclusive: number;
-};
-
-export type BytesWithLineOffsetIndex = {
-  bytes: Uint8Array;
-  index: LineOffsetIndex;
-};
-
-export function isSameWorktreeRange(range: DiffRange): boolean {
-  return range.from === 'worktree' && range.to === 'worktree';
-}
-
-export function parseHttpByteRange(header: string | null, size: number): ByteRangeParseResult {
-  if (!header) return { kind: 'invalid' };
-  if (size < 1) return { kind: 'unsatisfiable' };
-  const match = header.match(/^bytes=(\d*)-(\d*)$/);
-  if (!match) return { kind: 'invalid' };
-  const [, rawStart, rawEnd] = match;
-  if (!rawStart && !rawEnd) return { kind: 'invalid' };
-  let start: number;
-  let end: number;
-  if (!rawStart) {
-    const suffixLength = Number(rawEnd);
-    if (!Number.isSafeInteger(suffixLength) || suffixLength < 1) return { kind: 'unsatisfiable' };
-    start = Math.max(0, size - suffixLength);
-    end = size - 1;
-  } else {
-    start = Number(rawStart);
-    end = rawEnd ? Number(rawEnd) : size - 1;
-    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end)) return { kind: 'invalid' };
-    if (end >= size) end = size - 1;
-  }
-  if (start < 0 || end < start || start >= size) return { kind: 'unsatisfiable' };
-  return { kind: 'range', range: { start, end } };
-}
-
-export async function collectLineRangeFromStream(stream: ReadableStream<Uint8Array>, start: number, end: number): Promise<LineRangeResult> {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  const lines: string[] = [];
-  let lineNo = 1;
-  let pending = '';
-  let hasMore = false;
-
-  const pushLine = (line: string) => {
-    if (line.endsWith('\r')) line = line.slice(0, -1);
-    if (lineNo >= start && lineNo <= end) lines.push(line);
-    else if (lineNo > end) hasMore = true;
-    lineNo++;
-  };
-
-  while (!hasMore) {
-    const chunk = await reader.read();
-    if (chunk.done) break;
-    pending += decoder.decode(chunk.value, { stream: true });
-    let newline = pending.indexOf('\n');
-    while (newline !== -1) {
-      pushLine(pending.slice(0, newline));
-      pending = pending.slice(newline + 1);
-      if (hasMore) break;
-      newline = pending.indexOf('\n');
-    }
-  }
-  if (hasMore) {
-    try { await reader.cancel(); } catch { /* best effort */ }
-    return { lines, total: lineNo - 1, complete: false };
-  }
-  pending += decoder.decode();
-  if (pending.length > 0) pushLine(pending);
-  if (hasMore) return { lines, total: lineNo - 1, complete: false };
-  return { lines, total: Math.max(0, lineNo - 1), complete: true };
-}
-
-export function buildLineOffsetIndex(bytes: Uint8Array): LineOffsetIndex {
-  const builder = createLineOffsetIndexBuilder(bytes.length);
-  for (let index = 0; index < bytes.length; index++) {
-    if (bytes[index] === 10) builder.push(index);
-  }
-  const lastByte = bytes.length > 0 ? bytes[bytes.length - 1] : -1;
-  return builder.finish(bytes.length, bytes.length > 0 && lastByte !== 10);
-}
-
-export async function buildLineOffsetIndexFromStream(stream: ReadableStream<Uint8Array>, size: number): Promise<LineOffsetIndex> {
-  const reader = stream.getReader();
-  const builder = createLineOffsetIndexBuilder(size);
-  let offset = 0;
-  let lastByte = -1;
-  while (true) {
-    const chunk = await reader.read();
-    if (chunk.done) break;
-    const bytes = chunk.value;
-    for (let index = 0; index < bytes.length; index++) {
-      const byte = bytes[index];
-      if (byte === 10) builder.push(offset + index);
-      lastByte = byte;
-    }
-    offset += bytes.length;
-  }
-  return builder.finish(offset, offset > 0 && lastByte !== 10);
-}
-
-export async function collectByteRangeFromStream(stream: ReadableStream<Uint8Array>, start: number, endExclusive: number): Promise<Uint8Array> {
-  const reader = stream.getReader();
-  const chunks: Uint8Array[] = [];
-  let offset = 0;
-  let total = 0;
-  while (offset < endExclusive) {
-    const chunk = await reader.read();
-    if (chunk.done) break;
-    const chunkStart = offset;
-    const chunkEnd = offset + chunk.value.byteLength;
-    if (chunkEnd > start && chunkStart < endExclusive) {
-      const sliceStart = Math.max(0, start - chunkStart);
-      const sliceEnd = Math.min(chunk.value.byteLength, endExclusive - chunkStart);
-      const slice = chunk.value.subarray(sliceStart, sliceEnd);
-      chunks.push(slice);
-      total += slice.byteLength;
-    }
-    offset = chunkEnd;
-  }
-  try { await reader.cancel(); } catch { /* best effort */ }
-  if (chunks.length === 1) return chunks[0];
-  const bytes = new Uint8Array(total);
-  let writeOffset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, writeOffset);
-    writeOffset += chunk.byteLength;
-  }
-  return bytes;
-}
-
-export async function collectBytesWithLineOffsetIndexFromStream(stream: ReadableStream<Uint8Array>, sizeHint: number): Promise<BytesWithLineOffsetIndex> {
-  const reader = stream.getReader();
-  const builder = createLineOffsetIndexBuilder(sizeHint);
-  const chunks: Uint8Array[] = [];
-  let offset = 0;
-  let lastByte = -1;
-  while (true) {
-    const chunk = await reader.read();
-    if (chunk.done) break;
-    const bytes = chunk.value;
-    chunks.push(bytes);
-    for (let index = 0; index < bytes.length; index++) {
-      const byte = bytes[index];
-      if (byte === 10) builder.push(offset + index);
-      lastByte = byte;
-    }
-    offset += bytes.length;
-  }
-  const collected = new Uint8Array(offset);
-  let writeOffset = 0;
-  for (const chunk of chunks) {
-    collected.set(chunk, writeOffset);
-    writeOffset += chunk.byteLength;
-  }
-  return {
-    bytes: collected,
-    index: builder.finish(offset, offset > 0 && lastByte !== 10),
-  };
-}
-
-function createLineOffsetIndexBuilder(size: number) {
-  const useFloat64 = size > 0xffffffff;
-  let capacity = 1024;
-  let length = 0;
-  let offsets: Uint32Array | Float64Array = useFloat64 ? new Float64Array(capacity) : new Uint32Array(capacity);
-  const grow = () => {
-    capacity *= 2;
-    const next = useFloat64 ? new Float64Array(capacity) : new Uint32Array(capacity);
-    next.set(offsets);
-    offsets = next;
-  };
-  return {
-    push(offset: number) {
-      if (length >= capacity) grow();
-      offsets[length++] = offset;
-    },
-    finish(totalSize: number, hasTrailingLine: boolean): LineOffsetIndex {
-      return {
-        size: totalSize,
-        total: length + (hasTrailingLine ? 1 : 0),
-        newlines: offsets.slice(0, length) as Uint32Array | Float64Array,
-      };
-    },
-  };
-}
-
-export function lineByteRangeForIndex(index: LineOffsetIndex, start: number, end: number): IndexedLineByteRange | null {
-  const normalizedStart = Math.max(1, Math.floor(start));
-  const normalizedEnd = Math.max(normalizedStart, Math.floor(end));
-  if (normalizedStart > index.total) return null;
-  const lastLine = Math.min(normalizedEnd, index.total);
-  const byteStart = normalizedStart <= 1 ? 0 : index.newlines[normalizedStart - 2] + 1;
-  const byteEnd = lastLine <= index.newlines.length ? index.newlines[lastLine - 1] : index.size;
-  return { start: byteStart, endExclusive: byteEnd };
-}
-
-export function collectLineRangeFromIndexedText(text: string, index: LineOffsetIndex, start: number, end: number): LineRangeResult {
-  const normalizedStart = Math.max(1, Math.floor(start));
-  const normalizedEnd = Math.max(normalizedStart, Math.floor(end));
-  if (normalizedStart > index.total) return { lines: [], total: index.total, complete: true };
-  const expectedLines = Math.min(normalizedEnd, index.total) - normalizedStart + 1;
-  const lines = text.length
-    ? text.split('\n').map(line => line.endsWith('\r') ? line.slice(0, -1) : line)
-    : Array.from({ length: expectedLines }, () => '');
-  return { lines, total: index.total, complete: end >= index.total };
-}

package/web-src/server/runtime.d.ts

@@ -1,61 +0,0 @@
-interface BunFile extends globalThis.Blob {
-  arrayBuffer(): Promise<ArrayBuffer>;
-  slice(start?: number, end?: number, contentType?: string): BunFile;
-  stream(): ReadableStream<Uint8Array<ArrayBuffer>>;
-  text(): Promise<string>;
-}
-
-declare const Bun: {
-  file(path: string): BunFile;
-  spawn(args: string[], opts?: Record<string, unknown>): {
-    kill(signal?: string): void;
-    exited: Promise<number>;
-    stdout?: ReadableStream<Uint8Array>;
-    stderr?: ReadableStream<Uint8Array>;
-  };
-  spawnSync(args: string[], opts?: Record<string, unknown>): {
-    exitCode: number;
-    stdout: Uint8Array;
-    stderr: Uint8Array;
-  };
-  serve(opts: {
-    hostname?: string;
-    port?: number;
-    fetch(req: Request): Response | Promise<Response>;
-  }): { port: number };
-};
-
-declare const process: {
-  argv: string[];
-  env: Record<string, string | undefined>;
-  cwd(): string;
-  platform: 'darwin' | 'win32' | string;
-  on(event: 'SIGINT' | 'SIGTERM', listener: () => void): void;
-  exit(code?: number): never;
-};
-
-interface ImportMeta {
-  dir: string;
-}
-
-declare module 'node:fs' {
-  export function existsSync(path: string): boolean;
-  export function readdirSync(path: string): string[];
-  export function readFileSync(path: string): Buffer;
-  export function readFileSync(path: string, encoding: BufferEncoding): string;
-  export function realpathSync(path: string): string;
-  export function statSync(path: string): { mtimeMs: number };
-  export function watch(
-    path: string,
-    options: { persistent?: boolean },
-    listener: (eventType: string, filename: string | Buffer | null) => void,
-  ): unknown;
-}
-
-declare module 'node:path' {
-  export function basename(path: string): string;
-  export function extname(path: string): string;
-  export function join(...parts: string[]): string;
-  export function normalize(path: string): string;
-  export function relative(from: string, to: string): string;
-}

package/web-src/server/search.ts

@@ -1,104 +0,0 @@
-import type { FileSearchListResponse, GrepMatch } from '../types';
-import type { GitTreeEntry } from './git';
-
-export const GREP_DEFAULT_MAX = 200;
-export const GREP_ABSOLUTE_MAX = 500;
-export const GREP_MAX_FILE_BYTES = 2 * 1024 * 1024;
-export const FILE_SEARCH_ABSOLUTE_MAX = 50000;
-
-export function normalizeGrepMax(value: string | null): number {
-  const parsed = Number(value || '');
-  if (!Number.isInteger(parsed) || parsed <= 0) return GREP_DEFAULT_MAX;
-  return Math.min(parsed, GREP_ABSOLUTE_MAX);
-}
-
-export function isSkippableSearchPath(path: string, omitDirNames: string[] = []): boolean {
-  const omitDirs = new Set(omitDirNames.map(name => name.toLowerCase()));
-  return path.split(/[\\/]+/).some(part => {
-    const lower = part.toLowerCase();
-    return lower === '.git' || omitDirs.has(lower);
-  });
-}
-
-export function fixedStringLineMatches(path: string, text: string, query: string, max: number): GrepMatch[] {
-  const needle = query.toLowerCase();
-  if (!needle) return [];
-  const matches: GrepMatch[] = [];
-  const lines = text.split('\n');
-  for (let i = 0; i < lines.length && matches.length < max; i++) {
-    const line = lines[i];
-    const column = line.toLowerCase().indexOf(needle);
-    if (column < 0) continue;
-    matches.push({
-      path,
-      line: i + 1,
-      column: column + 1,
-      preview: line.slice(0, 500),
-    });
-  }
-  return matches;
-}
-
-export function buildFileSearchList(ref: string, generation: number, entries: GitTreeEntry[]): FileSearchListResponse {
-  const files = entries
-    .filter((entry): entry is GitTreeEntry & { type: 'blob' | 'commit' } => entry.type === 'blob' || entry.type === 'commit')
-    .slice(0, FILE_SEARCH_ABSOLUTE_MAX)
-    .map(entry => ({ path: entry.path, type: entry.type }));
-  return {
-    ref,
-    generation,
-    files,
-    truncated: entries.length > FILE_SEARCH_ABSOLUTE_MAX,
-  };
-}
-
-export function buildRgArgs(query: string, max: number, paths: string[], regex = false, omitDirNames: string[] = []): string[] {
-  const safePaths = paths.length ? paths : ['.'];
-  const omitGlobs = omitDirNames.flatMap(name => ['--glob', `!${name}/**`, '--glob', `!**/${name}/**`]);
-  const args = [
-    'rg',
-    '--no-config',
-    '--line-number',
-    '--column',
-    '--no-heading',
-    '--color',
-    'never',
-    '--smart-case',
-    '--max-count',
-    String(max),
-    '--max-filesize',
-    '2M',
-    ...omitGlobs,
-    '-e',
-    query,
-    '--',
-    ...safePaths,
-  ];
-  if (!regex) args.splice(8, 0, '--fixed-strings');
-  return args;
-}
-
-export function parseRgOutput(stdout: string, max: number, omitDirNames: string[] = []): GrepMatch[] {
-  const matches: GrepMatch[] = [];
-  for (const line of stdout.split('\n')) {
-    if (!line || matches.length >= max) continue;
-    const parsed = /^(.*):(\d+):(\d+):(.*)$/.exec(line);
-    if (!parsed) continue;
-    const path = parsed[1];
-    const lineNo = Number(parsed[2]);
-    const column = Number(parsed[3]);
-    const preview = parsed[4];
-    if (!path || !lineNo || !column || isSkippableSearchPath(path, omitDirNames)) continue;
-    matches.push({ path, line: lineNo, column, preview: preview.slice(0, 500) });
-  }
-  return matches;
-}
-
-export function parseGitGrepOutput(stdout: string, ref: string, max: number, omitDirNames: string[] = []): GrepMatch[] {
-  const prefix = ref + ':';
-  const normalized = stdout
-    .split('\n')
-    .map(line => line.startsWith(prefix) ? line.slice(prefix.length) : line)
-    .join('\n');
-  return parseRgOutput(normalized, max, omitDirNames);
-}

package/web-src/types.ts

@@ -1,142 +0,0 @@
-import type { GdpExpandLogic } from './expand-logic';
-
-export type FileMeta = {
-  order?: number;
-  key?: string;
-  path: string;
-  old_path?: string;
-  display_path?: string;
-  status?: string;
-  additions?: number;
-  deletions?: number;
-  binary?: boolean;
-  media_kind?: string | null;
-  size_class?: string;
-  force_layout?: string;
-  highlight?: boolean;
-  load_url: string;
-  preview_url?: string | null;
-  estimated_height_px?: number;
-  untracked?: boolean;
-};
-
-export type DiffMeta = {
-  files: FileMeta[];
-  totals?: {
-    files: number;
-    additions: number;
-    deletions: number;
-  };
-  range?: string;
-  branch?: string;
-  project?: string;
-  generation?: number;
-};
-
-export type RepoTreeEntry = {
-  name: string;
-  path: string;
-  type: 'tree' | 'blob' | 'commit';
-  children_omitted?: true;
-  children_omitted_reason?: 'heavy' | 'internal' | 'truncated';
-};
-
-export type RepoTreeResponse = {
-  ref: string;
-  path: string;
-  project: string;
-  branch?: string;
-  upload_enabled?: boolean;
-  entries: RepoTreeEntry[];
-  readme?: {
-    path: string;
-    text: string;
-  } | null;
-};
-
-export type SettingsResponse = {
-  project: string;
-  scope: {
-    omit_dirs_effective: string[];
-    omit_dirs_built_in: string[];
-    max_entries: number;
-  };
-};
-
-export type FileSearchListResponse = {
-  ref: string;
-  generation: number;
-  files: {
-    path: string;
-    type: 'blob' | 'commit';
-  }[];
-  truncated: boolean;
-};
-
-export type GrepMatch = {
-  path: string;
-  line: number;
-  column: number;
-  preview: string;
-};
-
-export type GrepResponse = {
-  ref: string;
-  engine: 'rg' | 'git' | 'fallback';
-  truncated: boolean;
-  matches: GrepMatch[];
-};
-
-export type FileDiffResponse = {
-  path: string;
-  old_path?: string;
-  status?: string;
-  mode?: string;
-  diff: string;
-  hunk_count?: number;
-  rendered_hunk_count?: number;
-  truncated?: boolean;
-  binary?: boolean;
-  generation?: number;
-};
-
-export type FileRangeResponse = {
-  path: string;
-  ref: string;
-  start: number;
-  end: number;
-  lines: string[];
-  /**
-   * When complete is true, total is the file's total line count.
-   * When complete is false, total is only the highest line number the server
-   * had to scan to prove more lines exist.
-   */
-  total: number;
-  complete?: boolean;
-  generation?: number;
-};
-
-export type DiffCardElement = HTMLElement & {
-  _diffData?: FileDiffResponse | null;
-  _file?: FileMeta | null;
-};
-
-export type RefResponse = {
-  branches?: string[];
-  tags?: string[];
-  commits?: string[];
-  current?: string;
-};
-
-declare global {
-  interface Window {
-    Diff2HtmlUI: any;
-    hljs: any;
-    GdpExpandLogic: typeof GdpExpandLogic;
-    _lastMeta?: DiffMeta;
-    __gdpScrollSpy?: EventListener;
-    __gdpSidebarTouchedAt?: number;
-  }
-
-  const Diff2HtmlUI: any;
-}