@lana-commerce/core 11.0.0

package/types/modules/helpers/hookUpAnalytics.d.ts

@@ -0,0 +1,21 @@
+import { Store } from "effector";
+import type { CanonicalVariantURLFunc } from "../../canonicalVariantURL.js";
+import type { Cart } from "../cart.js";
+import type { CartVariantFragment, CurrencyFragment } from "../../graphql/types.js";
+import type { Dict } from "../../commonTypes.js";
+import type { Search } from "../search.js";
+export interface HookUpAnalyticsArgs {
+    jwt?: Store<string>;
+    cart?: {
+        cartVisible: Store<boolean>;
+        cart: Cart<CartVariantFragment>;
+        analyticsEnv: {
+            cdn: string;
+            shopCurrency: string;
+            shopCurrencies: Dict<CurrencyFragment>;
+            canonicalVariantURL: () => CanonicalVariantURLFunc | null;
+        };
+    };
+    search?: Search<any>;
+}
+export declare function hookUpAnalytics(a: HookUpAnalyticsArgs): void;

package/types/modules/helpers/loadJWT.d.ts

@@ -0,0 +1 @@
+export declare function loadJWT(shopID: string, key: string): string | undefined;

package/types/modules/helpers/misc.d.ts

@@ -0,0 +1,14 @@
+import type Postmate from "postmate";
+import type { Store } from "effector";
+import type { Cart } from "../cart.js";
+import type { ShopLike } from "../../shopDomain.js";
+export declare function saveCartDataToLocalStorage(cart: Cart<any>, idKey: string, uuidKey: string): void;
+export declare function saveJWTToLocalStorage(jwt: Store<string>, key: string, checkoutRemote: Postmate): void;
+export interface MakeCartCheckoutFunctionArgs {
+    cart: Cart<any>;
+    checkoutRemote: Postmate;
+    jwt: Store<string>;
+    shop: string | ShopLike;
+}
+export declare function makeCartCheckoutFunction(a: MakeCartCheckoutFunctionArgs): () => Promise<void>;
+export declare function getNonEmptyStringFromLocalStorage(key: string): string | undefined;

package/types/modules/imageDialog.d.ts

@@ -0,0 +1,31 @@
+import type { RequestResponseData, RequestResponseError } from "../request.js";
+export interface ImageLike {
+    id: string;
+    public_url: string;
+    image_width: number;
+    image_height: number;
+}
+export interface Page<T> {
+    last_key: string;
+    items: T[];
+}
+export interface ImageDialogConfig {
+    cdn: string;
+    images: ImageLike[];
+    position: number;
+    perPage?: number;
+    lastKey?: string;
+    loadMore?: (lastKey: string) => Promise<RequestResponseData<Page<ImageLike>>>;
+}
+export declare function createImageDialog(): {
+    config: import("effector").Store<ImageDialogConfig>;
+    visible: import("effector").Store<boolean>;
+    show: import("effector").Event<ImageDialogConfig>;
+    hide: import("effector").Event<void>;
+    images: import("effector").Store<ImageLike[]>;
+    position: import("effector").Store<number>;
+    setPosition: import("effector").Event<number>;
+    unexpectedError: import("effector").Event<RequestResponseError>;
+    somethingPending: import("effector").Store<boolean>;
+};
+export type ImageDialogStore = ReturnType<typeof createImageDialog>;

package/types/modules/persist.d.ts

@@ -0,0 +1,13 @@
+export interface PersistData<T> {
+    version: number;
+    createdAt: number;
+    data: T;
+}
+export declare function serialize<T>(data: T, version: number): string;
+export declare function deserialize<T>(value: string, version: number, maxAgeMs: number): T | undefined;
+export declare function localStoragePersist(key: string, maxAgeMs?: number): {
+    load: () => string;
+    save: (data: string) => void;
+    onChange: (callback: (data: string) => void) => void;
+    maxAgeMs: number | undefined;
+};

package/types/modules/popupMessage.d.ts

@@ -0,0 +1,9 @@
+import { Event } from "effector";
+export interface MessageState<T> {
+    visible: boolean;
+    message: T;
+}
+export declare function createPopupMessage<Stream, Message>(f: (s: Stream) => Message, defaultMessage: Message, additionalSources?: Event<Stream>[]): {
+    input: Event<Stream>;
+    lastMessage: import("effector").Store<MessageState<Message>>;
+};

package/types/modules/product.d.ts

@@ -0,0 +1,320 @@
+import { Event, Store } from "effector";
+import { AbstractOp, GraphQLOpts, RequestResponseError } from "../request.js";
+import type { AnswerCreate, AnswerModify, FileNoFallbackFragment, ReviewDimensionFragment, ReviewDimensionSetFragment, ReviewSettingsFragment, SearchQuestionsSortBy, SearchReviewsSortBy, StorefrontCustomerVote, StorefrontProductQuestionCreate, StorefrontProductQuestionModify, StorefrontProductReviewCreate, StorefrontProductReviewModify } from "../graphql/types.js";
+import type { Dict } from "../commonTypes.js";
+import type { ResultErrorCode } from "../genericFile.js";
+import { ScoreValue } from "../rdsToInitialScores.js";
+interface SearchPage<T> {
+    count: number;
+    items: (T | null)[] | null;
+}
+interface NullPage<T> {
+    count: number;
+    last_key: string;
+    items: (T | null)[] | null;
+}
+interface Page<T> {
+    last_key: string;
+    items: T[];
+}
+interface ProductTypeReq {
+    id: string;
+    review_dimension_set: ReviewDimensionSetFragment | null;
+}
+interface QuestionTypeReq {
+    id: string;
+    text: string;
+    answers: ({
+        id: string;
+        text: string;
+    } | null)[] | null;
+}
+interface ReviewTypeReq {
+    id: string;
+    recommended: StorefrontCustomerVote;
+    title: string;
+    text: string;
+    scores: {
+        review_dimension: {
+            id: string;
+            name: string;
+        } | null;
+        score: number;
+    }[];
+    image_files: ({
+        id: string;
+        public_url: string;
+    } | null)[] | null;
+}
+type LoadResponse<ProductType, ReviewType, QuestionType> = {
+    products: ProductType[] | null;
+    reviews: SearchPage<ReviewType> | null;
+    questions: SearchPage<QuestionType> | null;
+    ownReviews: Page<ReviewType> | null;
+    ownQuestions: Page<QuestionType> | null;
+    images: NullPage<FileNoFallbackFragment> | null;
+};
+interface ReviewImageFile {
+    uuid: string;
+    id: string;
+    preview: string;
+    public_url: string;
+    status: ResultErrorCode | "ok" | "uploading";
+}
+interface ReviewImageFileUpdate {
+    uuid: string;
+    id?: string;
+    preview?: string;
+    public_url?: string;
+    status?: ResultErrorCode | "ok" | "uploading";
+}
+export interface ProductConfig<ProductType, ReviewType, QuestionType> {
+    readonly graphql: {
+        readonly loadProductQuery: AbstractOp<LoadResponse<ProductType, ReviewType, QuestionType>, {
+            shopID: string;
+            productID: string;
+            customerID: string;
+        }>;
+        readonly loadProductNoCustomerQuery: AbstractOp<{
+            products: ProductType[] | null;
+            reviews: SearchPage<ReviewType> | null;
+            questions: SearchPage<QuestionType> | null;
+            images: NullPage<FileNoFallbackFragment> | null;
+        }, {
+            shopID: string;
+            productID: string;
+        }>;
+        readonly createReviewMutation: AbstractOp<{
+            reviews: ReviewType[] | null;
+        }, {
+            shopID: string;
+            data: StorefrontProductReviewCreate;
+        }>;
+        readonly modifyReviewMutation: AbstractOp<{
+            reviews: ReviewType[] | null;
+        }, {
+            shopID: string;
+            reviewID: string;
+            data: StorefrontProductReviewModify;
+        }>;
+        readonly createQuestionMutation: AbstractOp<{
+            questions: QuestionType[] | null;
+        }, {
+            shopID: string;
+            data: StorefrontProductQuestionCreate;
+        }>;
+        readonly modifyQuestionMutation: AbstractOp<{
+            questions: QuestionType[] | null;
+        }, {
+            shopID: string;
+            questionID: string;
+            data: StorefrontProductQuestionModify;
+        }>;
+        readonly createQuestionAnswerMutation: AbstractOp<{
+            questionAnswers: {
+                id: string;
+            }[] | null;
+        }, {
+            shopID: string;
+            questionID: string;
+            data: AnswerCreate;
+        }>;
+        readonly modifyQuestionAnswerMutation: AbstractOp<{
+            questionAnswers: {
+                id: string;
+            }[] | null;
+        }, {
+            shopID: string;
+            questionID: string;
+            questionAnswerID: string;
+            data: AnswerModify;
+        }>;
+        readonly deleteReviewMutation: AbstractOp<{
+            reviews: boolean | null;
+        }, {
+            shopID: string;
+            reviewID: string;
+        }>;
+        readonly deleteQuestionMutation: AbstractOp<{
+            questions: boolean | null;
+        }, {
+            shopID: string;
+            questionID: string;
+        }>;
+        readonly deleteQuestionAnswerMutation: AbstractOp<{
+            questionAnswers: boolean | null;
+        }, {
+            shopID: string;
+            questionAnswerID: string;
+        }>;
+        readonly voteReviewMutation: AbstractOp<{
+            reviews: boolean | null;
+        }, {
+            shopID: string;
+            reviewID: string;
+            y: boolean;
+            delete?: boolean | null;
+        }>;
+        readonly flagReviewMutation: AbstractOp<{
+            reviews: boolean | null;
+        }, {
+            shopID: string;
+            reviewID: string;
+            delete?: boolean | null;
+        }>;
+        readonly voteQuestionMutation: AbstractOp<{
+            questions: boolean | null;
+        }, {
+            shopID: string;
+            questionID: string;
+            y: boolean;
+            delete?: boolean | null;
+        }>;
+        readonly flagQuestionMutation: AbstractOp<{
+            questions: boolean | null;
+        }, {
+            shopID: string;
+            questionID: string;
+            delete?: boolean | null;
+        }>;
+        readonly voteQuestionAnswerMutation: AbstractOp<{
+            questionAnswers: boolean | null;
+        }, {
+            shopID: string;
+            questionAnswerID: string;
+            y: boolean;
+            delete?: boolean | null;
+        }>;
+        readonly flagQuestionAnswerMutation: AbstractOp<{
+            questionAnswers: boolean | null;
+        }, {
+            shopID: string;
+            questionAnswerID: string;
+            delete?: boolean | null;
+        }>;
+        readonly getReviewQuery: AbstractOp<{
+            reviews: ReviewType[] | null;
+        }, {
+            shopID: string;
+            reviewID: string;
+        }>;
+        readonly getQuestionQuery: AbstractOp<{
+            questions: QuestionType[] | null;
+        }, {
+            shopID: string;
+            questionID: string;
+        }>;
+        readonly searchReviewsQuery: AbstractOp<{
+            reviews: SearchPage<ReviewType> | null;
+        }, {
+            shopID: string;
+            productID: string;
+            offset: number;
+            limit: number;
+            sortBy: SearchReviewsSortBy;
+            sortDesc: boolean;
+            notCustomerID?: string | null;
+        }>;
+        readonly searchQuestionsQuery: AbstractOp<{
+            questions: SearchPage<QuestionType> | null;
+        }, {
+            shopID: string;
+            productID: string;
+            offset: number;
+            limit: number;
+            sortBy: SearchQuestionsSortBy;
+            sortDesc: boolean;
+            notCustomerID?: string | null;
+        }>;
+    };
+    /** Your shop id. */
+    readonly shopID: string;
+    /** These graphql options are applied to all "request" api calls product module does. */
+    readonly opts?: Readonly<GraphQLOpts<any>>;
+    /** Review dimensions of the shop. */
+    readonly reviewDimensions: Dict<ReviewDimensionFragment>;
+    /** Review settings of the shop. */
+    readonly reviewSettings: ReviewSettingsFragment;
+    /** A store that represents current auth state. You should pass it in to keep auth state in-sync. */
+    readonly jwt: Store<string>;
+    /** Current locale. Module will react to its changes. */
+    readonly locale: Store<string>;
+}
+export interface Product<ProductType extends ProductTypeReq, ReviewType extends ReviewTypeReq, QuestionType extends QuestionTypeReq> {
+    signInRequired: Event<void>;
+    message: Event<MessageType>;
+    load: Event<string>;
+    unexpectedError: Event<RequestResponseError>;
+    product: Store<ProductType | null>;
+    images: Store<NullPage<FileNoFallbackFragment> | null>;
+    reviewsSortBy: Store<SearchReviewsSortBy>;
+    reviewsSortDesc: Store<boolean>;
+    setReviewsSortBy: Event<SearchReviewsSortBy>;
+    setReviewsSortDesc: Event<boolean>;
+    reviews: Store<ReviewType[] | null>;
+    questionsSortBy: Store<SearchQuestionsSortBy>;
+    questionsSortDesc: Store<boolean>;
+    setQuestionsSortBy: Event<SearchQuestionsSortBy>;
+    setQuestionsSortDesc: Event<boolean>;
+    questions: Store<QuestionType[] | null>;
+    ownReview: Store<ReviewType | null>;
+    ownQuestions: Store<QuestionType[] | null>;
+    somethingPending: Store<boolean>;
+    forms: ReturnType<typeof createProductForms>;
+    voteReviewYes: Event<string>;
+    voteReviewNo: Event<string>;
+    voteReviewDelete: Event<string>;
+    flagReview: Event<string>;
+    flagReviewDelete: Event<string>;
+    voteQuestionYes: Event<string>;
+    voteQuestionNo: Event<string>;
+    voteQuestionDelete: Event<string>;
+    flagQuestion: Event<string>;
+    flagQuestionDelete: Event<string>;
+    deleteReview: Event<string>;
+    deleteQuestion: Event<string>;
+    deleteQuestionAnswer: Event<[string, string]>;
+    voteQuestionAnswerYes: Event<[string, string]>;
+    voteQuestionAnswerNo: Event<[string, string]>;
+    voteQuestionAnswerDelete: Event<[string, string]>;
+    flagQuestionAnswer: Event<[string, string]>;
+    flagQuestionAnswerDelete: Event<[string, string]>;
+    totalReviews: Store<number>;
+    totalQuestions: Store<number>;
+    canLoadMoreReviews: Store<boolean>;
+    canLoadMoreQuestions: Store<boolean>;
+    loadMoreReviews: Event<void>;
+    loadMoreQuestions: Event<void>;
+}
+declare function createProductForms(everythingIdle: Store<boolean>): {
+    questionForm: import("../effector/form.js").Form<{
+        text: import("../effector/form.js").StringField<[import("../effector/validator.js").Validator<"invalid_non_empty">, import("../effector/validator.js").Validator<"max_length_exceeded">], string>;
+    }>;
+    showQuestionForm: Event<string>;
+    hideQuestionForm: Event<void>;
+    isQuestionFormVisible: Store<string | null>;
+    questionAnswerForm: import("../effector/form.js").Form<{
+        text: import("../effector/form.js").StringField<[import("../effector/validator.js").Validator<"invalid_non_empty">, import("../effector/validator.js").Validator<"max_length_exceeded">], string>;
+    }>;
+    showQuestionAnswerForm: Event<[string, string]>;
+    hideQuestionAnswerForm: Event<void>;
+    isQuestionAnswerFormVisible: Store<[string, string] | null>;
+    reviewForm: import("../effector/form.js").Form<{
+        title: import("../effector/form.js").StringField<[import("../effector/validator.js").Validator<"invalid_non_empty">, import("../effector/validator.js").Validator<"max_length_exceeded">], string>;
+        text: import("../effector/form.js").StringField<[import("../effector/validator.js").Validator<"invalid_non_empty">, import("../effector/validator.js").Validator<"max_length_exceeded">], string>;
+    }>;
+    uploadReviewImageFile: Event<File>;
+    removeReviewImageFile: Event<number>;
+    updateReviewImageFile: Event<ReviewImageFileUpdate>;
+    appendReviewImageFile: Event<ReviewImageFileUpdate>;
+    reviewImageFiles: Store<ReviewImageFile[]>;
+    setReviewScores: Event<ScoreValue[]>;
+    reviewScores: Store<ScoreValue[]>;
+    setReviewRecommended: Event<StorefrontCustomerVote>;
+    reviewRecommended: Store<StorefrontCustomerVote>;
+    isReviewFormVisible: Store<boolean>;
+    toggleReviewFormVisibility: Event<void>;
+};
+export type MessageType = "review_voted_yes" | "review_voted_no" | "review_vote_deleted" | "review_flagged" | "review_unflagged" | "review_created" | "review_modified" | "review_deleted" | "question_vote_deleted" | "question_voted_yes" | "question_voted_no" | "question_unflagged" | "question_flagged" | "question_answer_vote_deleted" | "question_answer_voted_yes" | "question_answer_voted_no" | "question_answer_unflagged" | "question_answer_flagged" | "question_created" | "question_modified" | "question_deleted" | "question_answer_modified" | "question_answer_created" | "question_answer_deleted";
+export declare function createProduct<ProductType extends ProductTypeReq, ReviewType extends ReviewTypeReq, QuestionType extends QuestionTypeReq>(config: ProductConfig<ProductType, ReviewType, QuestionType>): Product<ProductType, ReviewType, QuestionType>;
+export {};

package/types/modules/recentlyVisitedProducts.d.ts

@@ -0,0 +1,25 @@
+import { AbstractOp, GraphQLOpts } from "../request.js";
+export interface ProductLike {
+    id: string;
+}
+export interface RecentlyVisitedProductsConfig<T extends ProductLike> {
+    /** Your shop id. */
+    readonly shopID: string;
+    /** These graphql options are applied to all "request" api calls cart does. */
+    readonly opts?: GraphQLOpts<any>;
+    /** A localStorage key used for storing the recently visited products. */
+    readonly key: string;
+    /** GraphQL operations used by the module. */
+    readonly graphql: {
+        readonly getProductsQuery: AbstractOp<{
+            products: Array<T> | null;
+        }, {
+            shopID: string;
+            ids: string[];
+        }>;
+    };
+}
+export declare function createRecentlyVisitedProducts<T extends ProductLike>(config: RecentlyVisitedProductsConfig<T>): {
+    addRecentlyVisitedProduct: import("effector").Event<string>;
+    recentlyVisitedProducts: import("effector").Store<T[]>;
+};

package/types/modules/search.d.ts

@@ -0,0 +1,54 @@
+import { Event, Store } from "effector";
+import { AbstractOp, GraphQLOpts, RequestResponseError } from "../request.js";
+import type { SearchProductsQueryVariables } from "../graphql/types.js";
+export interface SearchOperationResult<Product> {
+    search: {
+        count: number;
+        items: Array<Product | null> | null;
+    } | null;
+}
+export interface SearchConfig<Product> {
+    readonly graphql: {
+        readonly searchProductsQuery: AbstractOp<SearchOperationResult<Product>, SearchProductsQueryVariables>;
+    };
+    /** Your shop id. */
+    readonly shopID: string;
+    /** These graphql options are applied to all "request" api calls search does. */
+    readonly opts?: Readonly<GraphQLOpts<any>>;
+    /** A store that represents current auth state. You should pass it in to keep auth state in-sync. */
+    readonly jwt: Store<string>;
+    /** Current locale. Module will react to its changes. */
+    readonly locale: Store<string>;
+    /** Persist data across multiple browser tabs (good for multi-page applications). */
+    readonly persist?: {
+        /** Load data from persistent storage. */
+        readonly load: () => string;
+        /** Save data to persistent storage. */
+        readonly save: (data: string) => void;
+        /**
+         * Register a callback that is called when data is changed in persistent storage (only from the outside,
+         * should ignore "save" calls).
+         */
+        readonly onChange: (callback: (data: string) => void) => void;
+        /** If stored data is older than this, it's ignored. In milliseconds. Default: 30 minutes. */
+        readonly maxAgeMs?: number;
+    };
+}
+export type SearchResult<T> = {
+    kind: "not_submitted";
+} | {
+    kind: "error";
+} | {
+    kind: "result";
+    result: T[];
+};
+export interface Search<Product> {
+    clear: Event<void>;
+    unexpectedError: Event<RequestResponseError>;
+    setQuery: Event<string>;
+    query: Store<string>;
+    submit: Event<void>;
+    result: Store<SearchResult<Product>>;
+    pending: Store<boolean>;
+}
+export declare function createSearch<Product>(config: SearchConfig<Product>): Search<Product>;

package/types/multiResponseToResponse.d.ts

@@ -0,0 +1,2 @@
+import { RequestResponseData, RequestResponseMulti } from "./request.js";
+export declare function multiResponseToResponse<T, U>(resp: RequestResponseMulti<T>, f: (data: T) => U, ignoreErrors?: boolean): RequestResponseData<NonNullable<U>>;

package/types/nonNull.d.ts

@@ -0,0 +1 @@
+export declare function nonNull<T>(v: T | null | undefined, msg?: string): T;

package/types/oauthState.d.ts

@@ -0,0 +1,3 @@
+import type { Dict } from "./commonTypes.js";
+export declare function encodeOauthState(kvs: Dict<string>): string;
+export declare function decodeOauthState(state: string): Dict<string>;

package/types/orderShippingAddress.d.ts

@@ -0,0 +1,6 @@
+interface OrderLike<T> {
+    shipping_address: T | null;
+    shipping_address_override?: T | null;
+}
+export declare function orderShippingAddress<T>(o: OrderLike<T>): T | null;
+export {};

package/types/pender.d.ts

@@ -0,0 +1,5 @@
+interface Pender {
+    pending: boolean;
+}
+export declare function pender<T extends (...args: any[]) => Promise<any>>(pender: Pender, f: T): T;
+export {};

package/types/percentageOff.d.ts

@@ -0,0 +1 @@
+export declare function percentageOff(from: number, to: number): number;

package/types/popupConnectQueue.d.ts

@@ -0,0 +1,41 @@
+import * as ss from "superstruct";
+export declare const QueueItemType: ss.Struct<{
+    kind: "success";
+    code: string;
+    state: string;
+} | {
+    kind: "success_oauth1";
+    oauth_token: string;
+    oauth_verifier: string;
+} | {
+    kind: "failure";
+    state: string;
+}, null>;
+export declare const QueueItemArrayType: ss.Struct<({
+    kind: "success";
+    code: string;
+    state: string;
+} | {
+    kind: "success_oauth1";
+    oauth_token: string;
+    oauth_verifier: string;
+} | {
+    kind: "failure";
+    state: string;
+})[], ss.Struct<{
+    kind: "success";
+    code: string;
+    state: string;
+} | {
+    kind: "success_oauth1";
+    oauth_token: string;
+    oauth_verifier: string;
+} | {
+    kind: "failure";
+    state: string;
+}, null>>;
+export type QueueItem = ss.Infer<typeof QueueItemType>;
+export declare const POPUP_CONNECT_QUEUE_KEY: string;
+export declare function addQueueChangeListener(callback: (item: QueueItem) => void): void;
+export declare function removeQueueChangeListener(callback: (item: QueueItem) => void): void;
+export declare function enqueueItem(item: QueueItem): void;

package/types/preact/components/SixDigitInput.d.ts

@@ -0,0 +1,28 @@
+/** @jsx h */
+import { Component, JSX } from "preact";
+interface SixDigitInputProps {
+    value: string;
+    onChange: (v: string) => void;
+    autoFocus?: boolean;
+    onEnteredSixDigits?: () => void;
+    className?: string;
+    inputClassName?: string;
+}
+interface CursorPositionOverride {
+    idx: number;
+    pos: number;
+}
+export declare class SixDigitInput extends Component<SixDigitInputProps> {
+    inputRefs: (HTMLInputElement | null)[];
+    focusedOnce: boolean;
+    cursorOverride: CursorPositionOverride | undefined;
+    cursorKeyDownPos: number;
+    focus(): void;
+    onChangeNth(e: JSX.TargetedEvent<HTMLInputElement>, idx: number): void;
+    onChange(nextValue: string, idx: number, move: number): void;
+    onKeyDownNth(idx: number, e: JSX.TargetedKeyboardEvent<HTMLInputElement>): void;
+    getValue(idx: number): string;
+    componentDidUpdate(): void;
+    render(): JSX.Element;
+}
+export {};

package/types/preact/effector.d.ts

@@ -0,0 +1,8 @@
+import { Store } from "effector";
+export declare function useStore<State>(store: Store<State>): State;
+export declare function useStoreMap<State, Result, Keys extends ReadonlyArray<any>>(configOrStore: {
+    store: Store<State>;
+    keys: Keys;
+    fn(state: State, keys: Keys): Result;
+    updateFilter?: (update: Result, current: Result) => boolean;
+} | Store<State>, separateFn?: (state: State, keys: Keys) => Result): Result;

package/types/preact/transition/CSSTransition.d.ts

@@ -0,0 +1,8 @@
+/** @jsx h */
+import { VNode, h } from "preact";
+import { CommonProps } from "./Transition.js";
+export interface CSSTransitionProps extends CommonProps {
+    classNames: string;
+    children: VNode<any>;
+}
+export declare const CSSTransition: ({ classNames, children, ...rest }: CSSTransitionProps) => h.JSX.Element;

package/types/preact/transition/Transition.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+export interface CommonProps {
+    in?: boolean;
+    appear?: boolean;
+    enter?: boolean;
+    exit?: boolean;
+    duration?: number;
+    alwaysMounted?: boolean;
+    onEnter?: () => void;
+    onEntering?: () => void;
+    onEntered?: () => void;
+    onExit?: () => void;
+    onExiting?: () => void;
+    onExited?: () => void;
+}
+export interface TransitionProps extends CommonProps {
+    children: (state: TransitionState) => JSX.Element | null;
+}
+export interface TransitionState {
+    appear: boolean;
+    appearActive: boolean;
+    appearDone: boolean;
+    enter: boolean;
+    enterActive: boolean;
+    enterDone: boolean;
+    exit: boolean;
+    exitActive: boolean;
+    exitDone: boolean;
+}
+export declare const Transition: ({ in: inProp, appear, enter, exit, duration, alwaysMounted, children, onEnter, onEntering, onEntered, onExit, onExiting, onExited, }: TransitionProps) => JSX.Element | null;

package/types/preact/translateLocalStatic.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { Dict } from "../commonTypes.js";
+import { FArgs, FArgsPrimitives } from "../formatToJSX.js";
+export declare function makeT(perLocaleData: Dict<Dict<string>>): <TArgs extends FArgs>(template: string, ...args: TArgs) => TArgs extends FArgsPrimitives ? string : string | JSX.Element;