@storecraft/dashboard 1.0.0

package/dist/lib/src/apps/gallery/gallery-image-grid.d.ts

@@ -0,0 +1,30 @@
+export function Image({ data, onClickImage, className, ...rest }: ImageParams): import("react").JSX.Element;
+export default ImageGrid;
+export type InternalImageParams = {
+    data: import('@storecraft/core/v-api').ImageType;
+    onClickImage: (e: React.MouseEvent<HTMLAnchorElement, MouseEvent>, data: import('@storecraft/core/v-api').ImageType) => void;
+    className?: string;
+};
+export type ImageParams = InternalImageParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+export type InternalImageGridParams = {
+    images: import('@storecraft/core/v-api').ImageType[];
+    onClickImage: (e: React.MouseEvent<HTMLAnchorElement, MouseEvent>, data: import('@storecraft/core/v-api').ImageType) => void;
+    className?: string;
+};
+export type ImageGridParams = InternalImageGridParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+/**
+ * @typedef {object} InternalImageGridParams
+ * @prop {import('@storecraft/core/v-api').ImageType[]} images
+ * @prop {(
+ *  e: React.MouseEvent<HTMLAnchorElement, MouseEvent>,
+ *  data: import('@storecraft/core/v-api').ImageType
+ * ) => void} onClickImage
+ * @prop {string} [className]
+ *
+ * @typedef {InternalImageGridParams &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } ImageGridParams
+ *
+ * @param {ImageGridParams} params
+ */
+declare function ImageGrid({ images, onClickImage, className, ...rest }: ImageGridParams): import("react").JSX.Element;

package/dist/lib/src/apps/gallery/gallery-page.d.ts

@@ -0,0 +1,2 @@
+declare function _default({}: {}): import("react").JSX.Element;
+export default _default;

package/dist/lib/src/apps/gallery/gallery-searchbar.d.ts

@@ -0,0 +1,17 @@
+export default SearchBar;
+export type InnerSearchBarParams = {
+    count: number;
+    searchTitle: string;
+    isLoading: boolean;
+    reload: () => void;
+};
+export type ImpInterface = {
+    getSearch: () => string;
+    setSearch: (value: string) => void;
+};
+/**
+ * @typedef {object} ImpInterface
+ * @prop {() => string} getSearch
+ * @prop {(value: string) => void} setSearch
+ */
+declare const SearchBar: import('react').ForwardRefExoticComponent<Omit<InnerSearchBarParams & import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement>, "ref"> & import('react').RefAttributes<any>>;

package/dist/lib/src/apps/gallery/gallery-select.d.ts

@@ -0,0 +1,7 @@
+export default GallerySelect;
+export type ImpInterface = any;
+export type GallerySelectParams = {
+    query_params?: import('@storecraft/core/v-api').ApiQuery;
+    onSelect: (img: import('@storecraft/core/v-api').ImageType) => void;
+};
+declare const GallerySelect: import('react').ForwardRefExoticComponent<GallerySelectParams & import('react').RefAttributes<any>>;

package/dist/lib/src/apps/gallery/gallery.d.ts

@@ -0,0 +1,56 @@
+export default Gallery;
+/**
+ * A `gallery` component. if contstrained on height, then image-grid
+ * will be scrollable
+ *
+ * Two modes of retrieving search:
+ * 1. onSearchUpdate=undefined will cause the comp to internally
+ *    fetch data when user searches data
+ * 2. onSearchUpdate!=undefined will cause the comp to delegate
+ *    the search params outside, where you can redirect again,
+ *    this is useful for re-routing of all kinds
+ */
+export type InnerGalleryParams = {
+    /**
+     * { vql: '', limit: 5}
+     */
+    query_params?: import('@storecraft/core/v-api').ApiQuery;
+    onClickImage?: (e: React.MouseEvent<HTMLAnchorElement, MouseEvent>, data: import('@storecraft/core/v-api').ImageType) => void;
+    /**
+     * Use url navigation
+     * to paginate through search params, as opposed to in-memory. This
+     * is suited for pages, the later for individual components.
+     */
+    useSearchParamsForQuery?: boolean;
+};
+/**
+ * A `gallery` component. if contstrained on height, then image-grid
+ * will be scrollable
+ *
+ * Two modes of retrieving search:
+ * 1. onSearchUpdate=undefined will cause the comp to internally
+ *    fetch data when user searches data
+ * 2. onSearchUpdate!=undefined will cause the comp to delegate
+ *    the search params outside, where you can redirect again,
+ *    this is useful for re-routing of all kinds
+ *
+ *
+ * @typedef {object} InnerGalleryParams
+ * @prop {import('@storecraft/core/v-api').ApiQuery
+ * } [query_params={}] { vql: '', limit: 5}
+ * @prop {(
+ *  e: React.MouseEvent<HTMLAnchorElement, MouseEvent>,
+ *  data: import('@storecraft/core/v-api').ImageType
+ * ) => void} [onClickImage]
+ * @prop {boolean} [useSearchParamsForQuery=true] Use url navigation
+ * to paginate through search params, as opposed to in-memory. This
+ * is suited for pages, the later for individual components.
+ *
+ *
+ * @param {InnerGalleryParams &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } params
+ *
+ *
+ */
+declare function Gallery({ query_params, onClickImage, useSearchParamsForQuery, className, ...rest }: InnerGalleryParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>): import("react").JSX.Element;

package/dist/lib/src/apps/gallery/image-header.d.ts

@@ -0,0 +1,18 @@
+export default Header;
+export type InnerHeaderParams = {
+    label: string;
+    Icon: React.FC<{
+        className: string;
+    }>;
+};
+/**
+ * @typedef {object} InnerHeaderParams
+ * @prop {string} label
+ * @prop {React.FC<{ className: string }>} Icon
+ *
+ * @param {InnerHeaderParams &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>
+ * } params
+ *
+ */
+declare function Header({ label, Icon, className, ...rest }: InnerHeaderParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>): import("react").JSX.Element;

package/dist/lib/src/apps/gallery/image-page.d.ts

@@ -0,0 +1,16 @@
+export default ImagePage;
+export type InnerLabelCapsuleParams = {
+    value: string;
+    label?: string | ((value: string) => string);
+    bgColor?: string | ((value: string) => string);
+};
+export type InnerTagsParams = {
+    search: string[];
+};
+export type InnerUsageParams = {
+    usage: string[];
+};
+/**
+ *
+ */
+declare function ImagePage({}: {}): import("react").JSX.Element;

package/dist/lib/src/apps/gallery/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/src/apps/gallery/utils.d.ts

@@ -0,0 +1,2 @@
+export function q2o(q: any, base: any): any;
+export function o2q(o: any): string;

package/dist/lib/src/apps/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Gallery } from './gallery/gallery-page.jsx';
+export { default as ImagePage } from './gallery/image-page.jsx';

package/dist/lib/src/auto-mount.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/src/comps/action-bar.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+export default ActionBar;
+export type InternalActionBarParams = {
+    menuOpen?: boolean;
+    className?: string;
+    onMenuClick?: React.MouseEventHandler;
+};
+export type ActionBarParams = InternalActionBarParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+/**
+ *
+ * @typedef {object} InternalActionBarParams
+ * @prop {boolean} [menuOpen]
+ * @prop {string} [className]
+ * @prop {React.MouseEventHandler} [onMenuClick]
+ *
+ *
+ * @typedef {InternalActionBarParams &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>
+ * } ActionBarParams
+ *
+ *
+ * @param {ActionBarParams} params
+ *
+ */
+declare function ActionBar({ menuOpen, className, onMenuClick, ...rest }: ActionBarParams): React.JSX.Element;

package/dist/lib/src/comps/attributes.d.ts

@@ -0,0 +1,16 @@
+export default Attributes;
+export type InnerAttrParams = {
+    attribute: import('@storecraft/core/v-api').AttributeType;
+    onChange: (attribute: import('@storecraft/core/v-api').AttributeType) => void;
+    onDelete: () => void;
+};
+export type AttributesParams = import('./fields-view.jsx').FieldLeafViewParams<import('@storecraft/core/v-api').AttributeType[]> & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+/**
+ * @typedef {import('./fields-view.jsx').FieldLeafViewParams<
+ *  import('@storecraft/core/v-api').AttributeType[]> &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } AttributesParams
+ *
+ * @param {AttributesParams} params
+ */
+declare function Attributes({ field, value, onChange, ...rest }: AttributesParams): import("react").JSX.Element;

package/dist/lib/src/comps/base-chart-view.d.ts

@@ -0,0 +1,20 @@
+export default BaseChartView;
+export type InnerBaseChartViewParams = {
+    config: import('chart.js').ChartConfiguration;
+};
+export type BaseChartViewParams = InnerBaseChartViewParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+/**
+ *
+ * @typedef {object} InnerBaseChartViewParams
+ * @prop {import('chart.js').ChartConfiguration<>} config
+ *
+ *
+ * @typedef {InnerBaseChartViewParams &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } BaseChartViewParams
+ *
+ *
+ * @param {BaseChartViewParams} params
+ *
+ */
+declare function BaseChartView({ config, ...rest }: BaseChartViewParams): import("react").JSX.Element;

package/dist/lib/src/comps/bulk-tag-products-in-collection.d.ts

@@ -0,0 +1,5 @@
+export default BulkTagProductsInCollection;
+declare function BulkTagProductsInCollection({ collectionId, value }: {
+    collectionId: any;
+    value: any;
+}): import("react").JSX.Element;

package/dist/lib/src/comps/capsule.d.ts

@@ -0,0 +1,8 @@
+export function LabelCapsule({ value, className, label, bgColor, ...rest }: CapsuleParams): import("react").JSX.Element;
+export type InternalCapsuleParams = {
+    className?: string;
+    bgColor?: string | ((v: string) => string);
+    value: string;
+    label?: string | ((v: string) => string);
+};
+export type CapsuleParams = InternalCapsuleParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;

package/dist/lib/src/comps/capsules-view.d.ts

@@ -0,0 +1,27 @@
+export default CapsulesView;
+export type CapsulesViewParams<T = any> = {
+    tags: T[];
+    name_fn?: (x: T) => string;
+    clsCapsule?: string;
+    className?: string;
+    onRemove?: (v: T) => void;
+    onClick: (v: T) => void;
+};
+/**
+ * @template [T=any]
+ *
+ * @typedef {object} CapsulesViewParams
+ * @property {T[]} tags
+ * @property {(x: T) => string} [name_fn]
+ * @property {string} [clsCapsule]
+ * @property {string} [className]
+ * @property {(v: T) => void} [onRemove]
+ * @property {(v: T) => void} onClick
+ *
+ */
+/**
+ * @template [T=any]
+ *
+ * @param {CapsulesViewParams<T>} params
+ */
+declare function CapsulesView<T = any>({ tags, name_fn, className, clsCapsule, onRemove, onClick }: CapsulesViewParams<T>): import("react").JSX.Element;

package/dist/lib/src/comps/client-only.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } params
+ */
+export default function ClientOnly({ ...rest }: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>): import("react").JSX.Element;
+/**
+ *
+ * @param {React.FC} Component
+ */
+export function withClient(Component: React.FC): (props: any) => import("react").JSX.Element;

package/dist/lib/src/comps/collection-actions.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @typedef {object} ImperativeInterface
+ * @prop {() => string} getSearch
+ * @prop {(value: string) => void} setSearch
+ *
+ *
+ * @typedef {object} TopActionsParams
+ * @prop {() => void} reload
+ * @prop {string} searchTitle
+ * @prop {boolean} isLoading
+ * @prop {string} [createLink]
+ * @prop {string} [className]
+ * @prop {boolean} [isCollectionEmpty=false]
+ */
+export const TopActions: import('react').ForwardRefExoticComponent<TopActionsParams & import('react').RefAttributes<any>>;
+export function BottomActions({ next, prev, limit, onLimitChange, className }: BottomActionsParams): import("react").JSX.Element;
+export type ImperativeInterface = {
+    getSearch: () => string;
+    setSearch: (value: string) => void;
+};
+export type TopActionsParams = {
+    reload: () => void;
+    searchTitle: string;
+    isLoading: boolean;
+    createLink?: string;
+    className?: string;
+    isCollectionEmpty?: boolean;
+};
+export type BottomActionsParams = {
+    next: () => Promise<any>;
+    prev: () => Promise<any>;
+    limit?: number;
+    onLimitChange: (v: number) => void;
+    className?: string;
+};

package/dist/lib/src/comps/collection-products.d.ts

@@ -0,0 +1,32 @@
+export default CollectionProducts;
+export type ImpInterface = {
+    refresh: () => Promise<void>;
+};
+export type CollectionBaseParams = {
+    /**
+     * `handle` or `id`
+     */
+    collection_handle_or_id: string;
+    /**
+     * `limit` of query
+     */
+    limit: number;
+    /**
+     * when loaded reports query count
+     */
+    onLoaded: (count: number) => void;
+    /**
+     * context
+     */
+    context: import('./fields-view.jsx').FieldContextData<import('@storecraft/core/v-api').CollectionType> & import('../pages/collection.jsx').Context;
+};
+/**
+ * `CollectionProducts` wraps and show the `products` of a given
+ * collection with pagination.
+ *
+ * @param {import('./fields-view.jsx').FieldLeafViewParams<
+ *  import('@storecraft/core/v-api').CollectionType,
+ *  import('../pages/collection.jsx').Context>
+ * } param
+ */
+declare function CollectionProducts({ value, context }: import('./fields-view.jsx').FieldLeafViewParams<import('@storecraft/core/v-api').CollectionType, import('../pages/collection.jsx').Context>): import("react").JSX.Element;

package/dist/lib/src/comps/common-button.d.ts

@@ -0,0 +1,77 @@
+export function Button({ text, icon, className, classNameSpan, children, rightView, ...rest }: ButtonParams): import("react").JSX.Element;
+export function Button2({ text, icon, className, classNameSpan, children, ...rest }: Button2params): import("react").JSX.Element;
+export function LoadingButton({ Icon, show, text, keep_text_on_load, className, classNameLoading, classNameLeft, loading, ...rest }: LoadingButtonParams): import("react").JSX.Element;
+/**
+ * A loading button which expects a promise for onClick
+ */
+export type PromisableLoadingButton = InternalPromisableLoadingButton & Omit<LoadingButtonParams, 'onClick'>;
+export function PromisableLoadingButton({ onClick, loading: $loading, ...rest }: PromisableLoadingButton): import("react").JSX.Element;
+export type PromisableLoadingBlingButton = InternalPromisableLoadingBlingButton & Omit<LoadingButtonParams, 'onClick'>;
+export function PromisableLoadingBlingButton({ onClick, show, className, loading: $loading, stroke, rounded, from, to, ...rest }: PromisableLoadingBlingButton): import("react").JSX.Element;
+export function BlingButton({ from, to, rounded, stroke, children, text, className, btnClassName, ...rest }: import('./common-ui.jsx').InternalBlingParams & {
+    btnClassName?: string;
+    text?: string;
+} & React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>): import("react").JSX.Element;
+export function BlingButton2({ from, to, rounded, stroke, ...rest }: Button2params & import('./common-ui.jsx').InternalBlingParams): import("react").JSX.Element;
+export function GradientFillIcon({ Icon, from, to, ...rest }: GradientFillIconParams): import("react").JSX.Element;
+export function GradientStrokeIcon({ Icon, from, to, ...rest }: GradientStrokeIconParams): import("react").JSX.Element;
+export type InternalButtonparams = {
+    text?: string;
+    icon?: React.ReactElement;
+    className?: string;
+    classNameSpan?: string;
+    children?: any;
+    rightView?: any;
+};
+export type ButtonParams = InternalButtonparams & React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+export type InternalButton2params = {
+    text?: string;
+    icon?: React.ReactElement;
+    className?: string;
+    classNameSpan?: string;
+    children: any;
+};
+export type Button2params = InternalButton2params & React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+export type InternalLoadingButtonParams = {
+    Icon?: React.ReactNode;
+    text?: string;
+    keep_text_on_load?: boolean;
+    className?: string;
+    classNameLoading?: string;
+    classNameLeft?: string;
+    loading?: boolean;
+    show?: boolean;
+};
+export type LoadingButtonParams = InternalLoadingButtonParams & React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+/**
+ * A loading button which expects a promise for onClick
+ */
+export type InternalPromisableLoadingButton = {
+    onClick: () => Promise<any>;
+    loading?: boolean;
+};
+export type InternalPromisableLoadingBlingButton = {
+    onClick: () => Promise<any>;
+    show?: boolean;
+    loading?: boolean;
+    stroke?: string;
+    rounded?: string;
+    from?: string;
+    to?: string;
+};
+export type InternalGradientFillIconParams = {
+    from?: string;
+    to?: string;
+    Icon?: React.FC;
+};
+export type GradientFillIconParams = InternalGradientFillIconParams & {
+    [x: string]: any;
+};
+export type InternalGradientStrokeIconParams = {
+    from?: string;
+    to?: string;
+    Icon?: React.FC;
+};
+export type GradientStrokeIconParams = InternalGradientFillIconParams & {
+    [x: string]: any;
+};

package/dist/lib/src/comps/common-fields.d.ts

@@ -0,0 +1,61 @@
+export function create_select_view(options: {
+    id: string | number;
+    name: string;
+}[], defaultIndex?: number): ({ field, value, onChange }: import('./fields-view.jsx').FieldLeafViewParams<{
+    id: string;
+}>) => import("react").JSX.Element;
+export function TextArea({ field, value, onChange, ...rest }: import('./fields-view.jsx').FieldLeafViewParams<string>): import("react").JSX.Element;
+export function Span<T>({ value, children, className, extra, ...rest }: SpanParams<T>): import("react").JSX.Element;
+export function SpanArray({ field, value, className, name_fn, classNameDelimiter, delimiter, ...rest }: SpanArrayParams): import("react").JSX.Element;
+export function TimeStampView({ field, value, ...rest }: import('./table-schema-view.jsx').TableSchemaViewComponentParams<string>): import("react").JSX.Element;
+export function MInput({ field, value, onChange, type, ...rest }: MInputParams): import("react").JSX.Element;
+export function InputWithClipboard({ value, field, onChange, setError, ...rest }: InputWithClipboardParams): import("react").JSX.Element;
+export function Handle({ value, field, onChange, context, setError, ...rest }: HandleParams): import("react").JSX.Element;
+export function Switch({ field, value, onChange, ...rest }: SwitchParams): import("react").JSX.Element;
+export function ClipBoardCopy({ value, config, process_before_copy }: ClipBoardCopyButtonParams): import("react").JSX.Element;
+export function withCard(Comp: React.FC, comp_params_inner?: any, border?: boolean, copy?: boolean): ({ field, value, disabled, onChange, children, error, setError, context, ...rest }: import('./fields-view.jsx').FieldLeafViewParams<any> & {
+    children: React.ReactNode;
+}) => import("react").JSX.Element;
+export function RecordActions<T>({ context, field, value, ...rest }: import('./table-schema-view.jsx').TableSchemaViewComponentParams<any, T>): import("react").JSX.Element;
+/**
+ * This is used in `TableSchemaView`
+ */
+export type InternalSpanParams = {
+    className?: string;
+    extra?: string;
+    children?: React.ReactNode;
+};
+export type SpanParams<T> = import('./table-schema-view.jsx').TableSchemaViewComponentParams<string, T> & InternalSpanParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
+/**
+ * This is used in `TableSchemaView`
+ */
+export type InternalSpanArrayParams = {
+    className?: string;
+    classNameDelimiter?: string;
+    delimiter?: string;
+    name_fn?: (value: any) => string;
+};
+/**
+ * This is used in `TableSchemaView`
+ */
+export type SpanArrayParams = import('./table-schema-view.jsx').TableSchemaViewComponentParams<any[]> & InternalSpanArrayParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
+export type InternalMInputParams = import('./fields-view.jsx').FieldLeafViewParams<string>;
+export type MInputParams = InternalMInputParams & import('./common-ui.jsx').InputParams;
+export type InternalInputWithClipboardParams = import('./fields-view.jsx').FieldLeafViewParams<string>;
+export type InputWithClipboardParams = InternalInputWithClipboardParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+export type InternalHandleParams = import('./fields-view.jsx').FieldLeafViewParams<string>;
+export type HandleParams = InternalHandleParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+export type InternalSwitchParams = import('./fields-view.jsx').FieldLeafViewParams<boolean>;
+export type SwitchParams = InternalSwitchParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+/**
+ * A `copy` to clipboard button
+ */
+export type ClipBoardCopyButtonParams = {
+    value: string;
+    config?: 0 | 1;
+    /**
+     * process the value
+     * before copying
+     */
+    process_before_copy?: (value: string) => string;
+};

package/dist/lib/src/comps/common-table-fields.d.ts

@@ -0,0 +1,18 @@
+export function SimpleLink({ context, value, children, className, extra, url_fn, get_state, ...rest }: SpanParams): import("react").JSX.Element;
+/**
+ * This is used in `TableSchemaView`
+ */
+export type InternalSpanParams<T extends unknown> = {
+    className?: string;
+    extra?: string;
+    /**
+     * create a `url`
+     */
+    url_fn: (item: T) => string;
+    /**
+     * get current navigatio `state`
+     */
+    get_state: () => any;
+    children?: React.ReactNode;
+};
+export type SpanParams<T extends unknown = any> = import('./table-schema-view.jsx').TableSchemaViewComponentParams<string, T> & InternalSpanParams<T> & React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;

package/dist/lib/src/comps/common-ui.d.ts

@@ -0,0 +1,101 @@
+/**
+ * @typedef {object} InternalCreateDateParams
+ * @prop {string} time
+ * @prop {boolean} [changes_made=false]
+ * @prop {string} [rightText] override
+ * @prop {string} className
+ *
+ * @typedef {InternalCreateDateParams &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } CreateDateParams
+ *
+ * @typedef {object} CreateDateImperativeInterface
+ * @prop {() => boolean} get
+ * @prop {(value?: boolean) => void} set
+ */
+export const CreateDate: import('react').ForwardRefExoticComponent<Omit<CreateDateParams, "ref"> & import('react').RefAttributes<any>>;
+export function CreateDate2({ time, className, ...rest }: {
+    time: number;
+    className: string;
+}): import("react").JSX.Element;
+export function HR({ dashed, ...rest }: React.InputHTMLAttributes<HTMLInputElement> & {
+    dashed?: boolean;
+}): import("react").JSX.Element;
+export function Title({ className, ...rest }: React.InputHTMLAttributes<HTMLInputElement> & {
+    className?: string;
+}): import("react").JSX.Element;
+export function Label({ ...rest }: {
+    [x: string]: any;
+}): import("react").JSX.Element;
+export const Input: import('react').ForwardRefExoticComponent<Omit<InputParams, "ref"> & import('react').RefAttributes<any>>;
+export const BlingInput: import('react').ForwardRefExoticComponent<Omit<BlingInputParams, "ref"> & import('react').RefAttributes<any>>;
+export function border_bling_style(color_stops?: string[]): {
+    style: {
+        'background-image': string;
+        'background-clip': string;
+        'border-color': string;
+        'background-origin': string;
+    };
+};
+export function Bling({ className, rounded, children, stroke, from, to, ...rest }: BlingParams): import("react").JSX.Element;
+export function withBling(Comp: any, params?: {}): ({ ...rest }: {
+    [x: string]: any;
+}) => import("react").JSX.Element;
+export function withBling2(Comp: any): ({ ...rest }: {
+    [x: string]: any;
+}) => import("react").JSX.Element;
+export function Div({ setError, ...rest }: {
+    [x: string]: any;
+    setError: any;
+}): import("react").JSX.Element;
+export function Card({ name, setError, error, children, border, desc, rightView, cardClass, ...rest }: CardParams): import("react").JSX.Element;
+export type InternalCreateDateParams = {
+    time: string;
+    changes_made?: boolean;
+    /**
+     * override
+     */
+    rightText?: string;
+    className: string;
+};
+export type CreateDateParams = InternalCreateDateParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+export type CreateDateImperativeInterface = {
+    get: () => boolean;
+    set: (value?: boolean) => void;
+};
+export type InputInternalParams = {
+    overrideClass?: boolean;
+    className?: string;
+};
+export type InputParams = InputInternalParams & React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+export type BlingInputInternalParams = {
+    inputClsName?: string;
+};
+export type BlingInputParams = BlingInputInternalParams & InternalBlingParams & InputParams;
+/**
+ * Background container with gradient
+ */
+export type InternalBlingParams = {
+    className?: string;
+    rounded?: string;
+    children?: any;
+    stroke?: string;
+    from?: string;
+    to?: string;
+};
+/**
+ * Background container with gradient
+ */
+export type BlingParams = InternalBlingParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+export type InternalCardParams = {
+    name?: React.ReactNode;
+    setError?: (e: string) => void;
+    error?: string;
+    children: React.ReactNode;
+    border?: boolean;
+    desc?: string;
+    rightView?: React.ReactElement;
+    cardClass?: string;
+    rest?: any[];
+};
+export type CardParams = InternalCardParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;

package/dist/lib/src/comps/copyable-view.d.ts

@@ -0,0 +1,15 @@
+export function CopyableView({ value, process_before_copy, ...rest }: CopyableViewParams & Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, 'value'>): import("react").JSX.Element;
+/**
+ * A view with `markdown` context, that is `copyable`
+ */
+export type CopyableViewParams = {
+    /**
+     * markdown text
+     */
+    value: string;
+    /**
+     * process the value
+     * before copying
+     */
+    process_before_copy: (value: string) => string;
+};

package/dist/lib/src/comps/customer-orders.d.ts

@@ -0,0 +1,13 @@
+export default CustomerOrders;
+/**
+ *
+ * @param {import('./fields-view.jsx').FieldLeafViewParams<
+ *    import('@storecraft/core/v-api').CustomerType,
+ *    import('../pages/customer.jsx').Context,
+ *    import('@storecraft/core/v-api').CustomerType
+ *  > &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } params
+ *
+ */
+declare function CustomerOrders({ value, field, context, error, setError, ...rest }: import('./fields-view.jsx').FieldLeafViewParams<import('@storecraft/core/v-api').CustomerType, import('../pages/customer.jsx').Context, import('@storecraft/core/v-api').CustomerType> & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>): import("react").JSX.Element;