Brunobkr/llama.cpp_AlgMor24_github

1import { StoryId } from 'storybook/internal/csf';2import { NormalizedProjectAnnotations, ProjectAnnotations, ComposedStoryFn } from 'storybook/internal/types';3 4/**5 * Actions represent the type of change to a location value.6 */7declare enum Action {8    /**9     * A POP indicates a change to an arbitrary index in the history stack, such10     * as a back or forward navigation. It does not describe the direction of the11     * navigation, only that the current index changed.12     *13     * Note: This is the default action for newly created history objects.14     */15    Pop = "POP",16    /**17     * A PUSH indicates a new entry being added to the history stack, such as when18     * a link is clicked and a new page loads. When this happens, all subsequent19     * entries in the stack are lost.20     */21    Push = "PUSH",22    /**23     * A REPLACE indicates the entry at the current index in the history stack24     * being replaced by a new one.25     */26    Replace = "REPLACE"27}28/**29 * The pathname, search, and hash values of a URL.30 */31interface Path {32    /**33     * A URL pathname, beginning with a /.34     */35    pathname: string;36    /**37     * A URL search string, beginning with a ?.38     */39    search: string;40    /**41     * A URL fragment identifier, beginning with a #.42     */43    hash: string;44}45/**46 * An entry in a history stack. A location contains information about the47 * URL path, as well as possibly some arbitrary state and a key.48 */49interface Location extends Path {50    /**51     * A value of arbitrary data associated with this location.52     */53    state: any;54    /**55     * A unique string associated with this location. May be used to safely store56     * and retrieve data in some other storage API, like `localStorage`.57     *58     * Note: This value is always "default" on the initial location.59     */60    key: string;61}62 63/**64 * Map of routeId -> data returned from a loader/action/error65 */66interface RouteData {67    [routeId: string]: any;68}69declare enum ResultType {70    data = "data",71    deferred = "deferred",72    redirect = "redirect",73    error = "error"74}75/**76 * Successful result from a loader or action77 */78interface SuccessResult {79    type: ResultType.data;80    data: any;81    statusCode?: number;82    headers?: Headers;83}84/**85 * Successful defer() result from a loader or action86 */87interface DeferredResult {88    type: ResultType.deferred;89    deferredData: DeferredData;90    statusCode?: number;91    headers?: Headers;92}93/**94 * Redirect result from a loader or action95 */96interface RedirectResult {97    type: ResultType.redirect;98    status: number;99    location: string;100    revalidate: boolean;101    reloadDocument?: boolean;102}103/**104 * Unsuccessful result from a loader or action105 */106interface ErrorResult {107    type: ResultType.error;108    error: any;109    headers?: Headers;110}111/**112 * Result from a loader or action - potentially successful or unsuccessful113 */114type DataResult = SuccessResult | DeferredResult | RedirectResult | ErrorResult;115type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";116type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;117/**118 * Active navigation/fetcher form methods are exposed in lowercase on the119 * RouterState120 */121type FormMethod = LowerCaseFormMethod;122/**123 * In v7, active navigation/fetcher form methods are exposed in uppercase on the124 * RouterState.  This is to align with the normalization done via fetch().125 */126type V7_FormMethod = UpperCaseFormMethod;127type FormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";128type JsonObject = {129    [Key in string]: JsonValue;130} & {131    [Key in string]?: JsonValue | undefined;132};133type JsonArray = JsonValue[] | readonly JsonValue[];134type JsonPrimitive = string | number | boolean | null;135type JsonValue = JsonPrimitive | JsonObject | JsonArray;136/**137 * @private138 * Internal interface to pass around for action submissions, not intended for139 * external consumption140 */141type Submission = {142    formMethod: FormMethod | V7_FormMethod;143    formAction: string;144    formEncType: FormEncType;145    formData: FormData;146    json: undefined;147    text: undefined;148} | {149    formMethod: FormMethod | V7_FormMethod;150    formAction: string;151    formEncType: FormEncType;152    formData: undefined;153    json: JsonValue;154    text: undefined;155} | {156    formMethod: FormMethod | V7_FormMethod;157    formAction: string;158    formEncType: FormEncType;159    formData: undefined;160    json: undefined;161    text: string;162};163/**164 * @private165 * Arguments passed to route loader/action functions.  Same for now but we keep166 * this as a private implementation detail in case they diverge in the future.167 */168interface DataFunctionArgs {169    request: Request;170    params: Params;171    context?: any;172}173/**174 * Arguments passed to loader functions175 */176interface LoaderFunctionArgs extends DataFunctionArgs {177}178/**179 * Arguments passed to action functions180 */181interface ActionFunctionArgs extends DataFunctionArgs {182}183/**184 * Loaders and actions can return anything except `undefined` (`null` is a185 * valid return value if there is no data to return).  Responses are preferred186 * and will ease any future migration to Remix187 */188type DataFunctionValue = Response | NonNullable<unknown> | null;189/**190 * Route loader function signature191 */192interface LoaderFunction {193    (args: LoaderFunctionArgs): Promise<DataFunctionValue> | DataFunctionValue;194}195/**196 * Route action function signature197 */198interface ActionFunction {199    (args: ActionFunctionArgs): Promise<DataFunctionValue> | DataFunctionValue;200}201/**202 * Route shouldRevalidate function signature.  This runs after any submission203 * (navigation or fetcher), so we flatten the navigation/fetcher submission204 * onto the arguments.  It shouldn't matter whether it came from a navigation205 * or a fetcher, what really matters is the URLs and the formData since loaders206 * have to re-run based on the data models that were potentially mutated.207 */208interface ShouldRevalidateFunction {209    (args: {210        currentUrl: URL;211        currentParams: AgnosticDataRouteMatch["params"];212        nextUrl: URL;213        nextParams: AgnosticDataRouteMatch["params"];214        formMethod?: Submission["formMethod"];215        formAction?: Submission["formAction"];216        formEncType?: Submission["formEncType"];217        text?: Submission["text"];218        formData?: Submission["formData"];219        json?: Submission["json"];220        actionResult?: DataResult;221        defaultShouldRevalidate: boolean;222    }): boolean;223}224/**225 * Keys we cannot change from within a lazy() function. We spread all other keys226 * onto the route. Either they're meaningful to the router, or they'll get227 * ignored.228 */229type ImmutableRouteKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";230type RequireOne<T, Key = keyof T> = Exclude<{231    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;232}[keyof T], undefined>;233/**234 * lazy() function to load a route definition, which can add non-matching235 * related properties to a route236 */237interface LazyRouteFunction<R extends AgnosticRouteObject> {238    (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;239}240/**241 * Base RouteObject with common props shared by all types of routes242 */243type AgnosticBaseRouteObject = {244    caseSensitive?: boolean;245    path?: string;246    id?: string;247    loader?: LoaderFunction;248    action?: ActionFunction;249    hasErrorBoundary?: boolean;250    shouldRevalidate?: ShouldRevalidateFunction;251    handle?: any;252    lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;253};254/**255 * Index routes must not have children256 */257type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {258    children?: undefined;259    index: true;260};261/**262 * Non-index routes may have children, but cannot have index263 */264type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {265    children?: AgnosticRouteObject[];266    index?: false;267};268/**269 * A route object represents a logical route, with (optionally) its child270 * routes organized in a tree-like structure.271 */272type AgnosticRouteObject = AgnosticIndexRouteObject | AgnosticNonIndexRouteObject;273type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {274    id: string;275};276type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {277    children?: AgnosticDataRouteObject[];278    id: string;279};280/**281 * A data route object, which is just a RouteObject with a required unique ID282 */283type AgnosticDataRouteObject = AgnosticDataIndexRouteObject | AgnosticDataNonIndexRouteObject;284/**285 * The parameters that were parsed from the URL path.286 */287type Params<Key extends string = string> = {288    readonly [key in Key]: string | undefined;289};290/**291 * A RouteMatch contains info about how a route matched a URL.292 */293interface AgnosticRouteMatch<ParamKey extends string = string, RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject> {294    /**295     * The names and values of dynamic parameters in the URL.296     */297    params: Params<ParamKey>;298    /**299     * The portion of the URL pathname that was matched.300     */301    pathname: string;302    /**303     * The portion of the URL pathname that was matched before child routes.304     */305    pathnameBase: string;306    /**307     * The route object that was used to match.308     */309    route: RouteObjectType;310}311interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {312}313declare class DeferredData {314    private pendingKeysSet;315    private controller;316    private abortPromise;317    private unlistenAbortSignal;318    private subscribers;319    data: Record<string, unknown>;320    init?: ResponseInit;321    deferredKeys: string[];322    constructor(data: Record<string, unknown>, responseInit?: ResponseInit);323    private trackPromise;324    private onSettle;325    private emit;326    subscribe(fn: (aborted: boolean, settledKey?: string) => void): () => boolean;327    cancel(): void;328    resolveData(signal: AbortSignal): Promise<boolean>;329    get done(): boolean;330    get unwrappedData(): {};331    get pendingKeys(): string[];332}333 334/**335 * State maintained internally by the router.  During a navigation, all states336 * reflect the the "old" location unless otherwise noted.337 */338interface RouterState {339    /**340     * The action of the most recent navigation341     */342    historyAction: Action;343    /**344     * The current location reflected by the router345     */346    location: Location;347    /**348     * The current set of route matches349     */350    matches: AgnosticDataRouteMatch[];351    /**352     * Tracks whether we've completed our initial data load353     */354    initialized: boolean;355    /**356     * Current scroll position we should start at for a new view357     *  - number -> scroll position to restore to358     *  - false -> do not restore scroll at all (used during submissions)359     *  - null -> don't have a saved position, scroll to hash or top of page360     */361    restoreScrollPosition: number | false | null;362    /**363     * Indicate whether this navigation should skip resetting the scroll position364     * if we are unable to restore the scroll position365     */366    preventScrollReset: boolean;367    /**368     * Tracks the state of the current navigation369     */370    navigation: Navigation;371    /**372     * Tracks any in-progress revalidations373     */374    revalidation: RevalidationState;375    /**376     * Data from the loaders for the current matches377     */378    loaderData: RouteData;379    /**380     * Data from the action for the current matches381     */382    actionData: RouteData | null;383    /**384     * Errors caught from loaders for the current matches385     */386    errors: RouteData | null;387    /**388     * Map of current fetchers389     */390    fetchers: Map<string, Fetcher>;391    /**392     * Map of current blockers393     */394    blockers: Map<string, Blocker>;395}396/**397 * Data that can be passed into hydrate a Router from SSR398 */399type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>;400/**401 * Potential states for state.navigation402 */403type NavigationStates = {404    Idle: {405        state: "idle";406        location: undefined;407        formMethod: undefined;408        formAction: undefined;409        formEncType: undefined;410        formData: undefined;411        json: undefined;412        text: undefined;413    };414    Loading: {415        state: "loading";416        location: Location;417        formMethod: Submission["formMethod"] | undefined;418        formAction: Submission["formAction"] | undefined;419        formEncType: Submission["formEncType"] | undefined;420        formData: Submission["formData"] | undefined;421        json: Submission["json"] | undefined;422        text: Submission["text"] | undefined;423    };424    Submitting: {425        state: "submitting";426        location: Location;427        formMethod: Submission["formMethod"];428        formAction: Submission["formAction"];429        formEncType: Submission["formEncType"];430        formData: Submission["formData"];431        json: Submission["json"];432        text: Submission["text"];433    };434};435type Navigation = NavigationStates[keyof NavigationStates];436type RevalidationState = "idle" | "loading";437/**438 * Potential states for fetchers439 */440type FetcherStates<TData = any> = {441    Idle: {442        state: "idle";443        formMethod: undefined;444        formAction: undefined;445        formEncType: undefined;446        text: undefined;447        formData: undefined;448        json: undefined;449        data: TData | undefined;450        " _hasFetcherDoneAnything "?: boolean;451    };452    Loading: {453        state: "loading";454        formMethod: Submission["formMethod"] | undefined;455        formAction: Submission["formAction"] | undefined;456        formEncType: Submission["formEncType"] | undefined;457        text: Submission["text"] | undefined;458        formData: Submission["formData"] | undefined;459        json: Submission["json"] | undefined;460        data: TData | undefined;461        " _hasFetcherDoneAnything "?: boolean;462    };463    Submitting: {464        state: "submitting";465        formMethod: Submission["formMethod"];466        formAction: Submission["formAction"];467        formEncType: Submission["formEncType"];468        text: Submission["text"];469        formData: Submission["formData"];470        json: Submission["json"];471        data: TData | undefined;472        " _hasFetcherDoneAnything "?: boolean;473    };474};475type Fetcher<TData = any> = FetcherStates<TData>[keyof FetcherStates<TData>];476interface BlockerBlocked {477    state: "blocked";478    reset(): void;479    proceed(): void;480    location: Location;481}482interface BlockerUnblocked {483    state: "unblocked";484    reset: undefined;485    proceed: undefined;486    location: undefined;487}488interface BlockerProceeding {489    state: "proceeding";490    reset: undefined;491    proceed: undefined;492    location: Location;493}494type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;495 496/**497 * NOTE: If you refactor this to split up the modules into separate files,498 * you'll need to update the rollup config for react-router-dom-v5-compat.499 */500 501declare global {502    var __staticRouterHydrationData: HydrationState | undefined;503}504 505declare global {506    var globalProjectAnnotations: NormalizedProjectAnnotations<any>;507    var defaultProjectAnnotations: ProjectAnnotations<any>;508}509type WrappedStoryRef = {510    __pw_type: 'jsx';511    props: Record<string, any>;512} | {513    __pw_type: 'importRef';514};515type UnwrappedJSXStoryRef = {516    __pw_type: 'jsx';517    type: UnwrappedImportStoryRef;518};519type UnwrappedImportStoryRef = ComposedStoryFn;520declare global {521    function __pwUnwrapObject(storyRef: WrappedStoryRef): Promise<UnwrappedJSXStoryRef | UnwrappedImportStoryRef>;522}523 524type StatusValue = 'status-value:pending' | 'status-value:success' | 'status-value:new' | 'status-value:modified' | 'status-value:affected' | 'status-value:reviewing' | 'status-value:warning' | 'status-value:error' | 'status-value:unknown';525type StatusTypeId = string;526interface Status {527    value: StatusValue;528    typeId: StatusTypeId;529    storyId: StoryId;530    title: string;531    description: string;532    data?: any;533    sidebarContextMenu?: boolean;534}535 536declare abstract class StorybookError extends Error {537    private _name;538    /** Category of the error. Used to classify the type of error, e.g., 'PREVIEW_API'. */539    readonly category: string;540    /** Code representing the error. Used to uniquely identify the error, e.g., 1. */541    readonly code: number;542    /**543     * Data associated with the error. Used to provide additional information in the error message or544     * to be passed to telemetry.545     */546    readonly data: {};547    /**548     * Specifies the documentation for the error.549     *550     * - If `true`, links to a documentation page on the Storybook website (make sure it exists before551     *   enabling) – This is not implemented yet.552     * - If a string, uses the provided URL for documentation (external or FAQ links).553     * - If `false` (default), no documentation link is added.554     */555    readonly documentation: boolean | string | string[];556    /** Flag used to easily determine if the error originates from Storybook. */557    readonly fromStorybook: true;558    /**559     * Flag used to determine if the error is handled by us and should therefore not be shown to the560     * user.561     */562    isHandledError: boolean;563    get fullErrorCode(): `SB_${string}_${string}`;564    /** Overrides the default `Error.name` property in the format: SB_<CATEGORY>_<CODE>. */565    get name(): string;566    set name(name: string);567    /**568     * A collection of sub errors which relate to a parent error.569     *570     * Sub-errors are used to represent multiple related errors that occurred together. When a571     * StorybookError with sub-errors is sent to telemetry, both the parent error and each sub-error572     * are sent as separate telemetry events. This allows for better error tracking and debugging.573     *574     * @example575     *576     * ```ts577     * const error1 = new SomeError();578     * const error2 = new AnotherError();579     * const parentError = new ParentError({580     *   // ... other props581     *   subErrors: [error1, error2],582     * });583     * ```584     */585    subErrors: StorybookError[];586    constructor(props: {587        category: string;588        code: number;589        message: string;590        cause?: unknown;591        documentation?: boolean | string | string[];592        isHandledError?: boolean;593        name: string;594        /**595         * Optional array of sub-errors that are related to this error. When this error is sent to596         * telemetry, each sub-error will be sent as a separate event.597         */598        subErrors?: StorybookError[];599    });600    /** Generates the error message along with additional documentation link (if applicable). */601    static getFullMessage({ documentation, code, category, message, }: ConstructorParameters<typeof StorybookError>[0]): string;602}603 604/**605 * If you can't find a suitable category for your error, create one based on the package name/file606 * path of which the error is thrown. For instance: If it's from `storybook/internal/client-logger`,607 * then MANAGER_CLIENT-LOGGER608 *609 * Categories are prefixed by a logical grouping, e.g. MANAGER_ to prevent manager and preview610 * errors from having the same category and error code.611 */612declare enum Category {613    MANAGER_UNCAUGHT = "MANAGER_UNCAUGHT",614    MANAGER_UI = "MANAGER_UI",615    MANAGER_API = "MANAGER_API",616    MANAGER_CLIENT_LOGGER = "MANAGER_CLIENT-LOGGER",617    MANAGER_CHANNELS = "MANAGER_CHANNELS",618    MANAGER_CORE_EVENTS = "MANAGER_CORE-EVENTS",619    MANAGER_ROUTER = "MANAGER_ROUTER",620    MANAGER_THEMING = "MANAGER_THEMING",621    MANAGER_UNIVERSAL_STORE = "MANAGER_UNIVERSAL-STORE",622    MANAGER_OPEN_SERVICE = "MANAGER_OPEN-SERVICE"623}624declare class ProviderDoesNotExtendBaseProviderError extends StorybookError {625    constructor();626}627declare class UncaughtManagerError extends StorybookError {628    data: {629        error: Error;630    };631    constructor(data: {632        error: Error;633    });634}635declare class StatusTypeIdMismatchError extends StorybookError {636    data: {637        status: Status;638        typeId: StatusTypeId;639    };640    constructor(data: {641        status: Status;642        typeId: StatusTypeId;643    });644}645declare class UniversalStoreFollowerTimeoutError extends StorybookError {646    constructor(followerId: string);647}648declare class OpenServiceStaticSnapshotLoadError extends StorybookError {649    data: {650        serviceId: string;651        queryName: string;652        input: unknown;653        logicalPath: string;654        url: string;655        cause: unknown;656        status?: number;657        statusText?: string;658    };659    constructor(data: {660        serviceId: string;661        queryName: string;662        input: unknown;663        logicalPath: string;664        url: string;665        cause: unknown;666        status?: number;667        statusText?: string;668    });669}670declare class OpenServiceStaticSnapshotInvalidError extends StorybookError {671    data: {672        serviceId: string;673        queryName: string;674        input: unknown;675        logicalPath: string;676        url: string;677        received: unknown;678    };679    constructor(data: {680        serviceId: string;681        queryName: string;682        input: unknown;683        logicalPath: string;684        url: string;685        received: unknown;686    });687}688 689export { Category, OpenServiceStaticSnapshotInvalidError, OpenServiceStaticSnapshotLoadError, ProviderDoesNotExtendBaseProviderError, StatusTypeIdMismatchError, UncaughtManagerError, UniversalStoreFollowerTimeoutError };690