@sqrzro/admin 2.0.0 → 2.1.0-bz.1

package/dist/utility/interfaces.d.ts

@@ -1,79 +0,0 @@
-import type { FunctionComponent, KeyboardEventHandler, MouseEventHandler } from 'react';
-import type { NextRouter } from 'next/router';
-export type InputValue = File | string[] | boolean | string;
-export interface InputEventTarget<T> {
-    name: string;
-    value: T;
-}
-export interface InputEvent<T extends InputValue = InputValue, O extends SimpleObject = SimpleObject> {
-    item?: O;
-    target: InputEventTarget<T>;
-}
-export interface InputProps<V extends InputValue, T extends V = V, E = HTMLInputElement> {
-    hasError?: boolean;
-    id?: string;
-    isAutoFocus?: boolean;
-    isDisabled?: boolean;
-    name: string;
-    onChange?: (event: InputEvent<T>) => void;
-    onKeyDown?: KeyboardEventHandler<E>;
-    value?: V;
-}
-export interface LayoutComponent extends FunctionComponent<{
-    children: React.ReactNode;
-}> {
-}
-export interface SceneComponentType extends FunctionComponent<{
-    router: Omit<NextRouter, 'events'>;
-}> {
-    Layout?: LayoutComponent;
-    hasLayout?: boolean;
-}
-export interface Action {
-    isDisabled?: boolean | null;
-    label: string;
-    onClick: () => void;
-    variant?: ButtonVariant | ButtonVariant[];
-}
-type NavigationObjectDisabledFunction = (item: NavigationObject, sceneData?: Record<string, unknown>) => boolean;
-export interface NavigationObject {
-    isActive?: boolean;
-    isDisabled?: NavigationObjectDisabledFunction | boolean;
-    label: string;
-    to?: string;
-    onClick?: MouseEventHandler<HTMLAnchorElement | HTMLButtonElement>;
-    permission?: string;
-}
-export type NavigationData = NavigationObject[] | [string, NavigationObject[]];
-export interface Query {
-    [key: string]: Query | Query[] | string[] | string;
-}
-export type QueryValue = Query | Query[] | string[] | string;
-export type FilterMap = Map<string, QueryValue>;
-export type Remote = string | [string, Query?, FilterMap?];
-export interface SimpleObject {
-    [key: string]: unknown;
-    id?: string;
-    name?: string;
-}
-export type StrictSimpleObject = Required<SimpleObject>;
-export type ActionFunction<T> = (data?: T) => Action[];
-export interface TransformedObject<T extends SimpleObject = SimpleObject> {
-    [key: string]: unknown;
-    $id: string;
-    $actions?: Action[] | ActionFunction<T> | null;
-    $original?: T;
-}
-export type Transformer<T extends SimpleObject = SimpleObject, O = TransformedObject> = (item: T) => O;
-export type TransformerWithActions<T extends SimpleObject = SimpleObject, O = TransformedObject> = Transformer<T, O> | [Transformer<T, O>, Action[] | ActionFunction<T>];
-export type StyleVariant = 'bordered' | 'danger' | 'primary' | 'secondary' | 'success' | 'tertiary' | 'warning';
-export type ButtonVariant = StyleVariant | 'link';
-export interface PaginationObject {
-    activePage: number;
-    pageCount: number;
-}
-export declare function isString(variable: unknown): variable is string;
-export declare function isStringArray(variable: unknown): variable is string[];
-export declare function isStrictSimpleObject(variable: unknown): variable is StrictSimpleObject;
-export declare function isStrictSimpleObjectArray(variable: unknown): variable is StrictSimpleObject[];
-export {};

package/dist/utility/interfaces.js

@@ -1,18 +0,0 @@
-/*
- * ---------------------------------------------------------------------------------
- * Checks
- * ---------------------------------------------------------------------------------
- */
-export function isString(variable) {
-    return typeof variable === 'string';
-}
-export function isStringArray(variable) {
-    return Array.isArray(variable) && (variable.length === 0 || isString(variable[0]));
-}
-export function isStrictSimpleObject(variable) {
-    return (isString(variable.id) &&
-        isString(variable.name));
-}
-export function isStrictSimpleObjectArray(variable) {
-    return Array.isArray(variable) && (variable.length === 0 || isStrictSimpleObject(variable[0]));
-}

package/dist/utility/middleware.d.ts

@@ -1,4 +0,0 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-declare function middleware(request: NextRequest): Promise<NextResponse>;
-export default middleware;

package/dist/utility/middleware.js

@@ -1,9 +0,0 @@
-import { NextResponse } from 'next/server';
-async function middleware(request) {
-    return NextResponse.redirect(new URL('/auth/login', request.url));
-}
-// function middleware(): void {
-//     console.log('tester');
-//     // Return NextResponse.redirect(new URL('/auth/login', request.url));
-// }
-export default middleware;

package/dist/utility/prop-types.d.ts

@@ -1,57 +0,0 @@
-import PropTypes from 'prop-types';
-import { AuthIdentifier } from '@sqrzro/hooks';
-import { AppLayout } from '../services/ConfigService';
-import type { ButtonVariant, StyleVariant } from '../utility/interfaces';
-export declare const NextRouterPropType: PropTypes.Requireable<PropTypes.InferProps<{
-    asPath: PropTypes.Validator<string>;
-    back: PropTypes.Validator<(...args: any[]) => any>;
-    basePath: PropTypes.Validator<string>;
-    beforePopState: PropTypes.Validator<(...args: any[]) => any>;
-    events: PropTypes.Requireable<PropTypes.InferProps<{
-        emit: PropTypes.Validator<(...args: any[]) => any>;
-        off: PropTypes.Validator<(...args: any[]) => any>;
-        on: PropTypes.Validator<(...args: any[]) => any>;
-    }>>;
-    forward: PropTypes.Validator<(...args: any[]) => any>;
-    isFallback: PropTypes.Validator<boolean>;
-    isLocaleDomain: PropTypes.Validator<boolean>;
-    isPreview: PropTypes.Validator<boolean>;
-    isReady: PropTypes.Validator<boolean>;
-    pathname: PropTypes.Validator<string>;
-    prefetch: PropTypes.Validator<(...args: any[]) => any>;
-    push: PropTypes.Validator<(...args: any[]) => any>;
-    query: PropTypes.Validator<NonNullable<PropTypes.InferProps<{}>>>;
-    reload: PropTypes.Validator<(...args: any[]) => any>;
-    replace: PropTypes.Validator<(...args: any[]) => any>;
-    route: PropTypes.Validator<string>;
-}>>;
-export declare const StyleVariantPropType: PropTypes.Requireable<NonNullable<NonNullable<StyleVariant> | NonNullable<StyleVariant>[] | null | undefined>>;
-export declare const ButtonVariantPropType: PropTypes.Requireable<NonNullable<NonNullable<ButtonVariant> | NonNullable<ButtonVariant>[] | null | undefined>>;
-export declare const AppPropTypes: {
-    Component: PropTypes.Validator<(...args: any[]) => any>;
-    context: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
-        auth: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
-            identifier: PropTypes.Validator<AuthIdentifier>;
-            identifierLabel: PropTypes.Validator<string>;
-            loginUrl: PropTypes.Validator<string>;
-            meUrl: PropTypes.Validator<string>;
-            passwordUrl: PropTypes.Validator<string>;
-            tfa: PropTypes.Validator<boolean>;
-        }>>>;
-        name: PropTypes.Validator<string>;
-        navigation: PropTypes.Validator<NonNullable<NonNullable<string | NonNullable<PropTypes.InferProps<{
-            label: PropTypes.Validator<string>;
-            to: PropTypes.Requireable<string>;
-            onClick: PropTypes.Requireable<(...args: any[]) => any>;
-            permission: PropTypes.Requireable<string>;
-        }>>>>[]>;
-        paths: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
-            api: PropTypes.Validator<string>;
-        }>>>;
-        style: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
-            brand: PropTypes.Validator<string>;
-            layout: PropTypes.Validator<AppLayout>;
-        }>>>;
-    }>>>;
-    $isHooked: PropTypes.Requireable<boolean>;
-};

package/dist/utility/prop-types.js

@@ -1,77 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import PropTypes from 'prop-types';
-import { AuthIdentifier } from '@sqrzro/hooks';
-import { AppLayout } from '../services/ConfigService';
-export const NextRouterPropType = PropTypes.shape({
-    asPath: PropTypes.string.isRequired,
-    back: PropTypes.func.isRequired,
-    basePath: PropTypes.string.isRequired,
-    beforePopState: PropTypes.func.isRequired,
-    events: PropTypes.shape({
-        emit: PropTypes.func.isRequired,
-        off: PropTypes.func.isRequired,
-        on: PropTypes.func.isRequired,
-    }),
-    forward: PropTypes.func.isRequired,
-    isFallback: PropTypes.bool.isRequired,
-    isLocaleDomain: PropTypes.bool.isRequired,
-    isPreview: PropTypes.bool.isRequired,
-    isReady: PropTypes.bool.isRequired,
-    pathname: PropTypes.string.isRequired,
-    prefetch: PropTypes.func.isRequired,
-    push: PropTypes.func.isRequired,
-    query: PropTypes.shape({}).isRequired,
-    reload: PropTypes.func.isRequired,
-    replace: PropTypes.func.isRequired,
-    route: PropTypes.string.isRequired,
-});
-const styleVariantPropTypes = [
-    'bordered',
-    'danger',
-    'primary',
-    'secondary',
-    'success',
-    'tertiary',
-];
-const buttonVariantPropTypes = [...styleVariantPropTypes, 'link'];
-export const StyleVariantPropType = PropTypes.oneOfType([
-    PropTypes.arrayOf(PropTypes.oneOf(styleVariantPropTypes).isRequired),
-    PropTypes.oneOf(styleVariantPropTypes).isRequired,
-]);
-export const ButtonVariantPropType = PropTypes.oneOfType([
-    PropTypes.arrayOf(PropTypes.oneOf(buttonVariantPropTypes).isRequired),
-    PropTypes.oneOf(buttonVariantPropTypes).isRequired,
-]);
-const AuthIdentifierPropType = PropTypes.oneOf(Object.values(AuthIdentifier));
-const AppLayoutPropType = PropTypes.oneOf(Object.values(AppLayout));
-export const AppPropTypes = {
-    Component: PropTypes.func.isRequired,
-    context: PropTypes.shape({
-        auth: PropTypes.shape({
-            identifier: AuthIdentifierPropType.isRequired,
-            identifierLabel: PropTypes.string.isRequired,
-            loginUrl: PropTypes.string.isRequired,
-            meUrl: PropTypes.string.isRequired,
-            passwordUrl: PropTypes.string.isRequired,
-            tfa: PropTypes.bool.isRequired,
-        }).isRequired,
-        name: PropTypes.string.isRequired,
-        navigation: PropTypes.arrayOf(PropTypes.oneOfType([
-            PropTypes.string.isRequired,
-            PropTypes.shape({
-                label: PropTypes.string.isRequired,
-                to: PropTypes.string,
-                onClick: PropTypes.func,
-                permission: PropTypes.string,
-            }).isRequired,
-        ]).isRequired).isRequired,
-        paths: PropTypes.shape({
-            api: PropTypes.string.isRequired,
-        }).isRequired,
-        style: PropTypes.shape({
-            brand: PropTypes.string.isRequired,
-            layout: AppLayoutPropType.isRequired,
-        }).isRequired,
-    }).isRequired,
-    $isHooked: PropTypes.bool,
-};

package/dist/utility/register.d.ts

@@ -1,3 +0,0 @@
-import type { Config } from '../services/ConfigService';
-declare function register(config: Config): void;
-export default register;

package/dist/utility/register.js

@@ -1,9 +0,0 @@
-function register(config) {
-    console.log('REGISTER');
-    // ApiService.registerConfig({ path: config.paths?.api });
-    // if (config.auth) {
-    //     AuthService.registerConfig(config.auth);
-    // }
-    // ConfigService.registerConfig(config);
-}
-export default register;

package/src/components/Alert/index.tsx

@@ -1,111 +0,0 @@
-'use client';
-
-import React, { useEffect, useRef } from 'react';
-import clsx from 'clsx';
-import PropTypes from 'prop-types';
-
-import Button from '../Button';
-
-import Icon from '../../core/Icon';
-import Panel from '../../core/Panel';
-
-import useVariant from '../../hooks/useVariant';
-
-import type { Action, StyleVariant } from '../../utility/interfaces';
-
-// Import styles from './AlertComponent.module.css';
-
-export interface AlertProps {
-    actions?: Action[];
-    children: React.ReactNode;
-    icon?: string;
-    isOpen?: boolean;
-    onClose?: React.MouseEventHandler<HTMLButtonElement>;
-    title?: string;
-    variant?: StyleVariant;
-    width?: string;
-}
-
-function Alert({
-    actions,
-    children,
-    icon,
-    isOpen,
-    onClose,
-    title,
-    variant,
-    width,
-}: AlertProps): React.ReactElement | null {
-    const ref = useRef<HTMLDialogElement>(null);
-    const { applyVariantClassName } = useVariant(variant);
-
-    useEffect(() => {
-        if (isOpen) {
-            ref.current?.showModal();
-        }
-    }, [isOpen]);
-
-    useEffect(() => {
-        ref.current?.addEventListener('close', (event: MouseEvent): void => {
-            if (onClose) {
-                onClose(event);
-            }
-        });
-    }, []);
-
-    return (
-        <dialog ref={ref} className="alert">
-            <aside className="max-w-sm" role="alert">
-                <Panel isPadded>
-                    <div
-                        className={clsx(
-                            'mx-auto -mt-8 flex h-24 w-16 flex-col justify-center rounded-b-md bg-green-400',
-                            applyVariantClassName({ warning: 'bg-amber-400' })
-                        )}
-                        data-testid="alert-component-logo"
-                    >
-                        {icon ? <Icon icon={icon} size={40} /> : null}
-                    </div>
-                    {title ? (
-                        <h3 className="/*styles.title*/" role="heading">
-                            {title}
-                        </h3>
-                    ) : null}
-                    <div key={String(isOpen)}>{children}</div>
-                    <footer className="/*styles.actions*/">
-                        {actions?.map((action) => (
-                            <Button
-                                key={action.label}
-                                isDisabled={action.isDisabled}
-                                onClick={action.onClick}
-                                variant={action.variant}
-                            >
-                                {action.label}
-                            </Button>
-                        ))}
-
-                        <form method="dialog">
-                            <Button type="submit" variant="link">
-                                Close
-                            </Button>
-                        </form>
-                    </footer>
-                </Panel>
-            </aside>
-        </dialog>
-    );
-}
-
-Alert.propTypes = {
-    children: PropTypes.node.isRequired,
-    actions: PropTypes.arrayOf(
-        PropTypes.shape({
-            label: PropTypes.string.isRequired,
-            onClick: PropTypes.func.isRequired,
-        }).isRequired
-    ),
-    title: PropTypes.string,
-    variant: PropTypes.oneOf(['primary', 'secondary', 'tertiary', 'warning', 'danger']),
-};
-
-export default Alert;

package/src/components/Allow/Allow.spec.tsx

@@ -1,37 +0,0 @@
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-
-import type { Config } from '../../services/ConfigService';
-
-import Allow from './index';
-
-jest.mock(
-    '../../hooks/useConfig',
-    () => (): Config => ({
-        me: { name: 'Lorem', permissions: ['lorem'] },
-        name: 'Lorem',
-        navigation: [],
-        paths: {},
-    })
-);
-
-describe('Allow', () => {
-    it('should render', () => {
-        render(<Allow>Lorem</Allow>);
-    });
-
-    it('should render defaults', () => {
-        render(<Allow>Lorem</Allow>);
-        expect(screen.getByText(/^Lorem$/u)).toBeInTheDocument();
-    });
-
-    it('should render with no permission', () => {
-        render(<Allow permission="ipsum">Lorem</Allow>);
-        expect(screen.queryByText(/^Lorem$/u)).not.toBeInTheDocument();
-    });
-
-    it('should render with permission', () => {
-        render(<Allow permission="lorem">Lorem</Allow>);
-        expect(screen.getByText(/^Lorem$/u)).toBeInTheDocument();
-    });
-});

package/src/components/Allow/index.tsx

@@ -1,42 +0,0 @@
-import React, { Fragment } from 'react';
-import PropTypes from 'prop-types';
-
-import useConfig from '../../hooks/useConfig';
-import type { Me } from '../../services/ConfigService';
-
-interface AllowProps {
-    children: React.ReactNode;
-    permission?: string;
-}
-
-function hasPermission(me: Me, permission?: string): boolean {
-    if (!me.permissions || !permission) {
-        return true;
-    }
-    return me.permissions.includes(permission);
-}
-
-/**
- * The `Allow` component is essentially a wrappy that lets a developer display or hide child content
- * based on the permissions a particular user has.
- *
- * By default, the
- */
-function Allow({ children, permission }: AllowProps): React.ReactElement | null {
-    const { me } = useConfig();
-
-    if (me && !hasPermission(me, permission)) {
-        return null;
-    }
-
-    // Use the `Fragment` here to get around TS complaining about FunctionComponent
-    // eslint-disable-next-line react/jsx-no-useless-fragment
-    return <Fragment>{children}</Fragment>;
-}
-
-Allow.propTypes = {
-    children: PropTypes.node.isRequired,
-    permission: PropTypes.string,
-};
-
-export default Allow;

package/src/components/AppLayout/AppLayout.stories.tsx

@@ -1,20 +0,0 @@
-import React from 'react';
-import type { ComponentMeta, ComponentStory } from '@storybook/react';
-
-import AppLayout from './index';
-import type { AppLayoutProps } from './index';
-
-export default {
-    title: 'Components/AppLayout',
-    component: AppLayout,
-} as ComponentMeta<typeof AppLayout>;
-
-const Template: ComponentStory<typeof AppLayout> = (args: AppLayoutProps): React.ReactElement => (
-    <AppLayout {...args} />
-);
-
-export const Basic = Template.bind({});
-
-Basic.args = {
-    children: 'Lorem Ipsum',
-};

package/src/components/AutoSuggest/AutoSuggest.module.css

@@ -1,8 +0,0 @@
-.root {
-    position: relative;
-    z-index: 1;
-}
-
-.rootOpen {
-    z-index: 2;
-}