@jitl/opentui-core 0.1.97-next.c8a3f05

package/assets/zig/highlights.scm

@@ -0,0 +1,284 @@
+; Query from: https://github.com/nvim-treesitter/nvim-treesitter/raw/refs/heads/master/queries/zig/highlights.scm
+; Variables
+(identifier) @variable
+
+; Parameters
+(parameter
+  name: (identifier) @variable.parameter)
+
+(payload
+  (identifier) @variable.parameter)
+
+; Types
+(parameter
+  type: (identifier) @type)
+
+((identifier) @type
+  (#lua-match? @type "^[A-Z_][a-zA-Z0-9_]*"))
+
+(variable_declaration
+  (identifier) @type
+  "="
+  [
+    (struct_declaration)
+    (enum_declaration)
+    (union_declaration)
+    (opaque_declaration)
+  ])
+
+[
+  (builtin_type)
+  "anyframe"
+] @type.builtin
+
+; Constants
+((identifier) @constant
+  (#lua-match? @constant "^[A-Z][A-Z_0-9]+$"))
+
+[
+  "null"
+  "unreachable"
+  "undefined"
+] @constant.builtin
+
+(field_expression
+  .
+  member: (identifier) @constant)
+
+(enum_declaration
+  (container_field
+    type: (identifier) @constant))
+
+; Labels
+(block_label
+  (identifier) @label)
+
+(break_label
+  (identifier) @label)
+
+; Fields
+(field_initializer
+  .
+  (identifier) @variable.member)
+
+(field_expression
+  (_)
+  member: (identifier) @variable.member)
+
+(container_field
+  name: (identifier) @variable.member)
+
+(initializer_list
+  (assignment_expression
+    left: (field_expression
+      .
+      member: (identifier) @variable.member)))
+
+; Functions
+(builtin_identifier) @function.builtin
+
+(call_expression
+  function: (identifier) @function.call)
+
+(call_expression
+  function: (field_expression
+    member: (identifier) @function.call))
+
+(function_declaration
+  name: (identifier) @function)
+
+; Modules
+(variable_declaration
+  (identifier) @module
+  (builtin_function
+    (builtin_identifier) @keyword.import
+    (#any-of? @keyword.import "@import" "@cImport")))
+
+; Builtins
+[
+  "c"
+  "..."
+] @variable.builtin
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "_"))
+
+(calling_convention
+  (identifier) @variable.builtin)
+
+; Keywords
+[
+  "asm"
+  "defer"
+  "errdefer"
+  "test"
+  "error"
+  "const"
+  "var"
+] @keyword
+
+[
+  "struct"
+  "union"
+  "enum"
+  "opaque"
+] @keyword.type
+
+[
+  "async"
+  "await"
+  "suspend"
+  "nosuspend"
+  "resume"
+] @keyword.coroutine
+
+"fn" @keyword.function
+
+[
+  "and"
+  "or"
+  "orelse"
+] @keyword.operator
+
+"return" @keyword.return
+
+[
+  "if"
+  "else"
+  "switch"
+] @keyword.conditional
+
+[
+  "for"
+  "while"
+  "break"
+  "continue"
+] @keyword.repeat
+
+[
+  "usingnamespace"
+  "export"
+] @keyword.import
+
+[
+  "try"
+  "catch"
+] @keyword.exception
+
+[
+  "volatile"
+  "allowzero"
+  "noalias"
+  "addrspace"
+  "align"
+  "callconv"
+  "linksection"
+  "pub"
+  "inline"
+  "noinline"
+  "extern"
+  "comptime"
+  "packed"
+  "threadlocal"
+] @keyword.modifier
+
+; Operator
+[
+  "="
+  "*="
+  "*%="
+  "*|="
+  "/="
+  "%="
+  "+="
+  "+%="
+  "+|="
+  "-="
+  "-%="
+  "-|="
+  "<<="
+  "<<|="
+  ">>="
+  "&="
+  "^="
+  "|="
+  "!"
+  "~"
+  "-"
+  "-%"
+  "&"
+  "=="
+  "!="
+  ">"
+  ">="
+  "<="
+  "<"
+  "&"
+  "^"
+  "|"
+  "<<"
+  ">>"
+  "<<|"
+  "+"
+  "++"
+  "+%"
+  "-%"
+  "+|"
+  "-|"
+  "*"
+  "/"
+  "%"
+  "**"
+  "*%"
+  "*|"
+  "||"
+  ".*"
+  ".?"
+  "?"
+  ".."
+] @operator
+
+; Literals
+(character) @character
+
+([
+  (string)
+  (multiline_string)
+] @string
+  (#set! "priority" 95))
+
+(integer) @number
+
+(float) @number.float
+
+(boolean) @boolean
+
+(escape_sequence) @string.escape
+
+; Punctuation
+[
+  "["
+  "]"
+  "("
+  ")"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  ";"
+  "."
+  ","
+  ":"
+  "=>"
+  "->"
+] @punctuation.delimiter
+
+(payload
+  "|" @punctuation.bracket)
+
+; Comments
+(comment) @comment @spell
+
+((comment) @comment.documentation
+  (#lua-match? @comment.documentation "^//!"))

package/buffer.d.ts

@@ -0,0 +1,111 @@
+import { RGBA } from "./lib/index.js";
+import { type RenderLib } from "./zig.js";
+import { type Pointer } from "./compat/ffi.js";
+import { type BorderStyle, type BorderSides } from "./lib/index.js";
+import { TargetChannel, type WidthMethod, type CapturedLine } from "./types.js";
+import type { TextBufferView } from "./text-buffer-view.js";
+import type { EditorView } from "./editor-view.js";
+export declare class OptimizedBuffer {
+    private static fbIdCounter;
+    id: string;
+    lib: RenderLib;
+    private bufferPtr;
+    private _width;
+    private _height;
+    private _widthMethod;
+    respectAlpha: boolean;
+    private _rawBuffers;
+    private _destroyed;
+    get ptr(): Pointer;
+    private guard;
+    get buffers(): {
+        char: Uint32Array;
+        fg: Float32Array;
+        bg: Float32Array;
+        attributes: Uint32Array;
+    };
+    constructor(lib: RenderLib, ptr: Pointer, width: number, height: number, options: {
+        respectAlpha?: boolean;
+        id?: string;
+        widthMethod?: WidthMethod;
+    });
+    static create(width: number, height: number, widthMethod: WidthMethod, options?: {
+        respectAlpha?: boolean;
+        id?: string;
+    }): OptimizedBuffer;
+    get widthMethod(): WidthMethod;
+    get width(): number;
+    get height(): number;
+    setRespectAlpha(respectAlpha: boolean): void;
+    getNativeId(): string;
+    getRealCharBytes(addLineBreaks?: boolean): Uint8Array;
+    getSpanLines(): CapturedLine[];
+    clear(bg?: RGBA): void;
+    setCell(x: number, y: number, char: string, fg: RGBA, bg: RGBA, attributes?: number): void;
+    setCellWithAlphaBlending(x: number, y: number, char: string, fg: RGBA, bg: RGBA, attributes?: number): void;
+    drawText(text: string, x: number, y: number, fg: RGBA, bg?: RGBA, attributes?: number, selection?: {
+        start: number;
+        end: number;
+        bgColor?: RGBA;
+        fgColor?: RGBA;
+    } | null): void;
+    fillRect(x: number, y: number, width: number, height: number, bg: RGBA): void;
+    colorMatrix(matrix: Float32Array, cellMask: Float32Array, strength?: number, target?: TargetChannel): void;
+    colorMatrixUniform(matrix: Float32Array, strength?: number, target?: TargetChannel): void;
+    drawFrameBuffer(destX: number, destY: number, frameBuffer: OptimizedBuffer, sourceX?: number, sourceY?: number, sourceWidth?: number, sourceHeight?: number): void;
+    destroy(): void;
+    drawTextBuffer(textBufferView: TextBufferView, x: number, y: number): void;
+    drawEditorView(editorView: EditorView, x: number, y: number): void;
+    drawSuperSampleBuffer(x: number, y: number, pixelDataPtr: Pointer, pixelDataLength: number, format: "bgra8unorm" | "rgba8unorm", alignedBytesPerRow: number): void;
+    drawPackedBuffer(dataPtr: Pointer, dataLen: number, posX: number, posY: number, terminalWidthCells: number, terminalHeightCells: number): void;
+    drawGrayscaleBuffer(posX: number, posY: number, intensities: Float32Array, srcWidth: number, srcHeight: number, fg?: RGBA | null, bg?: RGBA | null): void;
+    drawGrayscaleBufferSupersampled(posX: number, posY: number, intensities: Float32Array, srcWidth: number, srcHeight: number, fg?: RGBA | null, bg?: RGBA | null): void;
+    resize(width: number, height: number): void;
+    drawBox(options: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        borderStyle?: BorderStyle;
+        customBorderChars?: Uint32Array;
+        border: boolean | BorderSides[];
+        borderColor: RGBA;
+        backgroundColor: RGBA;
+        shouldFill?: boolean;
+        title?: string;
+        titleAlignment?: "left" | "center" | "right";
+        bottomTitle?: string;
+        bottomTitleAlignment?: "left" | "center" | "right";
+    }): void;
+    pushScissorRect(x: number, y: number, width: number, height: number): void;
+    popScissorRect(): void;
+    clearScissorRects(): void;
+    pushOpacity(opacity: number): void;
+    popOpacity(): void;
+    getCurrentOpacity(): number;
+    clearOpacity(): void;
+    encodeUnicode(text: string): {
+        ptr: Pointer;
+        data: Array<{
+            width: number;
+            char: number;
+        }>;
+    } | null;
+    freeUnicode(encoded: {
+        ptr: Pointer;
+        data: Array<{
+            width: number;
+            char: number;
+        }>;
+    }): void;
+    drawGrid(options: {
+        borderChars: Uint32Array;
+        borderFg: RGBA;
+        borderBg: RGBA;
+        columnOffsets: Int32Array;
+        rowOffsets: Int32Array;
+        drawInner: boolean;
+        drawOuter: boolean;
+    }): void;
+    drawChar(char: number, x: number, y: number, fg: RGBA, bg: RGBA, attributes?: number): void;
+}

package/compat/FFIType.d.ts

@@ -0,0 +1,304 @@
+/** Copy of bun:ffi#FFIType */
+export declare enum FFIType {
+    char = 0,
+    /**
+     * 8-bit signed integer
+     *
+     * Must be a value between -127 and 127
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * signed char
+     * char // on x64 & aarch64 macOS
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    int8_t = 1,
+    /**
+     * 8-bit signed integer
+     *
+     * Must be a value between -127 and 127
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * signed char
+     * char // on x64 & aarch64 macOS
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    i8 = 1,
+    /**
+     * 8-bit unsigned integer
+     *
+     * Must be a value between 0 and 255
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * unsigned char
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    uint8_t = 2,
+    /**
+     * 8-bit unsigned integer
+     *
+     * Must be a value between 0 and 255
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * unsigned char
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    u8 = 2,
+    /**
+     * 16-bit signed integer
+     *
+     * Must be a value between -32768 and 32767
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * in16_t
+     * short // on arm64 & x64
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    int16_t = 3,
+    /**
+     * 16-bit signed integer
+     *
+     * Must be a value between -32768 and 32767
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * in16_t
+     * short // on arm64 & x64
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    i16 = 3,
+    /**
+     * 16-bit unsigned integer
+     *
+     * Must be a value between 0 and 65535, inclusive.
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * uint16_t
+     * unsigned short // on arm64 & x64
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    uint16_t = 4,
+    /**
+     * 16-bit unsigned integer
+     *
+     * Must be a value between 0 and 65535, inclusive.
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * uint16_t
+     * unsigned short // on arm64 & x64
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    u16 = 4,
+    /**
+     * 32-bit signed integer
+     */
+    int32_t = 5,
+    /**
+     * 32-bit signed integer
+     *
+     * Alias of {@link FFIType.int32_t}
+     */
+    i32 = 5,
+    /**
+     * 32-bit signed integer
+     *
+     * The same as `int` in C
+     *
+     * ```c
+     * int
+     * ```
+     */
+    int = 5,
+    /**
+     * 32-bit unsigned integer
+     *
+     * The same as `unsigned int` in C (on x64 & arm64)
+     *
+     * C:
+     * ```c
+     * unsigned int
+     * ```
+     * JavaScript:
+     * ```js
+     * ptr(new Uint32Array(1))
+     * ```
+     */
+    uint32_t = 6,
+    /**
+     * 32-bit unsigned integer
+     *
+     * Alias of {@link FFIType.uint32_t}
+     */
+    u32 = 6,
+    /**
+     * int64 is a 64-bit signed integer
+     */
+    int64_t = 7,
+    /**
+     * i64 is a 64-bit signed integer
+     */
+    i64 = 7,
+    /**
+     * 64-bit unsigned integer
+     */
+    uint64_t = 8,
+    /**
+     * 64-bit unsigned integer
+     */
+    u64 = 8,
+    /**
+     * IEEE-754 double precision float
+     */
+    double = 9,
+    /**
+     * Alias of {@link FFIType.double}
+     */
+    f64 = 9,
+    /**
+     * IEEE-754 single precision float
+     */
+    float = 10,
+    /**
+     * Alias of {@link FFIType.float}
+     */
+    f32 = 10,
+    /**
+     * Boolean value
+     *
+     * Must be `true` or `false`. `0` and `1` type coercion is not supported.
+     *
+     * In C, this corresponds to:
+     * ```c
+     * bool
+     * _Bool
+     * ```
+     */
+    bool = 11,
+    /**
+     * Pointer value
+     *
+     * See {@link Bun.FFI.ptr} for more information
+     *
+     * In C:
+     * ```c
+     * void*
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * ptr(new Uint8Array(1))
+     * ```
+     */
+    ptr = 12,
+    /**
+     * Pointer value
+     *
+     * alias of {@link FFIType.ptr}
+     */
+    pointer = 12,
+    /**
+     * void value
+     *
+     * void arguments are not supported
+     *
+     * void return type is the default return type
+     *
+     * In C:
+     * ```c
+     * void
+     * ```
+     */
+    void = 13,
+    /**
+     * When used as a `returns`, this will automatically become a {@link CString}.
+     *
+     * When used in `args` it is equivalent to {@link FFIType.pointer}
+     */
+    cstring = 14,
+    /**
+     * Attempt to coerce `BigInt` into a `Number` if it fits. This improves performance
+     * but means you might get a `BigInt` or you might get a `number`.
+     *
+     * In C, this always becomes `int64_t`
+     *
+     * In JavaScript, this could be number or it could be BigInt, depending on what
+     * value is passed in.
+     */
+    i64_fast = 15,
+    /**
+     * Attempt to coerce `BigInt` into a `Number` if it fits. This improves performance
+     * but means you might get a `BigInt` or you might get a `number`.
+     *
+     * In C, this always becomes `uint64_t`
+     *
+     * In JavaScript, this could be number or it could be BigInt, depending on what
+     * value is passed in.
+     */
+    u64_fast = 16,
+    function = 17,
+    napi_env = 18,
+    napi_value = 19,
+    buffer = 20
+}

package/compat/Worker.d.ts

@@ -0,0 +1 @@
+export declare const Worker: typeof globalThis.Worker;

package/compat/bun-ffi-structs.d.ts

@@ -0,0 +1,2 @@
+export declare const defineStruct: typeof import("./nodejs/bun-ffi-structs/structs_ffi.js").defineStruct;
+export declare const defineEnum: typeof import("./nodejs/bun-ffi-structs/structs_ffi.js").defineEnum;