amotify 0.0.65 → 0.0.67

package/dist/node_modules/react-router/dist/index.d.ts

@@ -0,0 +1,241 @@
+/**
+ * Component to use for rendering lazily loaded data from returning defer()
+ * in a loader function
+ */
+export function Await(_ref7: any): React.CElement<any, AwaitErrorBoundary>;
+/**
+ * A `<Router>` that stores all entries in memory.
+ *
+ * @see https://reactrouter.com/router-components/memory-router
+ */
+export function MemoryRouter(_ref3: any): React.FunctionComponentElement<any>;
+/**
+ * Changes the current location.
+ *
+ * Note: This API is mostly useful in React.Component subclasses that are not
+ * able to use hooks. In functional components, we recommend you use the
+ * `useNavigate` hook instead.
+ *
+ * @see https://reactrouter.com/components/navigate
+ */
+export function Navigate(_ref4: any): null;
+/**
+ * Renders the child route's element, if there is one.
+ *
+ * @see https://reactrouter.com/components/outlet
+ */
+export function Outlet(props: any): React.FunctionComponentElement<React.ProviderProps<null>> | null;
+/**
+ * Declares an element that should be rendered at a certain URL path.
+ *
+ * @see https://reactrouter.com/components/route
+ */
+export function Route(_props: any): void;
+/**
+ * Provides location context for the rest of the app.
+ *
+ * Note: You usually won't render a `<Router>` directly. Instead, you'll render a
+ * router that is more specific to your environment such as a `<BrowserRouter>`
+ * in web browsers or a `<StaticRouter>` for server rendering.
+ *
+ * @see https://reactrouter.com/router-components/router
+ */
+export function Router(_ref5: any): React.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> | null;
+/**
+ * Given a Remix Router instance, render the appropriate UI
+ */
+export function RouterProvider(_ref: any): React.FunctionComponentElement<{
+    children?: React.ReactNode;
+}>;
+/**
+ * A container for a nested tree of `<Route>` elements that renders the branch
+ * that best matches the current location.
+ *
+ * @see https://reactrouter.com/components/routes
+ */
+export function Routes(_ref6: any): any;
+declare const DataRouterContext: React.Context<null>;
+declare const DataRouterStateContext: React.Context<null>;
+declare const LocationContext: React.Context<null>;
+/**
+ * A Navigator is a "location changer"; it's how you get to different locations.
+ *
+ * Every history instance conforms to the Navigator interface, but the
+ * distinction is useful primarily when it comes to the low-level `<Router>` API
+ * where both the location and a navigator must be provided separately in order
+ * to avoid "tearing" that may occur in a suspense-enabled app if the action
+ * and/or location were to be read directly from the history instance.
+ */
+declare const NavigationContext: React.Context<null>;
+declare const RouteContext: React.Context<{
+    outlet: null;
+    matches: never[];
+    isDataRoute: boolean;
+}>;
+declare function mapRouteProperties(route: any): {
+    hasErrorBoundary: boolean;
+};
+/**
+ * Returns the ID for the nearest contextual route
+ */
+declare function useRouteId(): any;
+declare function useRoutesImpl(routes: any, locationArg: any, dataRouterState: any, future: any): any;
+export function createMemoryRouter(routes: any, opts: any): import("@remix-run/router").Router;
+/**
+ * Creates a route config from a React "children" object, which is usually
+ * either a `<Route>` element or an array of them. Used internally by
+ * `<Routes>` to create a route config from its children.
+ *
+ * @see https://reactrouter.com/utils/create-routes-from-children
+ */
+export function createRoutesFromChildren(children: any, parentPath: any): any[];
+/**
+ * Renders the result of `matchRoutes()` into a React element.
+ */
+export function renderMatches(matches: any): any;
+/**
+ * Returns the action data for the nearest ancestor Route action
+ */
+export function useActionData(): any;
+/**
+ * Returns the error from the nearest ancestor `<Await />` value
+ */
+export function useAsyncError(): any;
+/**
+ * Returns the happy-path data from the nearest ancestor `<Await />` value
+ */
+export function useAsyncValue(): any;
+/**
+ * Allow the application to block navigations within the SPA and present the
+ * user a confirmation dialog to confirm the navigation.  Mostly used to avoid
+ * using half-filled form data.  This does not handle hard-reloads or
+ * cross-origin navigations.
+ */
+export function useBlocker(shouldBlock: any): any;
+/**
+ * Returns the full href for the given "to" value. This is useful for building
+ * custom links that are also accessible and preserve right-click behavior.
+ *
+ * @see https://reactrouter.com/hooks/use-href
+ */
+export function useHref(to: any, _temp: any): any;
+/**
+ * Returns true if this component is a descendant of a `<Router>`.
+ *
+ * @see https://reactrouter.com/hooks/use-in-router-context
+ */
+export function useInRouterContext(): boolean;
+/**
+ * Returns the loader data for the nearest ancestor Route loader
+ */
+export function useLoaderData(): any;
+/**
+ * Returns the current location object, which represents the current URL in web
+ * browsers.
+ *
+ * Note: If you're using this it may mean you're doing some of your own
+ * "routing" in your app, and we'd like to know what your use case is. We may
+ * be able to provide something higher-level to better suit your needs.
+ *
+ * @see https://reactrouter.com/hooks/use-location
+ */
+export function useLocation(): any;
+/**
+ * Returns a PathMatch object if the given pattern matches the current URL.
+ * This is useful for components that need to know "active" state, e.g.
+ * `<NavLink>`.
+ *
+ * @see https://reactrouter.com/hooks/use-match
+ */
+export function useMatch(pattern: any): import("@remix-run/router").PathMatch<string> | null;
+/**
+ * Returns the active route matches, useful for accessing loaderData for
+ * parent/child routes or the route "handle" property
+ */
+export function useMatches(): any;
+/**
+ * Returns an imperative method for changing the location. Used by `<Link>`s, but
+ * may also be used by other elements to change the location.
+ *
+ * @see https://reactrouter.com/hooks/use-navigate
+ */
+export function useNavigate(): (to: any, options: any) => void;
+/**
+ * Returns the current navigation, defaulting to an "idle" navigation when
+ * no navigation is in progress
+ */
+export function useNavigation(): any;
+/**
+ * Returns the current navigation action which describes how the router came to
+ * the current location, either by a pop, push, or replace on the history stack.
+ *
+ * @see https://reactrouter.com/hooks/use-navigation-type
+ */
+export function useNavigationType(): any;
+/**
+ * Returns the element for the child route at this level of the route
+ * hierarchy. Used internally by `<Outlet>` to render child routes.
+ *
+ * @see https://reactrouter.com/hooks/use-outlet
+ */
+export function useOutlet(context: any): React.FunctionComponentElement<React.ProviderProps<null>> | null;
+/**
+ * Returns the context (if provided) for the child route at this level of the route
+ * hierarchy.
+ * @see https://reactrouter.com/hooks/use-outlet-context
+ */
+export function useOutletContext(): null;
+/**
+ * Returns an object of key/value pairs of the dynamic params from the current
+ * URL that were matched by the route path.
+ *
+ * @see https://reactrouter.com/hooks/use-params
+ */
+export function useParams(): any;
+/**
+ * Resolves the pathname of the given `to` value against the current location.
+ *
+ * @see https://reactrouter.com/hooks/use-resolved-path
+ */
+export function useResolvedPath(to: any, _temp2: any): import("@remix-run/router").Path;
+/**
+ * Returns a revalidate function for manually triggering revalidation, as well
+ * as the current state of any manual revalidations
+ */
+export function useRevalidator(): {
+    revalidate: any;
+    state: any;
+};
+/**
+ * Returns the nearest ancestor Route error, which could be a loader/action
+ * error or a render error.  This is intended to be called from your
+ * ErrorBoundary/errorElement to display a proper error message.
+ */
+export function useRouteError(): any;
+/**
+ * Returns the loaderData for the given routeId
+ */
+export function useRouteLoaderData(routeId: any): any;
+/**
+ * Returns the element of the route that matched the current location, prepared
+ * with the correct context to render the remainder of the route tree. Route
+ * elements in the tree must render an `<Outlet>` to render their child route's
+ * element.
+ *
+ * @see https://reactrouter.com/hooks/use-routes
+ */
+export function useRoutes(routes: any, locationArg: any): any;
+declare class AwaitErrorBoundary extends React.Component<any, any, any> {
+    static getDerivedStateFromError(error: any): {
+        error: any;
+    };
+    constructor(props: any);
+    state: {
+        error: null;
+    };
+    componentDidCatch(error: any, errorInfo: any): void;
+    render(): React.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+}
+import * as React from 'react';
+export { DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, mapRouteProperties as UNSAFE_mapRouteProperties, useRouteId as UNSAFE_useRouteId, useRoutesImpl as UNSAFE_useRoutesImpl, createRoutesFromChildren as createRoutesFromElements };
+export { AbortedDeferredError, Action as NavigationType, createPath, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, resolvePath } from "@remix-run/router";

package/dist/node_modules/react-router-dom/dist/index.d.ts

@@ -0,0 +1,139 @@
+export { UNSAFE_ErrorResponseImpl } from "@remix-run/router";
+/**
+ * A `<Router>` for use in web browsers. Provides the cleanest URLs.
+ */
+export function BrowserRouter(_ref4: any): React.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+/**
+ * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except
+ * that the interaction with the server is with `fetch` instead of new document
+ * requests, allowing components to add nicer UX to the page as the form is
+ * submitted and returns with data.
+ */
+export const Form: React.ForwardRefExoticComponent<React.RefAttributes<any>>;
+/**
+ * A `<Router>` for use in web browsers. Stores the location in the hash
+ * portion of the URL so it is not sent to the server.
+ */
+export function HashRouter(_ref5: any): React.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+/**
+ * The public API for rendering a history-aware `<a>`.
+ */
+export const Link: React.ForwardRefExoticComponent<React.RefAttributes<any>>;
+/**
+ * A `<Link>` wrapper that knows if it's "active" or not.
+ */
+export const NavLink: React.ForwardRefExoticComponent<React.RefAttributes<any>>;
+/**
+ * Given a Remix Router instance, render the appropriate UI
+ */
+export function RouterProvider(_ref: any): React.FunctionComponentElement<{
+    children?: React.ReactNode;
+}>;
+/**
+ * This component will emulate the browser's scroll restoration on location
+ * changes.
+ */
+export function ScrollRestoration(_ref10: any): null;
+export namespace ScrollRestoration {
+    let displayName: string;
+}
+declare const FetchersContext: React.Context<Map<any, any>>;
+declare const ViewTransitionContext: React.Context<{
+    isTransitioning: boolean;
+}>;
+/**
+ * When rendered inside a RouterProvider, will restore scroll positions on navigations
+ */
+declare function useScrollRestoration(_temp4: any): void;
+export function createBrowserRouter(routes: any, opts: any): import("@remix-run/router").Router;
+export function createHashRouter(routes: any, opts: any): import("@remix-run/router").Router;
+/**
+ * Creates a URLSearchParams object using the given initializer.
+ *
+ * This is identical to `new URLSearchParams(init)` except it also
+ * supports arrays as values in the object form of the initializer
+ * instead of just strings. This is convenient when you need multiple
+ * values for a given key, but don't want to use an array initializer.
+ *
+ * For example, instead of:
+ *
+ *   let searchParams = new URLSearchParams([
+ *     ['sort', 'name'],
+ *     ['sort', 'price']
+ *   ]);
+ *
+ * you can do:
+ *
+ *   let searchParams = createSearchParams({
+ *     sort: ['name', 'price']
+ *   });
+ */
+export function createSearchParams(init: any): URLSearchParams;
+/**
+ * A `<Router>` that accepts a pre-instantiated history object. It's important
+ * to note that using your own history object is highly discouraged and may add
+ * two versions of the history library to your bundles unless you use the same
+ * version of the history library that React Router uses internally.
+ */
+declare function HistoryRouter(_ref6: any): React.FunctionComponentElement<import("react-router").RouterProps>;
+declare namespace HistoryRouter {
+    let displayName_1: string;
+    export { displayName_1 as displayName };
+}
+/**
+ * Wrapper around useBlocker to show a window.confirm prompt to users instead
+ * of building a custom UI with useBlocker.
+ *
+ * Warning: This has *a lot of rough edges* and behaves very differently (and
+ * very incorrectly in some cases) across browsers if user click addition
+ * back/forward navigations while the confirm is open.  Use at your own risk.
+ */
+declare function usePrompt(_ref12: any): void;
+/**
+ * Return a boolean indicating if there is an active view transition to the
+ * given href.  You can use this value to render CSS classes or viewTransitionName
+ * styles onto your elements
+ *
+ * @param href The destination href
+ * @param [opts.relative] Relative routing type ("route" | "path")
+ */
+declare function useViewTransitionState(to: any, opts: any): boolean;
+/**
+ * Setup a callback to be fired on the window's `beforeunload` event. This is
+ * useful for saving some data to `window.localStorage` just before the page
+ * refreshes.
+ *
+ * Note: The `callback` argument should be a function created with
+ * `React.useCallback()`.
+ */
+export function useBeforeUnload(callback: any, options: any): void;
+/**
+ * Interacts with route loaders and actions without causing a navigation. Great
+ * for any interaction that stays on the same page.
+ */
+export function useFetcher(_temp3: any): any;
+/**
+ * Provides all fetchers currently on the page. Useful for layouts and parent
+ * routes that need to provide pending/optimistic UI regarding the fetch.
+ */
+export function useFetchers(): any[];
+export function useFormAction(action: any, _temp2: any): string;
+/**
+ * Handles the click behavior for router `<Link>` components. This is useful if
+ * you need to create custom `<Link>` components with the same click behavior we
+ * use in our exported `<Link>`.
+ */
+export function useLinkClickHandler(to: any, _temp: any): (event: any) => void;
+/**
+ * A convenient wrapper for reading and writing search parameters via the
+ * URLSearchParams interface.
+ */
+export function useSearchParams(defaultInit: any): (URLSearchParams | ((nextInit: any, navigateOptions: any) => void))[];
+/**
+ * Returns a function that may be used to programmatically submit a form (or
+ * some arbitrary data) to the server.
+ */
+export function useSubmit(): (target: any, options: any) => void;
+import * as React from 'react';
+export { FetchersContext as UNSAFE_FetchersContext, ViewTransitionContext as UNSAFE_ViewTransitionContext, useScrollRestoration as UNSAFE_useScrollRestoration, HistoryRouter as unstable_HistoryRouter, usePrompt as unstable_usePrompt, useViewTransitionState as unstable_useViewTransitionState };
+export { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, Routes, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, UNSAFE_useRouteId, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, resolvePath, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from "react-router";

package/dist/node_modules/scheduler/cjs/scheduler.production.min.d.ts

@@ -0,0 +1,20 @@
+export function unstable_now(): number;
+export const unstable_IdlePriority: 5;
+export const unstable_ImmediatePriority: 1;
+export const unstable_LowPriority: 4;
+export const unstable_NormalPriority: 3;
+export const unstable_Profiling: any;
+export const unstable_UserBlockingPriority: 2;
+export function unstable_cancelCallback(a: any): void;
+export function unstable_continueExecution(): void;
+export function unstable_forceFrameRate(a: any): void;
+export function unstable_getCurrentPriorityLevel(): number;
+export function unstable_getFirstCallbackNode(): any;
+export function unstable_next(a: any): any;
+export function unstable_pauseExecution(): void;
+export function unstable_requestPaint(): void;
+export function unstable_runWithPriority(a: any, b: any): any;
+export function unstable_scheduleCallback(a: any, b: any, c: any): any;
+export { M as unstable_shouldYield };
+export function unstable_wrapCallback(a: any): (...args: any[]) => any;
+declare function M(): boolean;

package/dist/node_modules/scheduler/index.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

package/dist/src/@atoms.d.ts

@@ -0,0 +1,4 @@
+import { Box, Span, Img, Flex, FlexBr, Grid, Paragraph, Placeholder } from './atoms/Various/parts';
+import { FAI } from './atoms/FAI/parts';
+import { Logo } from './atoms/Logo/parts';
+export { Flex, FlexBr, FAI, Placeholder, Grid, Logo, Box, Span, Paragraph, Img };

package/dist/src/@declations/_.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import './module';
+import _$ from 'jsmin-front';
+declare global {
+    var $: typeof _$;
+}
+export type Device = 'windows' | 'android' | 'iPhone' | 'iPad' | 'macOSX' | 'undefined';
+export type Browser = 'chrome' | 'firefox' | 'safari' | 'opera' | 'ie' | 'edge' | 'undefined';
+export type ReactElement = React.ReactNode | React.ReactNode[];
+import './jsminAmotifyExtension';
+import { Styles } from './styles';
+export { Styles };
+import { config, global, atoms, mols, orgs, temps, fn } from './amotify';
+export { config, global, atoms, mols, orgs, temps, fn };
+export interface amotify {
+    config: config.Methods;
+    global: global.Methods;
+    atoms: atoms.Methods;
+    mols: mols.Methods;
+    orgs: orgs.Methods;
+    temps: temps.Methods;
+    fn: fn.Methods;
+}