@redocly/api-docs 0.0.2

package/lib/types/options.d.ts

@@ -0,0 +1,260 @@
+import type { AsyncApiConfig, GraphQLConfig, LayoutVariant, RedocConfig } from '@redocly/config';
+import type { ConfigFunction, Node, Schema } from '@markdoc/markdoc';
+import type { MarkdocTagSchema } from '@redocly/theme/markdoc/tags/types';
+import type { UserClaims } from '@redocly/theme/core/types';
+import type { ConfigureRequestValues, ConfigureServerRequestValues } from '@redocly/theme/ext/configure';
+import type { ReactElement } from 'react';
+import type { ComponentType } from 'react';
+import type { ApiSpecType, SidebarLogo } from './common.js';
+import type { ProtocolVariant } from './asyncapi.js';
+import type { GraphQLOptions } from './graphql.js';
+import type { Events } from './events.js';
+import type { OpenAPIInfo, OpenAPIOperation as OpenAPIOperationType, OpenAPIParameter, OpenAPIServer, OpenAPITag } from './openapi.js';
+import type { Referenced } from './common.js';
+export type Operation = {
+    id: string;
+    path: string;
+    httpVerb: string;
+    name: string;
+};
+export type DownloadUrl = {
+    title?: string;
+    url: string;
+};
+export type NormalizedDownloadUrl = DownloadUrl & {
+    title: string;
+};
+export type ApiDocsMetadata = {
+    title?: string;
+    description?: string | Node[] | Node;
+    summary?: string;
+    version?: string;
+    [key: string]: unknown;
+};
+export type MarkdocOptions = {
+    tags: Record<string, MarkdocTagSchema>;
+    nodes: Record<string, Schema>;
+    components: Record<string, ComponentType<any>>;
+    variables?: Record<string, unknown>;
+    partials?: Record<string, unknown>;
+    functions?: Record<string, ConfigFunction>;
+};
+/**
+ * Turns a raw markdown string into an AST. api-docs core does not bundle a markdown engine — the
+ * host supplies the parser (the standalone build supplies a Markdoc-based one; see
+ * `markdocParser`). It is the single seam where markdown text becomes an AST.
+ */
+export type MarkdownParser = (markdown: string, sanitizeOptions?: Partial<Pick<ApiDocsOptions, 'sanitize' | 'unstable_hooks'>>) => Node | Node[] | undefined;
+export type ApiDocsOptions = {
+    schemaDefinitionsTagName?: string;
+    corsProxyUrl?: string;
+    jsonSamplesExpandLevel: number;
+    generatedSamplesMaxDepth: number;
+    hideDownloadButtons: boolean;
+    hideInfoMetadata: boolean;
+    hideSchemaTitles: boolean;
+    hideSchemaPattern: boolean;
+    maxDisplayedEnumValues: number;
+    hideReplay: boolean;
+    oAuth2RedirectURI?: string;
+    onlyRequiredInSamples: boolean;
+    onDeepLinkClick: ((link: string) => void) | undefined | null;
+    schemasExpansionLevel?: number;
+    sortRequiredPropsFirst: boolean;
+    sanitize: boolean;
+    showExtensions: string[] | boolean;
+    ignoreNamedSchemas: Set<string>;
+    markdocOptions?: MarkdocOptions;
+    markdownParser: MarkdownParser;
+    codeSamples?: CodeSamplesConfig;
+    events: Events;
+    unstable_hooks: HooksConfig;
+    unstable_skipSamples?: boolean;
+    unstable_externalCodeSamples: Unstable_ExternalCodeSample[];
+    hidePropertiesPrefix: boolean;
+    showSchemaCatalogLinks?: boolean;
+    dynamicRequestValues?: ConfigureRequestValues | ConfigureServerRequestValues;
+    userClaims?: UserClaims;
+    protocol?: ProtocolVariant;
+    scrollYOffset: () => number;
+    hideLoading: boolean;
+    skipBundle: boolean;
+    hideSidebar: boolean;
+    basePath: string;
+    specType: ApiSpecType;
+    licenseKey?: string;
+    metadata: ApiDocsMetadata;
+    downloadUrls?: NormalizedDownloadUrl[];
+    layout: LayoutVariant;
+    feedback: NonNullable<RedocConfig['feedback']>;
+    mockServer?: {
+        url: string;
+        position: 'first' | 'last' | 'replace' | 'off';
+        description: string;
+    };
+    apiLogo?: SidebarLogo;
+    jsonSamplesDepth: number;
+    samplesMaxInlineArgs: number;
+    fieldExpandLevel: number;
+    baseUrlPath?: string;
+} & GraphQLOptions;
+export type RawApiDocsOptions = RedocConfig & AsyncApiConfig & GraphQLConfig & {
+    specType: ApiSpecType;
+    markdownParser: MarkdownParser;
+    basePath?: string;
+    hideSchemaPattern?: boolean;
+    requiredPropsFirst?: boolean;
+    licenseKey?: string;
+    protocol?: ProtocolVariant;
+    excludeFromSearch?: boolean;
+    dynamicRequestValues?: ConfigureRequestValues | ConfigureServerRequestValues;
+    userClaims?: UserClaims;
+    layout?: RedocConfig['layout'] | AsyncApiConfig['layout'] | GraphQLConfig['layout'];
+};
+export type Languages = 'JavaScript' | 'Node.js' | 'curl' | 'Java8+Apache' | 'Java' | 'Python' | 'Go' | 'PHP' | 'C#' | 'C#+Newtonsoft' | 'Ruby' | 'R';
+export interface BasicLanguageOptions {
+    indent?: string;
+    withImports?: boolean;
+    withComments?: boolean;
+}
+interface CodeSampleBasicConfig {
+    lang: Languages | 'Payload';
+    label: string;
+    key: string;
+    options?: BasicLanguageOptions;
+}
+export interface CurlCodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'curl';
+    options?: BasicLanguageOptions & {
+        binary?: boolean;
+    };
+}
+export interface JavaScriptCodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'JavaScript';
+    options?: BasicLanguageOptions & {
+        credentials?: 'omit' | 'same-origin' | 'include';
+    };
+}
+export interface GoCodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'Go';
+}
+export interface NodeJsCodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'Node.js';
+}
+export interface PythonCodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'Python';
+}
+export interface Java8CodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'Java8+Apache';
+}
+export interface JavaCodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'Java';
+}
+export interface CSharpCodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'C#';
+}
+export interface CSharpNewtonsoftCodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'C#+Newtonsoft';
+}
+export interface PHPCodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'PHP';
+}
+export interface RubyCodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'Ruby';
+}
+export interface RCodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'R';
+}
+export interface PayloadCodeSampleConfig extends CodeSampleBasicConfig {
+    lang: 'Payload';
+}
+export interface CustomLanguageCodeSampleConfig extends Omit<CodeSampleBasicConfig, 'lang'> {
+    lang: string;
+}
+export type CodeSampleConfig = CurlCodeSampleConfig | JavaScriptCodeSampleConfig | NodeJsCodeSampleConfig | PythonCodeSampleConfig | Java8CodeSampleConfig | JavaCodeSampleConfig | CSharpCodeSampleConfig | CSharpNewtonsoftCodeSampleConfig | PHPCodeSampleConfig | GoCodeSampleConfig | RubyCodeSampleConfig | RCodeSampleConfig;
+export interface CodeSamplesConfig {
+    languages: (CodeSampleConfig | PayloadCodeSampleConfig | CustomLanguageCodeSampleConfig)[];
+    skipOptionalParameters?: boolean;
+    withOAuth2Call?: boolean;
+    onSampleTabClick?: (label: string) => void;
+}
+export type Normalized<T> = {
+    [P in keyof T]-?: T[P];
+};
+export type ExternalLink = ExternalLinkLink | ExternalLinkSeparator;
+export type ExternalLinkLink = {
+    label: string;
+    link: string;
+    target?: string;
+    separatorLine?: boolean;
+};
+export type ExternalLinkSeparator = {
+    separator?: string;
+    separatorLine?: boolean;
+};
+export type MenuItemGroupType = 'group' | 'tag' | 'section' | 'schema' | 'tool' | 'rsrc' | 'prompt';
+export type MenuItemType = MenuItemGroupType | 'operation';
+export type TagInfo = OpenAPITag & {
+    operations: ExtendedOpenAPIOperation[];
+    used?: boolean;
+    schemaRendersInTag?: boolean;
+    isSchema?: boolean;
+};
+export type ExtendedOpenAPIOperation = {
+    pointer: string;
+    pathName: string;
+    httpVerb: string;
+    pathParameters: Array<Referenced<OpenAPIParameter>>;
+    pathServers: Array<OpenAPIServer> | undefined;
+    isWebhook: boolean;
+    isAdditionalOperation: boolean;
+    defaultSampleName?: string | false;
+    keywords?: unknown;
+} & OpenAPIOperationType;
+export type TagsInfoMap = Record<string, TagInfo>;
+export type TagGroup = {
+    name: string;
+    tags: string[];
+};
+export type Unstable_ExternalCodeSample = {
+    get: (source: ExternalSource) => string;
+};
+export type ExternalSource = {
+    sample: Unstable_ExternalCodeSample;
+    operation: unknown;
+    exampleName?: string;
+    pathParams?: unknown;
+    properties?: unknown;
+};
+export type HookRawHtml = {
+    html: string;
+};
+type HookResult = ReactElement | HookRawHtml | null;
+export type HookConfig<T> = (props: T) => HookResult;
+export type HooksConfig = {
+    AfterApiTitle?: HookConfig<{
+        info: OpenAPIInfo;
+    }>;
+    BeforeOperation?: HookConfig<{
+        operation: unknown;
+    }>;
+    BeforeOperationSummary?: HookConfig<{
+        operation: unknown;
+    }>;
+    AfterOperationSummary?: HookConfig<{
+        operation: unknown;
+    }>;
+    AfterOperation?: HookConfig<{
+        operation: unknown;
+    }>;
+    onInit?: (args: {
+        store: Record<string, unknown>;
+    }) => void;
+    replaceSecurityLink?: (args: {
+        securityRequirementId: string;
+    }) => string;
+    sanitize?: (raw: string) => string;
+    MiddlePanelFooter?: HookConfig<undefined>;
+    MiddlePanelHeader?: HookConfig<undefined>;
+};
+export {};

package/lib/types/pluggable.d.ts

@@ -0,0 +1,4 @@
+export type OneOfChangeParams = {
+    pointer: string;
+    index: number;
+};

package/lib/types/schema.d.ts

@@ -0,0 +1,155 @@
+import type { Node } from '@markdoc/markdoc';
+import type { AsyncApiDefinition } from './asyncapi';
+import type { ObjectValues } from './common';
+import type { OpenAPIDefinition } from './openapi';
+export type DiscriminatorObject = {
+    propertyName?: string;
+    mapping?: Record<string, string>;
+    defaultMapping?: string;
+    'x-explicitMappingOnly'?: boolean;
+};
+export type SchemaNode = {
+    type?: string | string[];
+    format?: string;
+    title?: string;
+    description?: string | Node | Node[];
+    pattern?: string;
+    default?: unknown;
+    example?: unknown;
+    const?: unknown;
+    enum?: string[];
+    deprecated?: boolean;
+    nullable?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number | boolean;
+    exclusiveMaximum?: number | boolean;
+    multipleOf?: number;
+    minLength?: number;
+    maxLength?: number;
+    contentEncoding?: string;
+    contentMediaType?: string;
+    properties?: Record<string, SchemaNode>;
+    additionalProperties?: SchemaNode | boolean;
+    unevaluatedProperties?: SchemaNode | boolean;
+    patternProperties?: Record<string, SchemaNode>;
+    required?: string[];
+    minProperties?: number;
+    maxProperties?: number;
+    items?: SchemaNode | SchemaNode[] | boolean;
+    prefixItems?: SchemaNode[];
+    additionalItems?: SchemaNode | boolean;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    oneOf?: SchemaNode[];
+    anyOf?: SchemaNode[];
+    allOf?: SchemaNode[];
+    if?: SchemaNode;
+    then?: SchemaNode;
+    else?: SchemaNode;
+    discriminator?: DiscriminatorObject;
+    $ref?: string;
+    externalDocs?: {
+        url?: string;
+        description?: string;
+    };
+    'x-circular-ref'?: boolean;
+    'x-complex'?: boolean;
+    'x-nullable'?: boolean;
+    'x-original-ref'?: string;
+    'x-badges'?: BadgeType[];
+    'x-enumDescriptions'?: Record<string, string | Node | Node[]>;
+    'x-additionalPropertiesName'?: string;
+    'x-discriminator'?: DiscriminatorObject;
+    'x-displayName'?: string;
+    'x-parentRefs'?: string[];
+    'x-refsStack'?: string[];
+    [key: string]: unknown;
+};
+export type AccessMode = 'read-only' | 'write-only' | undefined;
+export type Document = OpenAPIDefinition | AsyncApiDefinition;
+export declare function isSchemaNode(value: unknown): value is SchemaNode;
+export declare function isStructuredExample(example: unknown): example is object;
+export type PropertyType = {
+    type: string;
+    title?: string;
+    schemaName?: string;
+    isAdditionalProperty?: boolean;
+    isAdditionalItems?: boolean;
+    isTupleItem?: boolean;
+    isPatternProperty?: boolean;
+    isCircular?: boolean;
+    isComplex?: boolean;
+    isExpandable?: boolean;
+    isRequired?: boolean;
+    isDeprecated?: boolean;
+    description?: string | Node | Node[];
+    pattern?: string;
+    example?: string | object;
+    badges?: BadgeType[];
+    default?: string;
+    accessMode?: AccessMode;
+    enum?: Record<string, string | Node | Node[]> | string[];
+    examples?: Record<string, ExampleType>;
+    extensions?: Record<string, string>;
+    externalDocs?: ExternalDocsType;
+    const?: string;
+    properties?: Record<string, PropertyType>;
+    items?: PropertyType[];
+    switcher?: SwitcherType;
+};
+export type BadgeType = {
+    name: string;
+    position: 'before' | 'after';
+    color: string;
+};
+export type ExampleType = {
+    summary?: string;
+    description?: string;
+    value?: string;
+};
+export type ExternalDocsType = {
+    description: string;
+    url: string;
+};
+export declare const switcherLabel: {
+    readonly DISCRIMINATOR: 'Discriminator';
+    readonly ONE_OF: 'One of:';
+    readonly ANY_OF: 'Any of:';
+};
+export type SwitcherLabel = ObjectValues<typeof switcherLabel>;
+export type SwitcherType = {
+    type: 'discriminator' | 'oneOf';
+    label: SwitcherLabel;
+    propertyName?: string;
+    jsonPointer?: string;
+    options: Record<string, SwitcherOptionType>;
+};
+export type SwitcherOptionType = {
+    isDeprecated: boolean;
+    isDefaultMapping: boolean;
+    isCircular?: boolean;
+    description?: string | Node | Node[];
+    constraints?: string[];
+    properties?: Record<string, PropertyType>;
+    items?: PropertyType[];
+    switcher?: SwitcherType;
+    typeLabel?: string;
+    title?: string;
+    schemaName?: string;
+    accessMode?: AccessMode;
+    enum?: Record<string, string | Node | Node[]> | string[];
+};
+export type SchemaProcessorDialect = {
+    readonly id: string;
+    process(schema: SchemaNode, document: Document, options?: SchemaProcessorOptions): PropertyType;
+};
+export type SchemaProcessorOptions = {
+    dialectId?: string;
+    rootJsonPointer?: string;
+    exampleSerializer?: (value: unknown) => string;
+    sortRequiredPropsFirst?: boolean;
+};

package/lib/types/schema.js

@@ -0,0 +1 @@
+function t(r){return r!==null&&typeof r=="object"&&!Array.isArray(r)}function o(r){return typeof r=="object"&&r!==null}const e={DISCRIMINATOR:"Discriminator",ONE_OF:"One of:",ANY_OF:"Any of:"};export{t as isSchemaNode,o as isStructuredExample,e as switcherLabel};

package/lib/types/store.d.ts

@@ -0,0 +1,182 @@
+import type { ResolvedNavItem, REDOCLY_TEAMS_RBAC } from '@redocly/config';
+import type { DocumentNode } from 'graphql';
+import type { Node } from '@markdoc/markdoc';
+import type { ApiSpecType, Badge, BadgeData, ContentType, ItemVariant, SecuritySchemeIn, SecuritySchemeType, ServerData, SeoData, SidebarLogo } from './common.js';
+import type { McpTool, McpResource, McpPrompt, OpenAPIDefinition } from './openapi.js';
+import type { AsyncApiDefinition } from './asyncapi.js';
+import type { ApiDocsOptions } from './options.js';
+import type { ContentNode } from './content.js';
+import type { SchemaKind } from './common.js';
+import type { GraphqlStoreMeta } from './graphql-store.js';
+export type AdapterBuildContextInput = {
+    options: ApiDocsOptions;
+    basePath: string;
+};
+export type ApiDocAdapterProps = {
+    type: ApiSpecType;
+    document: OpenAPIDefinition | AsyncApiDefinition | DocumentNode;
+    options: ApiDocsOptions;
+    basePath: string;
+};
+export type StoreContext = {
+    schemaStore: Record<string, SchemaEntry>;
+    exampleStore: Record<string, ExampleEntry>;
+    securitySchemeStore: Record<string, SecuritySchemeEntry>;
+    hashIndex: Record<string, string>;
+    document: Record<string, unknown>;
+};
+export type ApiItemContent = {
+    contentType: ContentType;
+    seo?: SeoData;
+    itemVariant?: ItemVariant;
+    meta?: ItemMeta;
+    children: ContentNode[];
+    showDivider?: boolean;
+};
+export type BreadcrumbItem = {
+    label: string;
+};
+export type ItemMeta = {
+    sourceId?: string;
+    name?: string;
+    deprecated?: boolean;
+    isWebhook?: boolean;
+    hasSamples?: boolean;
+    badges?: BadgeData[];
+    pointer?: string;
+    position?: {
+        start: {
+            lineNumber: number;
+            column: number;
+        };
+        end?: {
+            lineNumber: number;
+            column: number;
+        };
+    };
+    protocolTag?: {
+        label: string;
+        color: string;
+    };
+    breadcrumbs?: BreadcrumbItem[];
+    action?: 'send' | 'receive';
+    actionLabel?: string;
+    channelBindings?: Record<string, unknown>;
+    returnType?: string;
+};
+export type ApiItem = ResolvedNavItem & {
+    content: ApiItemContent | null;
+    httpVerb?: string;
+};
+export type SchemaEntry = {
+    id: string;
+    kind: SchemaKind;
+    title?: string;
+    data: Record<string, unknown>;
+    [REDOCLY_TEAMS_RBAC]?: Record<string, string>;
+};
+export type ExampleEntry = {
+    id: string;
+    value: unknown;
+    key?: string;
+    summary?: string;
+    description?: string;
+    mediaType?: string;
+    externalValue?: string;
+    [REDOCLY_TEAMS_RBAC]?: Record<string, string>;
+};
+export type OAuthFlowEntry = {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    deviceAuthorizationUrl?: string;
+    scopes?: Record<string, string>;
+};
+export type OAuthFlowsData = {
+    implicit?: {
+        authorizationUrl?: string;
+        refreshUrl?: string;
+        scopes: Record<string, string>;
+    };
+    password?: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: Record<string, string>;
+    };
+    clientCredentials?: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: Record<string, string>;
+        'x-assertionType'?: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer';
+    };
+    authorizationCode?: {
+        authorizationUrl: string;
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: Record<string, string>;
+        'x-usePkce'?: boolean;
+    };
+    deviceAuthorization?: {
+        deviceAuthorizationUrl: string;
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: Record<string, string>;
+        'x-defaultClientId'?: string;
+    };
+};
+export type SecuritySchemeCredentials = {
+    'x-defaultAccessToken'?: string;
+    'x-defaultTokenType'?: string;
+    'x-defaultClientId'?: string;
+    'x-defaultClientSecret'?: string;
+    'x-defaultUsername'?: string;
+    'x-defaultPassword'?: string;
+    scopes?: string[];
+};
+export type SecuritySchemeEntry = {
+    id: string;
+    type: SecuritySchemeType;
+    scheme?: string;
+    bearerFormat?: string;
+    description?: string | Node[] | Node;
+    in?: SecuritySchemeIn;
+    paramName?: string;
+    openIdConnectUrl?: string;
+    deprecated?: boolean;
+    oauth2MetadataUrl?: string;
+    'x-defaultClientId'?: string;
+    'x-defaultAccessToken'?: string;
+    'x-defaultTokenType'?: string;
+    'x-defaultClientSecret'?: string;
+    'x-defaultUsername'?: string;
+    'x-defaultPassword'?: string;
+    serverValues?: Record<string, SecuritySchemeCredentials>;
+    flows?: OAuthFlowsData;
+    [REDOCLY_TEAMS_RBAC]?: Record<string, string>;
+};
+export type GroupItem = {
+    title: string;
+    summary?: string;
+    prefix?: Badge;
+    badges?: Badge[];
+    link: string;
+    deprecated: boolean;
+    childTag?: boolean;
+    [REDOCLY_TEAMS_RBAC]?: Record<string, string>;
+};
+export type McpData = {
+    tools?: McpTool[];
+    resources?: McpResource[];
+    prompts?: McpPrompt[];
+};
+export type ApiStore = {
+    schemaStore: Record<string, SchemaEntry>;
+    exampleStore: Record<string, ExampleEntry>;
+    securitySchemeStore: Record<string, SecuritySchemeEntry>;
+    graphqlMeta?: GraphqlStoreMeta;
+    servers?: ServerData[];
+    mcp?: McpData;
+    schemaCatalogLink?: string;
+    /** From OpenAPI `info.x-logo`. Rendered by the standalone sidebar. */
+    logo?: SidebarLogo;
+};

package/lib/utils/calculateMaxLength.d.ts

@@ -0,0 +1,6 @@
+type Breadcrumb = {
+    name: string;
+    href: string;
+};
+export declare function calculateMaxLength(breadcrumbs: Breadcrumb[], availableWidth: number, isCollapsed: boolean, measureEl: HTMLElement): number;
+export {};

package/lib/utils/calculateMaxLength.js

@@ -0,0 +1 @@
+import{trimText as s}from"@redocly/theme/core/openapi";const e=10,m=40;function T(n,l,c,o){if(!n.length||l<=0)return e;const x=Math.max(0,l-(c?m:0));o.textContent="/";const r=o.scrollWidth,W=(n.length-1)*r,d=Math.max(...n.map(t=>t.name.length),e);let h=e,i=d,a=e;for(;h<=i;){const t=Math.floor((h+i)/2);n.reduce((f,g)=>(o.textContent=s(g.name,t),f+o.scrollWidth),0)+W<=x?(a=t,h=t+1):i=t-1}return a}export{T as calculateMaxLength};

package/lib/utils/compose.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentType, FC } from 'react';
+type HOC<P> = (Component: ComponentType<P>) => FC<P>;
+export declare function compose<P>(f: HOC<P>): (Component: ComponentType<P>) => FC<P>;
+export declare function compose<P>(f: HOC<P>, g: HOC<P>): (Component: ComponentType<P>) => FC<P>;
+export declare function compose<P>(f: HOC<P>, g: HOC<P>, h: HOC<P>): (Component: ComponentType<P>) => FC<P>;
+export declare function compose<P>(f: HOC<P>, g: HOC<P>, h: HOC<P>, i: HOC<P>): (Component: ComponentType<P>) => FC<P>;
+export {};

package/lib/utils/compose.js

@@ -0,0 +1 @@
+function c(...e){return o=>e.reduceRight((r,t)=>t(r),o)}export{c as compose};

package/lib/utils/cookies.d.ts

@@ -0,0 +1,7 @@
+export declare function setCookie(name: string | number | boolean, value: string, attributes?: {
+    [x: string]: string | number | Date | boolean;
+}): string | undefined;
+export declare function getCookie(name: string, serverString?: string): string;
+export declare function removeCookie(name: string, attributes?: {
+    [x: string]: string | number | Date | boolean;
+}): void;

package/lib/utils/cookies.js

@@ -0,0 +1 @@
+import{tryDecodeURIComponent as r}from"./string.js";function s(e,c,o={path:"/"}){if(typeof document>"u")return;typeof o.expires=="number"&&(o.expires=new Date(Date.now()+o.expires*864e5)),o.expires&&(o.expires=o.expires instanceof Date?o.expires.toUTCString():o.expires),e=encodeURIComponent(e).replace(/%(2[346B]|5E|60|7C)/g,r).replace(/[()]/g,escape);let i="";for(const n in o)o[n]&&(i+="; "+n,o[n]!==!0&&(i+="="+String(o[n]).split(";")[0]));return document.cookie=e+"="+g(c)+i}function u(e,c){const o=typeof document<"u"?document.cookie:c,i=o?o.split("; "):[],n={};for(let p=0;p<i.length;p++){const f=i[p].split("="),d=f.slice(1).join("=");try{const t=r(f[0]);if(t in n||(n[t]=x(d)),e===t)break}catch{}}return e?n[e]:""}function C(e,c={path:"/"}){s(e,"",{...c,expires:-1})}function x(e){return e[0]==='"'&&(e=e.slice(1,-1)),e.replace(/(%[\dA-F]{2})+/gi,r)}function g(e){return encodeURIComponent(e).replace(/%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,r)}export{u as getCookie,C as removeCookie,s as setCookie};