@gamecrafters/base-ui 0.0.5 → 0.0.7

package/build/components/status/Status.types.d.ts

@@ -0,0 +1,19 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type StatusVariant = "accent" | "success" | "attention" | "severe" | "danger" | "done" | "neutral";
+export type StatusSize = "small" | "medium" | "large";
+export type StatusProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+    variant?: StatusVariant;
+    size?: StatusSize;
+    srText?: string;
+    className?: string;
+}>;
+export type StatusIndicatorProps = React.ComponentPropsWithoutRef<"span"> & {
+    variant?: StatusVariant;
+    size?: StatusSize;
+    className?: string;
+};
+export type StatusContextValue = {
+    variant?: StatusVariant;
+    size?: StatusSize;
+};

package/build/components/status/StatusContext.d.ts

@@ -0,0 +1,2 @@
+import type { StatusContextValue } from "./Status.types";
+export declare const StatusContext: import("react").Context<StatusContextValue>;

package/build/components/status/StatusIndicator.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import type { StatusSize, StatusVariant } from "./Status.types";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    variant?: StatusVariant;
+    size?: StatusSize;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/status/index.d.ts

@@ -0,0 +1,17 @@
+import StatusIndicator from "./StatusIndicator";
+export declare const Status: (<As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "span" : As> & {
+    variant?: import("./Status.types").StatusVariant;
+    size?: import("./Status.types").StatusSize;
+    srText?: string;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Indicator: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        variant?: import("./Status.types").StatusVariant;
+        size?: import("./Status.types").StatusSize;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { StatusIndicator };
+export * from "./Status.types";

package/build/hooks/useSlots.d.ts

@@ -6,9 +6,6 @@ export type SlotConfig = Record<string, ComponentMatcher | ComponentAndPropsMatc
 type SlotElements<Config extends SlotConfig> = {
     [Property in keyof Config]: SlotValue<Config, Property>;
 };
-type SlotValue<Config, Property extends keyof Config> = Config[Property] extends React.ElementType ? React.ReactElement<React.ComponentPropsWithoutRef<Config[Property]>, Config[Property]> : Config[Property] extends readonly [
-    infer ElementType extends React.ElementType,
-    infer _testFn
-] ? React.ReactElement<React.ComponentPropsWithoutRef<ElementType>, ElementType> : never;
+type SlotValue<Config, Property extends keyof Config> = Config[Property] extends React.ElementType ? React.ReactElement<React.ComponentPropsWithoutRef<Config[Property]>, Config[Property]> : Config[Property] extends readonly [infer ElementType extends React.ElementType, infer _testFn] ? React.ReactElement<React.ComponentPropsWithoutRef<ElementType>, ElementType> : never;
 export declare const useSlots: <Config extends SlotConfig>(children: React.ReactNode, config: Config) => [Partial<SlotElements<Config>>, React.ReactNode[]];
 export {};

package/build/lib/qr-code/core/data.d.ts

@@ -0,0 +1,13 @@
+/**
+ * QR Code data encoding and bitstream construction
+ */
+import type { ErrorCorrectionLevel, QRCodeOptions } from "./types";
+export interface EncodedData {
+    version: number;
+    ecLevel: ErrorCorrectionLevel;
+    bits: number[];
+}
+/**
+ * Encode text into QR code data bits with error correction
+ */
+export declare function encodeData(text: string, options?: QRCodeOptions): EncodedData;

package/build/lib/qr-code/core/errors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Custom error classes for qr-code
+ */
+export declare class QRCodeError extends Error {
+    name: string;
+}
+export declare class InvalidInputError extends QRCodeError {
+    name: string;
+}
+export declare class CapacityError extends QRCodeError {
+    name: string;
+}

package/build/lib/qr-code/core/format.d.ts

@@ -0,0 +1,12 @@
+/**
+ * QR Code format and version info encoding
+ * BCH encoding for format info, Golay encoding for version info
+ */
+import type { Module } from "./matrix";
+import type { ErrorCorrectionLevel } from "./types";
+/** Generate 15-bit format info for given EC level and mask */
+export declare function generateFormatInfo(ecLevel: ErrorCorrectionLevel, mask: number): number;
+/** Write format info to the matrix at the reserved positions */
+export declare function writeFormatInfo(matrix: Module[][], ecLevel: ErrorCorrectionLevel, mask: number): void;
+/** Write version info for version 7+ */
+export declare function writeVersionInfo(matrix: Module[][], version: number): void;

package/build/lib/qr-code/core/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * QR Code core encoder — main entry point
+ */
+export type { ErrorCorrectionLevel, EncodingMode, QRCodeOptions, QRSegment } from "./types";
+export { encodeData } from "./data";
+export { createMatrix, placeFunctionPatterns, placeData } from "./matrix";
+export { selectBestMask, applyMask } from "./mask";
+export { writeFormatInfo, writeVersionInfo } from "./format";
+export { encodeMicroQR } from "./micro";
+export type { MicroQROptions } from "./micro";
+import type { QRCodeOptions } from "./types";
+/**
+ * Encode text into a QR code matrix.
+ * Returns a 2D boolean array — true = dark module.
+ */
+export declare function encodeQR(text: string, options?: QRCodeOptions): boolean[][];

package/build/lib/qr-code/core/mask.d.ts

@@ -0,0 +1,19 @@
+/**
+ * QR Code mask patterns and penalty evaluation
+ * 8 mask patterns, 4 penalty rules
+ */
+import type { Module } from "./matrix";
+/** Get mask function for a given mask pattern (0-7) */
+export declare function getMaskFn(mask: number): (r: number, c: number) => boolean;
+/** Apply a mask pattern to the matrix (only data modules) */
+export declare function applyMask(matrix: Module[][], mask: number, size: number, version: number): void;
+/**
+ * Select the best mask pattern by evaluating all 8 masks
+ * Returns the mask number with the lowest penalty score
+ */
+export declare function selectBestMask(matrix: Module[][], size: number, version: number, requestedMask?: number): number;
+/**
+ * Evaluate penalty score for a masked matrix
+ * Implements all 4 penalty rules from the QR code spec
+ */
+export declare function evaluatePenalty(matrix: Module[][], size: number): number;

package/build/lib/qr-code/core/matrix.d.ts

@@ -0,0 +1,17 @@
+/**
+ * QR Code matrix construction
+ * Function patterns, data placement, alignment patterns
+ */
+export type Module = boolean | null;
+/** Create an empty matrix of the given size */
+export declare function createMatrix(size: number): Module[][];
+/** Place all function patterns on the matrix */
+export declare function placeFunctionPatterns(matrix: Module[][], version: number): void;
+/**
+ * Place data bits in the matrix using the zigzag pattern
+ */
+export declare function placeData(matrix: Module[][], bits: number[], _version: number): void;
+/**
+ * Check if a module is a data module (not a function pattern)
+ */
+export declare function isDataModule(r: number, c: number, size: number, version: number): boolean;

package/build/lib/qr-code/core/micro.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Micro QR Code encoder (M1-M4)
+ * ISO/IEC 18004 — single finder pattern, reduced quiet zone
+ *
+ * M1: 11x11, numeric only, error detection only
+ * M2: 13x13, numeric/alphanumeric, EC L/M
+ * M3: 15x15, numeric/alphanumeric/byte, EC L/M
+ * M4: 17x17, numeric/alphanumeric/byte/kanji, EC L/M/Q
+ */
+export interface MicroQROptions {
+    version?: 1 | 2 | 3 | 4;
+    ecLevel?: "L" | "M" | "Q";
+    mask?: 0 | 1 | 2 | 3;
+}
+export declare const MICRO_QR_SIZES: readonly [11, 13, 15, 17];
+export declare function encodeMicroQR(text: string, options?: MicroQROptions): boolean[][];

package/build/lib/qr-code/core/mode.d.ts

@@ -0,0 +1,31 @@
+/**
+ * QR Code encoding modes - detection and encoding
+ */
+/** Check if a string can be encoded in numeric mode */
+export declare function isNumeric(text: string): boolean;
+/** Check if a string can be encoded in alphanumeric mode */
+export declare function isAlphanumeric(text: string): boolean;
+/** Check if a string can be encoded in Kanji mode (Shift JIS double-byte) */
+export declare function isKanji(_text: string): boolean;
+/** Auto-detect the best encoding mode for the given text */
+export declare function detectMode(text: string): "numeric" | "alphanumeric" | "byte" | "kanji";
+/** Get alphanumeric character value (0-44) */
+export declare function getAlphanumericValue(char: string): number;
+/** Encode numeric data to bits */
+export declare function encodeNumericData(text: string): number[];
+/** Encode alphanumeric data to bits */
+export declare function encodeAlphanumericData(text: string): number[];
+/** Encode byte data to bits */
+export declare function encodeByteData(data: Uint8Array): number[];
+/**
+ * Encode Kanji data to bits (13 bits per character)
+ * Input must be pre-converted to Shift JIS double-byte values
+ */
+export declare function encodeKanjiData(sjisValues: number[]): number[];
+/**
+ * Convert a Unicode string to Shift JIS double-byte values for Kanji encoding.
+ * This is a simplified mapping — covers common CJK characters.
+ */
+export declare function unicodeToShiftJIS(text: string): number[];
+/** Push a value as the specified number of bits (MSB first) */
+export declare function pushBits(arr: number[], value: number, count: number): void;

package/build/lib/qr-code/core/reed-solomon.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Reed-Solomon error correction for QR codes
+ * GF(256) arithmetic with primitive polynomial 0x11D
+ */
+/** Multiply two GF(256) elements */
+export declare function gfMultiply(a: number, b: number): number;
+/** Generate error correction codewords for a data block */
+export declare function generateECCodewords(data: number[], ecCount: number): number[];
+/**
+ * Add error correction to data bytes
+ * Handles block splitting, EC generation, and interleaving
+ */
+export declare function addErrorCorrection(dataBytes: number[], ecCodewordsPerBlock: number, group1Blocks: number, group1DataCW: number, group2Blocks: number, group2DataCW: number): number[];

package/build/lib/qr-code/core/segment.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Optimal segment mode switching for QR codes
+ */
+import type { QRSegment } from "./types";
+/**
+ * Split text into optimized segments that minimize total encoded bit length.
+ */
+export declare function optimizeSegments(text: string, version: number): QRSegment[];

package/build/lib/qr-code/core/tables.d.ts

@@ -0,0 +1,49 @@
+/**
+ * QR Code lookup tables for versions 1-40, all EC levels
+ * Based on ISO/IEC 18004:2015
+ */
+import type { ErrorCorrectionLevel } from "./types";
+/**
+ * Character count indicator bit lengths by version group and mode
+ * [V1-9, V10-26, V27-40]
+ */
+export declare const CHAR_COUNT_BITS: Record<string, [number, number, number]>;
+/** Get character count bits for a version and mode */
+export declare function getCharCountBits(version: number, mode: string): number;
+/**
+ * Alphanumeric character values
+ */
+export declare const ALPHANUMERIC_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+/**
+ * Error correction block information for each version and EC level
+ * Format: [totalCodewords, ecCodewordsPerBlock, group1Blocks,
+ *          group1DataCW, group2Blocks, group2DataCW]
+ */
+interface ECBlockInfo {
+    totalDataCodewords: number;
+    ecCodewordsPerBlock: number;
+    group1Blocks: number;
+    group1DataCW: number;
+    group2Blocks: number;
+    group2DataCW: number;
+}
+export declare function getECInfo(version: number, ecLevel: ErrorCorrectionLevel): ECBlockInfo;
+/**
+ * Alignment pattern positions for each version (2-40)
+ * Version 1 has no alignment patterns
+ */
+export declare const ALIGNMENT_POSITIONS: number[][];
+/**
+ * Remainder bits after data placement for each version
+ */
+export declare const REMAINDER_BITS: number[];
+/**
+ * Total codewords (data + EC) for each version
+ */
+export declare function getTotalCodewords(version: number): number;
+/**
+ * Version info bit strings for versions 7-40
+ * 18-bit BCH code
+ */
+export declare const VERSION_INFO: number[];
+export {};

package/build/lib/qr-code/core/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * QR Code types and interfaces
+ */
+export type ErrorCorrectionLevel = "L" | "M" | "Q" | "H";
+export type EncodingMode = "numeric" | "alphanumeric" | "byte" | "kanji" | "auto";
+export interface QRCodeOptions {
+    ecLevel?: ErrorCorrectionLevel;
+    version?: number;
+    mode?: EncodingMode;
+    mask?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    micro?: boolean;
+    structuredAppend?: {
+        index: number;
+        total: number;
+        parity: number;
+    };
+}
+export interface QRSegment {
+    mode: "numeric" | "alphanumeric" | "byte" | "kanji" | "eci";
+    data: Uint8Array | string;
+    charCount: number;
+}
+/** EC level indicators: L=01, M=00, Q=11, H=10 */
+export declare const EC_LEVEL_BITS: Record<ErrorCorrectionLevel, number>;
+/** Mode indicators (4 bits) */
+export declare const MODE_INDICATOR: {
+    readonly numeric: 1;
+    readonly alphanumeric: 2;
+    readonly byte: 4;
+    readonly kanji: 8;
+    readonly eci: 7;
+    readonly structuredAppend: 3;
+    readonly fnc1First: 5;
+    readonly fnc1Second: 9;
+    readonly terminator: 0;
+};

package/build/lib/qr-code/core/version.d.ts

@@ -0,0 +1,18 @@
+/**
+ * QR Code version selection
+ * Versions 1-40, size = 4*V + 17 modules per side
+ */
+import type { ErrorCorrectionLevel } from "./types";
+/** Calculate data capacity in bits for a given version and EC level */
+export declare function getDataCapacityBits(version: number, ecLevel: ErrorCorrectionLevel): number;
+/**
+ * Select the smallest QR version that can encode the given data
+ * Returns version number (1-40)
+ */
+export declare function selectVersion(text: string, ecLevel: ErrorCorrectionLevel, mode?: string, requestedVersion?: number): number;
+/** Get the module count (size) for a version */
+export declare function getModuleCount(version: number): number;
+/**
+ * Determine the optimal encoding mode based on data content
+ */
+export declare function selectMode(text: string, requestedMode?: string): "numeric" | "alphanumeric" | "byte" | "kanji";

package/build/lib/qr-code/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * QR Code library
+ */
+import type { QRCodeSVGOptions } from "./types";
+import type { QRCodeOptions } from "./core/types";
+export declare function qrcode(text: string, options?: QRCodeSVGOptions & QRCodeOptions): string;
+export declare function qrcodeTerminal(text: string, options?: QRCodeOptions): string;
+export declare function qrcodeDataURI(text: string, options?: QRCodeSVGOptions & QRCodeOptions): string;
+export declare function qrcodeBase64(text: string, options?: QRCodeSVGOptions & QRCodeOptions): string;
+export { encodeQR } from "./core/index";
+export { encodeMicroQR } from "./core/micro";
+export { renderQRCodeSVG } from "./utilities/svg";
+export { renderText } from "./utilities/text";
+export { svgToDataURI, svgToBase64, svgToBase64Raw } from "./utilities/data-uri";
+export type { QRCodeSVGOptions, DotType, GradientOptions, CornerOptions, LogoOptions, TextRenderOptions, MeasurementUnit, } from "./types";
+export type { QRCodeOptions, ErrorCorrectionLevel, EncodingMode, QRSegment } from "./core/types";
+export type { MicroQROptions } from "./core/micro";

package/build/lib/qr-code/types/index.d.ts

@@ -0,0 +1,65 @@
+export type DotType = "square" | "rounded" | "dots" | "diamond" | "classy" | "classy-rounded" | "extra-rounded" | "vertical-line" | "horizontal-line" | "small-square" | "tiny-square";
+export interface LinearGradientOptions {
+    type: "linear";
+    rotation?: number;
+    stops: Array<{
+        offset: number;
+        color: string;
+    }>;
+}
+export interface RadialGradientOptions {
+    type: "radial";
+    stops: Array<{
+        offset: number;
+        color: string;
+    }>;
+}
+export type GradientOptions = LinearGradientOptions | RadialGradientOptions;
+export interface CornerOptions {
+    outerShape?: "square" | "rounded" | "dots" | "extra-rounded" | "classy";
+    innerShape?: "square" | "dots" | "rounded";
+    outerColor?: string | GradientOptions;
+    innerColor?: string | GradientOptions;
+}
+export interface LogoOptions {
+    svg?: string;
+    path?: string;
+    imageUrl?: string;
+    imageWidth?: number;
+    imageHeight?: number;
+    size?: number;
+    margin?: number;
+    hideBackgroundDots?: boolean;
+    backgroundColor?: string;
+}
+export interface SVGAccessibilityOptions {
+    ariaLabel?: string;
+    role?: string;
+    title?: string;
+    desc?: string;
+}
+export interface QRCodeSVGOptions extends SVGAccessibilityOptions {
+    size?: number;
+    margin?: number;
+    unit?: MeasurementUnit;
+    color?: string | GradientOptions;
+    background?: string | GradientOptions | "transparent";
+    dotType?: DotType;
+    dotSize?: number;
+    shape?: "square" | "circle";
+    corners?: {
+        topLeft?: CornerOptions;
+        topRight?: CornerOptions;
+        bottomLeft?: CornerOptions;
+    };
+    logo?: LogoOptions;
+    xmlDeclaration?: boolean;
+}
+export type MeasurementUnit = "px" | "mm" | "in" | "pt" | "cm";
+export interface TextRenderOptions {
+    dark?: string;
+    light?: string;
+    compact?: boolean;
+    margin?: number;
+    invert?: boolean;
+}

package/build/lib/qr-code/utilities/adler32.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Adler32 checksum for zlib wrapper
+ */
+export declare function adler32(data: Uint8Array): number;

package/build/lib/qr-code/utilities/common.d.ts

@@ -0,0 +1,2 @@
+/** Escape a string for use in SVG/XML attribute values */
+export declare function escapeAttr(value: string): string;

package/build/lib/qr-code/utilities/crc32.d.ts

@@ -0,0 +1,4 @@
+/**
+ * CRC32 for PNG chunk checksums (ISO 3309 / ITU-T V.42)
+ */
+export declare function crc32(data: Uint8Array): number;

package/build/lib/qr-code/utilities/data-uri.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Data URI encoding utilities
+ */
+export declare function svgToDataURI(svg: string): string;
+export declare function svgToBase64(svg: string): string;
+export declare function svgToBase64Raw(svg: string): string;

package/build/lib/qr-code/utilities/deflate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Minimal DEFLATE encoder using stored (uncompressed) blocks
+ * Wrapped in zlib format for PNG IDAT chunks
+ */
+export declare function deflateRaw(data: Uint8Array): Uint8Array;
+export declare function zlibCompress(data: Uint8Array): Uint8Array;

package/build/lib/qr-code/utilities/gradient.d.ts

@@ -0,0 +1,10 @@
+/**
+ * SVG gradient generation
+ */
+import type { GradientOptions } from "../types";
+export declare function resetGradientCounter(): void;
+export declare function isGradient(color: string | GradientOptions | undefined): color is GradientOptions;
+export declare function generateGradientDef(options: GradientOptions): {
+    id: string;
+    svg: string;
+};

package/build/lib/qr-code/utilities/ico.d.ts

@@ -0,0 +1,4 @@
+/**
+ * ICO/BMP to PNG converter for logo embedding
+ */
+export declare function icoToPngDataURI(icoData: Uint8Array): string;

package/build/lib/qr-code/utilities/logo.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Logo embedding in QR codes
+ */
+import type { LogoOptions } from "../types";
+export interface LogoPlacement {
+    svg: string;
+    hiddenModules: Set<string>;
+}
+export declare function calculateLogoPlacement(options: LogoOptions, moduleCount: number, moduleSize: number, margin: number): LogoPlacement;

package/build/lib/qr-code/utilities/png-encoder.d.ts

@@ -0,0 +1,5 @@
+/**
+ * PNG encoder — assembles valid PNG files from pixel data
+ */
+export declare function encodePNG(width: number, height: number, rows: Uint8Array[], fg: [number, number, number], bg: [number, number, number], useUpFilter?: boolean): Uint8Array;
+export declare function encodeTrueColorPNG(width: number, height: number, rgba: Uint8Array): Uint8Array;

package/build/lib/qr-code/utilities/shapes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Module shape generators for QR code SVG rendering
+ */
+import type { DotType } from "../types";
+export declare function getModulePath(x: number, y: number, size: number, dotType: DotType, dotSize?: number): string;
+export declare function getFinderOuterPath(x: number, y: number, moduleSize: number, shape?: string): string;
+export declare function getFinderInnerPath(x: number, y: number, moduleSize: number, shape?: string): string;

package/build/lib/qr-code/utilities/svg.d.ts

@@ -0,0 +1,5 @@
+/**
+ * QR Code SVG renderer with styling support
+ */
+import type { QRCodeSVGOptions } from "../types";
+export declare function renderQRCodeSVG(matrix: boolean[][], options?: QRCodeSVGOptions): string;

package/build/lib/qr-code/utilities/text.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Terminal/text output for QR codes
+ */
+export interface TextRenderOptions {
+    dark?: string;
+    light?: string;
+    compact?: boolean;
+    margin?: number;
+    invert?: boolean;
+}
+export declare function renderText(matrix: boolean[][], options?: TextRenderOptions): string;