native-pytech 1.0.1

package/dist/libs/segmentedControl/src/components/Segmented/index.js

@@ -0,0 +1,93 @@
+import React, { memo, useState, useRef, useCallback } from 'react';
+import { View, StyleSheet, ScrollView } from 'react-native';
+import { Easing, useSharedValue, withTiming, useDerivedValue } from 'react-native-reanimated';
+import { useEffectWithoutFirstRender } from '../../../../../libs/constants/hooks';
+import { useShared } from '../../context/shared';
+import { scrollToIndex } from '../../utils';
+import Container from '../Container';
+import Item from '../Item';
+import AnimatedChip from '../AnimatedChip';
+const anim = {
+    duration: 400,
+    easing: Easing.bezier(0.2, 0.2, 0, 1)
+};
+export default memo(({ data, selectedIndex, setCurrentSelectedIndex, isScrollable = true, style, contentContainerStyle, ...itemProps }) => {
+    // ---------------- Variables ----------------
+    const { selectedIndexShared } = useShared();
+    const [equalWidths, setEqualWidths] = useState(false);
+    const widthsRef = useRef([]);
+    const scrollRef = useRef(null);
+    const scrollXRef = useRef(0);
+    const widthsShared = useSharedValue([]);
+    const widthContainerShared = useSharedValue(0);
+    // ---------------- useDerivedValue ----------------
+    const equalWidthsShared = useDerivedValue(() => {
+        if (!isScrollable)
+            return true;
+        const widthContainer = widthContainerShared.value;
+        const widths = widthsShared.value;
+        const sumWidths = widths.reduce((acc, width) => acc + width, 0);
+        return sumWidths <= widthContainer;
+    });
+    // ---------------- Functions ----------------
+    const onPress = useCallback((index) => {
+        selectedIndexShared.value = withTiming(index, anim);
+        setCurrentSelectedIndex(index);
+        if (!equalWidthsShared.value)
+            scrollToIndex({
+                widths: widthsShared.value,
+                scrollX: scrollXRef.current,
+                containerWidth: widthContainerShared.value,
+                scrollRef,
+                index
+            });
+    }, []);
+    const onLayoutItem = useCallback((index, e) => {
+        const width = e.nativeEvent.layout.width;
+        const newWidths = [...widthsRef.current];
+        newWidths[index] = width;
+        widthsRef.current = newWidths;
+        widthsShared.value = newWidths;
+    }, []);
+    // ---------------- Hooks ----------------
+    useEffectWithoutFirstRender(() => {
+        onPress(selectedIndex);
+    }, [selectedIndex]);
+    const content = (<>
+            <AnimatedChip isScrollable={isScrollable} onFinishedSelectedIndex={(index) => setCurrentSelectedIndex(index)} onChangeEqualWidths={(isEqualWidths) => setEqualWidths(isEqualWidths)} widthsShared={widthsShared} widthContainerShared={widthContainerShared}/>
+
+            {data.map((text, index) => (<Item key={index} text={text} onPress={() => onPress(index)} onLayout={(e) => onLayoutItem(index, e)} {...itemProps}/>))}
+        </>);
+    return (<Container style={style} onLayout={(e) => widthContainerShared.value = (e.nativeEvent.layout.width - 2 * 2)} // Restamos 4px de margin
+    >
+            {equalWidths || !isScrollable ? (<View style={[styles.view, contentContainerStyle]}>
+                    {content}
+                </View>) : (<ScrollView ref={scrollRef} horizontal={true} showsHorizontalScrollIndicator={false} style={styles.scrollView} contentContainerStyle={[styles.contentContainer, contentContainerStyle]} scrollEventThrottle={16} onScroll={e => scrollXRef.current = e.nativeEvent.contentOffset.x}>
+                    {content}
+                </ScrollView>)}
+        </Container>);
+});
+const styles = StyleSheet.create({
+    view: {
+        margin: 2,
+        flexDirection: 'row',
+        flex: 1,
+        flexGrow: 1
+    },
+    scrollView: {
+        margin: 2,
+        borderRadius: 999,
+    },
+    contentContainer: {
+        flexDirection: 'row',
+    },
+    containerSelected: {
+        position: 'absolute',
+        height: '100%',
+    },
+    selected: {
+        flex: 1,
+        backgroundColor: 'hsl(0, 0%, 96%)',
+        borderRadius: 999,
+    },
+});

package/dist/libs/segmentedControl/src/components/Segmented/types.d.ts

@@ -0,0 +1,12 @@
+import type PropsWrapper from "../Wrapper/types";
+type Props = Omit<PropsWrapper, 'onChange' | 'selectedIndex'> & {
+    /**
+        selectedIndex del componente.
+    */
+    selectedIndex: number;
+    /**
+        Actualiza el index seleccionado.
+    */
+    setCurrentSelectedIndex: (index: number) => void;
+};
+export default Props;

package/dist/libs/segmentedControl/src/components/Segmented/types.js

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

package/dist/libs/segmentedControl/src/components/Wrapper/index.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import Props from './types';
+declare const _default: React.MemoExoticComponent<({ data, selectedIndex, onChange, ...props }: Props) => React.JSX.Element>;
+export default _default;

package/dist/libs/segmentedControl/src/components/Wrapper/index.js

@@ -0,0 +1,21 @@
+import React, { memo, useState } from 'react';
+import { useEffectWithoutFirstRender } from '../../../../../libs/constants/hooks';
+import Segmented from '../Segmented';
+import Provider, { useShared } from '../../context/shared';
+import { getIndex } from '../../utils';
+export default memo(({ data = [], selectedIndex = 0, onChange, ...props }) => {
+    const _selectedIndex = getIndex(selectedIndex);
+    // Creamos el state interno para activar el onChange
+    const [currentSelectedIndex, setCurrentSelectedIndex] = useState(_selectedIndex);
+    useEffectWithoutFirstRender(() => {
+        onChange?.({ index: currentSelectedIndex, item: data[currentSelectedIndex] });
+    }, [currentSelectedIndex]);
+    // Nos fijamos si ya está dentro del context.
+    const { selectedIndexShared } = useShared() ?? {};
+    const component = (<Segmented data={data} selectedIndex={_selectedIndex} setCurrentSelectedIndex={setCurrentSelectedIndex} {...props}/>);
+    if (!selectedIndexShared)
+        return (<Provider selectedIndex={_selectedIndex}>
+            {component}
+        </Provider>);
+    return component;
+});

package/dist/libs/segmentedControl/src/components/Wrapper/types.d.ts

@@ -0,0 +1,38 @@
+import { StyleProp, TextStyle, ViewStyle } from "react-native";
+type Props = {
+    /**
+        contentContainerStyle de la ScrollView.
+        @default []
+    */
+    data: string[];
+    /**
+        Index del item seleccionado.
+        @default 0
+    */
+    selectedIndex?: number;
+    /**
+        Se ejecuta cuando hay un cambio en el index seleccionado.
+    */
+    onChange?: ({ index, item }: {
+        index: number;
+        item: string;
+    }) => void;
+    /**
+        Si es false, el componente no será scrollable.
+        @default true
+    */
+    isScrollable?: boolean;
+    /**
+        style del contenedor de la ScrollView.
+    */
+    style?: StyleProp<ViewStyle>;
+    /**
+        contentContainerStyle de la ScrollView.
+    */
+    contentContainerStyle?: StyleProp<ViewStyle>;
+    /**
+        style de los textos de los items.
+    */
+    textStyle?: StyleProp<TextStyle>;
+};
+export default Props;

package/dist/libs/segmentedControl/src/components/Wrapper/types.js

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

package/dist/libs/segmentedControl/src/context/shared.d.ts

@@ -0,0 +1,11 @@
+import { type SharedValue } from "react-native-reanimated";
+import React from "react";
+export type ContextType = {
+    selectedIndexShared: SharedValue<number>;
+};
+export declare const useShared: () => ContextType;
+declare const _default: React.MemoExoticComponent<({ children, selectedIndex }: {
+    children: React.ReactNode;
+    selectedIndex?: number;
+}) => React.JSX.Element>;
+export default _default;

package/dist/libs/segmentedControl/src/context/shared.js

@@ -0,0 +1,13 @@
+import { useSharedValue } from "react-native-reanimated";
+import React, { createContext, memo } from "react";
+import { getIndex } from "../utils";
+import { useContext } from "react";
+const context = createContext(null);
+export const useShared = () => useContext(context);
+export default memo(({ children, selectedIndex = 0 }) => {
+    const _selectedIndex = getIndex(selectedIndex);
+    const selectedIndexShared = useSharedValue(_selectedIndex);
+    return (<context.Provider value={{ selectedIndexShared }}>
+            {children}
+        </context.Provider>);
+});

package/dist/libs/segmentedControl/src/utils.d.ts

@@ -0,0 +1,10 @@
+import { RefObject } from "react";
+import { ScrollView } from "react-native";
+export declare const getIndex: (index?: number) => number;
+export declare const scrollToIndex: ({ widths, scrollX, containerWidth, scrollRef, index }: {
+    widths: number[];
+    scrollX: number;
+    containerWidth: number;
+    scrollRef: RefObject<ScrollView | null>;
+    index: number;
+}) => void;

package/dist/libs/segmentedControl/src/utils.js

@@ -0,0 +1,29 @@
+export const getIndex = (index = 0) => Number.isInteger(index) ? index : Math.floor(index);
+export const scrollToIndex = ({ widths, scrollX, containerWidth, scrollRef, index }) => {
+    if (!widths[index] || !containerWidth)
+        return;
+    const left = widths.slice(0, index).reduce((acc, w) => acc + (w || 0), 0);
+    const width = widths[index];
+    const prevWidth = widths[index - 1] || 0;
+    const nextWidth = widths[index + 1] || 0;
+    // Rango que queremos visible (prev + current + next)
+    const blockStart = left - prevWidth;
+    const blockEnd = left + width + nextWidth;
+    const visibleStart = scrollX;
+    const visibleEnd = scrollX + containerWidth;
+    let target = scrollX;
+    if (blockEnd > visibleEnd)
+        target = blockEnd - containerWidth; // Si el bloque se sale por la derecha
+    else if (blockStart < visibleStart)
+        target = blockStart; // Si el bloque se sale por la izquierda
+    else
+        return; // Si ya está todo visible, no hace nada
+    // Límites
+    const totalWidth = widths.reduce((a, w) => a + (w || 0), 0);
+    const maxScroll = Math.max(0, totalWidth - containerWidth);
+    target = Math.max(0, Math.min(target, maxScroll));
+    scrollRef.current?.scrollTo({
+        x: target,
+        animated: true
+    });
+};

package/dist/libs/sql/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from './src/queryLocal';
+export { default as dbRef } from './src/init';
+export * from './src/init';
+export { reset } from './src/utils';

package/dist/libs/sql/index.js

@@ -0,0 +1,4 @@
+export { default } from './src/queryLocal';
+export { default as dbRef } from './src/init';
+export * from './src/init';
+export { reset } from './src/utils';

package/dist/libs/sql/src/init.d.ts

@@ -0,0 +1,24 @@
+import * as SQLite from 'expo-sqlite';
+declare const dbRef: {
+    current: SQLite.SQLiteDatabase | undefined;
+};
+export declare const init: ({ currentVersion, listQueriesTables, queryOnCreateTables, queryOnExists }: {
+    /**
+        Versión actual de la base de datos.
+        Se utiliza para reiniciarla a mano.
+    */
+    currentVersion: number;
+    /**
+        Listado de queries para crear las tablas.
+    */
+    listQueriesTables: string[];
+    /**
+        Cuando se crean las tablas, se ejecuta esta query.
+    */
+    queryOnCreateTables?: string;
+    /**
+        Si la base de datos ya existía (no la está creando), se ejecuta esta query.
+    */
+    queryOnExists?: string;
+}) => Promise<boolean>;
+export default dbRef;

package/dist/libs/sql/src/init.js

@@ -0,0 +1,31 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import * as SQLite from 'expo-sqlite';
+import { Platform } from 'react-native';
+import { reset, _hasTables, _createTables, _executeSQL } from './utils';
+const dbRef = {
+    current: undefined,
+};
+export const init = async ({ currentVersion, listQueriesTables, queryOnCreateTables, queryOnExists }) => {
+    // Se fija si tiene que reinicar la base de datos
+    const savedVersion = await AsyncStorage.getItem('DB_VERSION');
+    //if (savedVersion === null && Platform.OS === 'android') savedVersion = String(DB_VERSION)
+    console.log('version:', currentVersion);
+    console.log('AsyncStorage (DB_VERSION):', savedVersion);
+    if (savedVersion !== String(currentVersion))
+        await reset({ currentVersion });
+    // Inicia la base de datos
+    dbRef.current = await SQLite.openDatabaseAsync('app.db');
+    if (!await _hasTables()) {
+        const created = await _createTables({ listQueries: listQueriesTables, queryOnCreate: queryOnCreateTables });
+        if (!created)
+            return false;
+    }
+    else if (queryOnExists)
+        await _executeSQL({ query: queryOnExists });
+    // En la web se usa memoria temporal (RAM) para que la view_rutas funcione
+    if (Platform.OS === 'web')
+        await dbRef.current.execAsync('PRAGMA temp_store = MEMORY');
+    await dbRef.current.execAsync('PRAGMA journal_mode = WAL');
+    return true;
+};
+export default dbRef;

package/dist/libs/sql/src/queryLocal.d.ts

@@ -0,0 +1,6 @@
+declare const queryLocal: ({ query, params, onlyExecute }: {
+    query: string;
+    params?: any[];
+    onlyExecute?: boolean;
+}) => Promise<any[]>;
+export default queryLocal;

package/dist/libs/sql/src/queryLocal.js

@@ -0,0 +1,15 @@
+import dbRef from './init';
+const queryLocal = async ({ query, params = [], onlyExecute = false }) => {
+    if (!dbRef.current)
+        throw new Error('Database not initialized');
+    try {
+        if (!onlyExecute)
+            return await (dbRef.current.getAllAsync(query, params));
+        await dbRef.current.execAsync(query);
+    }
+    catch (e) {
+        console.error('Error queryLocal:', e, query.slice(0, 100), params);
+    }
+    return [];
+};
+export default queryLocal;

package/dist/libs/sql/src/utils.d.ts

@@ -0,0 +1,11 @@
+export declare const reset: ({ currentVersion }: {
+    currentVersion?: number;
+}) => Promise<void>;
+export declare const _hasTables: () => Promise<boolean>;
+export declare const _createTables: ({ listQueries, queryOnCreate }: {
+    listQueries: string[];
+    queryOnCreate?: string;
+}) => Promise<boolean>;
+export declare const _executeSQL: ({ query }: {
+    query: string;
+}) => Promise<void>;

package/dist/libs/sql/src/utils.js

@@ -0,0 +1,56 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import * as SQLite from 'expo-sqlite';
+import dbRef from './init';
+export const reset = async ({ currentVersion }) => {
+    console.log('Reiniciando base de datos...');
+    try {
+        await SQLite.deleteDatabaseAsync('app.db');
+    }
+    catch (e) {
+        if (e.message.includes('currently open')) {
+            dbRef.current = await SQLite.openDatabaseAsync('app.db');
+            await dbRef.current.closeAsync();
+            dbRef.current.closeSync();
+            await SQLite.deleteDatabaseAsync('app.db');
+        }
+        else
+            console.error('Error eliminando base de datos:', e);
+    }
+    if (currentVersion)
+        await AsyncStorage.setItem('DB_VERSION', String(currentVersion));
+};
+export const _hasTables = async () => {
+    try {
+        const listTables = await dbRef.current.getAllAsync("SELECT name FROM sqlite_master WHERE type='table'");
+        return listTables.length > 0;
+    }
+    catch (e) {
+        console.error('Error verificando DB:', e);
+        return false;
+    }
+};
+export const _createTables = async ({ listQueries, queryOnCreate }) => {
+    console.log('Creando tablas...');
+    for (const query of listQueries) {
+        // Ejecuta
+        try {
+            await _executeSQL({ query });
+        }
+        catch (e) {
+            console.error('Error creando tablas:', e);
+            await AsyncStorage.removeItem('DB_VERSION');
+            return false;
+        }
+    }
+    if (queryOnCreate)
+        await _executeSQL({ query: queryOnCreate });
+    return true;
+};
+export const _executeSQL = async ({ query }) => {
+    const splitStr = query.includes('END;') ? 'END;' : ';';
+    const statements = query.split(splitStr).map(s => s.trim()).filter(Boolean);
+    for (const statement of statements) {
+        const query = `${statement}\n${splitStr}`;
+        await dbRef.current.execAsync(query);
+    }
+};

package/dist/libs/supabase/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from './src/clients/app';
+export type { SupabaseApp } from './src/clients/app';
+export { default as supabaseAdmin } from './src/clients/admin';
+export type { SupabaseAdmin } from './src/clients/admin';

package/dist/libs/supabase/index.js

@@ -0,0 +1,2 @@
+export { default } from './src/clients/app';
+export { default as supabaseAdmin } from './src/clients/admin';

package/dist/libs/supabase/src/clients/admin/config.d.ts

@@ -0,0 +1,2 @@
+declare const supabase: import("@supabase/supabase-js").SupabaseClient<any, "public", "public", any, any>;
+export default supabase;

package/dist/libs/supabase/src/clients/admin/config.js

@@ -0,0 +1,18 @@
+import { expoEnv } from '../../../../../libs/constants/consts';
+import * as utils from '../../utils';
+const { SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY } = expoEnv;
+if (!SUPABASE_URL)
+    throw new Error('SUPABASE_URL is not set');
+if (!SUPABASE_SERVICE_ROLE_KEY)
+    throw new Error('SUPABASE_SERVICE_ROLE_KEY is not set');
+const supabase = utils.createClient({
+    url: SUPABASE_URL,
+    key: SUPABASE_SERVICE_ROLE_KEY,
+    options: {
+        auth: {
+            autoRefreshToken: false,
+            persistSession: true,
+        }
+    }
+});
+export default supabase;

package/dist/libs/supabase/src/clients/admin/index.d.ts

@@ -0,0 +1,8 @@
+declare const supabase: {
+    getUserById: (uid: string) => Promise<import("@supabase/auth-js").UserResponse>;
+    updateUser: (uid: string, attributes: import("../../utils/types").UpdateUserParams["attributes"]) => Promise<import("@supabase/auth-js").UserResponse>;
+    deleteUser: (uid: string) => Promise<import("@supabase/auth-js").UserResponse>;
+    client: import("@supabase/supabase-js").SupabaseClient<any, "public", "public", any, any>;
+};
+export default supabase;
+export type SupabaseAdmin = typeof supabase;

package/dist/libs/supabase/src/clients/admin/index.js

@@ -0,0 +1,7 @@
+import client from './config';
+import * as utils from './utils';
+const supabase = {
+    client,
+    ...utils,
+};
+export default supabase;

package/dist/libs/supabase/src/clients/admin/utils.d.ts

@@ -0,0 +1,4 @@
+import * as utils from '../../utils';
+export declare const getUserById: (uid: string) => Promise<import("@supabase/auth-js").UserResponse>;
+export declare const updateUser: (uid: string, attributes: utils.types.UpdateUserParams["attributes"]) => Promise<import("@supabase/auth-js").UserResponse>;
+export declare const deleteUser: (uid: string) => Promise<import("@supabase/auth-js").UserResponse>;

package/dist/libs/supabase/src/clients/admin/utils.js

@@ -0,0 +1,5 @@
+import supabase from './config';
+import * as utils from '../../utils';
+export const getUserById = async (uid) => (await utils.getUserById(supabase, { uid }));
+export const updateUser = async (uid, attributes) => (await utils.updateUser(supabase, { uid, attributes }));
+export const deleteUser = async (uid) => (await utils.deleteUser(supabase, { uid }));

package/dist/libs/supabase/src/clients/app/config.d.ts

@@ -0,0 +1,3 @@
+import 'react-native-url-polyfill/auto';
+declare const supabase: import("@supabase/supabase-js").SupabaseClient<any, "public", "public", any, any>;
+export default supabase;

package/dist/libs/supabase/src/clients/app/config.js

@@ -0,0 +1,30 @@
+import { expoEnv } from '../../../../../libs/constants/consts';
+import * as utils from '../../utils';
+import { Platform } from 'react-native';
+import 'react-native-url-polyfill/auto';
+import { Buffer } from 'buffer';
+global.Buffer = global.Buffer ?? Buffer;
+// AsyncStorage
+const isWeb = Platform.OS === 'web';
+const asyncStorage = !isWeb
+    ? require('@react-native-async-storage/async-storage')?.default
+    : undefined;
+// Configuración
+const { SUPABASE_URL, SUPABASE_KEY } = expoEnv;
+if (!SUPABASE_URL)
+    throw new Error('SUPABASE_URL is not set');
+if (!SUPABASE_KEY)
+    throw new Error('SUPABASE_KEY is not set');
+const supabase = utils.createClient({
+    url: SUPABASE_URL,
+    key: SUPABASE_KEY,
+    options: {
+        auth: {
+            autoRefreshToken: false,
+            persistSession: true,
+            detectSessionInUrl: false,
+            storage: asyncStorage
+        }
+    }
+});
+export default supabase;

package/dist/libs/supabase/src/clients/app/index.d.ts

@@ -0,0 +1,15 @@
+declare const supabase: {
+    logIn: ({ email, password }?: {
+        email?: string;
+        password?: string;
+    }) => Promise<import("@supabase/auth-js").AuthTokenResponsePassword>;
+    logOut: () => Promise<{
+        error: import("@supabase/auth-js").AuthError | null;
+    }>;
+    getUser: () => Promise<import("@supabase/auth-js").User>;
+    execFunction: (params: import("../../utils/types").ExecFunctionParams) => Promise<any>;
+    signUp: (params: import("../../utils/types").SignUpParams) => Promise<import("@supabase/auth-js").AuthResponse>;
+    client: import("@supabase/supabase-js").SupabaseClient<any, "public", "public", any, any>;
+};
+export default supabase;
+export type SupabaseApp = typeof supabase;

package/dist/libs/supabase/src/clients/app/index.js

@@ -0,0 +1,7 @@
+import client from './config';
+import * as utils from './utils';
+const supabase = {
+    client,
+    ...utils,
+};
+export default supabase;

package/dist/libs/supabase/src/clients/app/utils.d.ts

@@ -0,0 +1,11 @@
+import * as utils from '../../utils';
+export declare const logIn: ({ email, password }?: {
+    email?: string;
+    password?: string;
+}) => Promise<import("@supabase/auth-js").AuthTokenResponsePassword>;
+export declare const logOut: () => Promise<{
+    error: import("@supabase/auth-js").AuthError | null;
+}>;
+export declare const getUser: () => Promise<import("@supabase/auth-js").User>;
+export declare const execFunction: (params: utils.types.ExecFunctionParams) => Promise<any>;
+export declare const signUp: (params: utils.types.SignUpParams) => Promise<import("@supabase/auth-js").AuthResponse>;

package/dist/libs/supabase/src/clients/app/utils.js

@@ -0,0 +1,9 @@
+import supabase from './config';
+import * as utils from '../../utils';
+import { expoEnv } from '../../../../../libs/constants/consts';
+const { SUPABASE_USERNAME_LOGIN, SUPABASE_PASSWORD_LOGIN } = expoEnv;
+export const logIn = async ({ email = SUPABASE_USERNAME_LOGIN, password = SUPABASE_PASSWORD_LOGIN } = {}) => (await utils.logIn(supabase, { email, password }));
+export const logOut = async () => await utils.logOut(supabase);
+export const getUser = async () => await utils.getUser(supabase);
+export const execFunction = async (params) => (await utils.execFunction(supabase, params));
+export const signUp = async (params) => (await utils.signUp(supabase, params));

package/dist/libs/supabase/src/utils/index.d.ts

@@ -0,0 +1,18 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import type { CreateClientParams, SignUpParams, ExecFunctionParams, LogInParams, UpdateUserParams } from './types';
+export * as types from './types';
+export declare const logIn: (supabase: SupabaseClient, params: LogInParams) => Promise<import("@supabase/auth-js").AuthTokenResponsePassword>;
+export declare const logOut: (supabase: SupabaseClient) => Promise<{
+    error: import("@supabase/auth-js").AuthError | null;
+}>;
+export declare const getUser: (supabase: SupabaseClient) => Promise<import("@supabase/auth-js").User>;
+export declare const createClient: ({ url, key, options }: CreateClientParams) => SupabaseClient<any, "public", "public", any, any>;
+export declare const execFunction: (supabase: SupabaseClient, { schema, name, args }: ExecFunctionParams) => Promise<any | null>;
+export declare const getUserById: (supabase: SupabaseClient, { uid }: {
+    uid: string;
+}) => Promise<import("@supabase/auth-js").UserResponse>;
+export declare const updateUser: (supabase: SupabaseClient, { uid, attributes }: UpdateUserParams) => Promise<import("@supabase/auth-js").UserResponse>;
+export declare const deleteUser: (supabase: SupabaseClient, { uid }: {
+    uid: string;
+}) => Promise<import("@supabase/auth-js").UserResponse>;
+export declare const signUp: (supabase: SupabaseClient, credentials: SignUpParams) => Promise<import("@supabase/auth-js").AuthResponse>;

package/dist/libs/supabase/src/utils/index.js

@@ -0,0 +1,21 @@
+import { createClient as createSupabaseClient } from '@supabase/supabase-js';
+export * as types from './types';
+export const logIn = async (supabase, params) => (await supabase.auth.signInWithPassword(params));
+export const logOut = async (supabase) => (await supabase.auth.signOut());
+export const getUser = async (supabase) => {
+    const { data } = await supabase.auth.getSession();
+    return data?.session?.user;
+};
+export const createClient = ({ url, key, options }) => (createSupabaseClient(url, key, options));
+export const execFunction = async (supabase, { schema = 'app', name, args }) => {
+    const { data, error } = await supabase.schema(schema).rpc(name, args);
+    if (error) {
+        console.error(name, error);
+        return null;
+    }
+    return data;
+};
+export const getUserById = async (supabase, { uid }) => (await supabase.auth.admin.getUserById(uid));
+export const updateUser = async (supabase, { uid, attributes }) => (await supabase.auth.admin.updateUserById(uid, attributes));
+export const deleteUser = async (supabase, { uid }) => (await supabase.auth.admin.deleteUser(uid));
+export const signUp = async (supabase, credentials) => (await supabase.auth.signUp(credentials));

package/dist/libs/supabase/src/utils/types.d.ts

@@ -0,0 +1,20 @@
+import { AdminUserAttributes, SignUpWithPasswordCredentials, SupabaseClientOptions } from '@supabase/supabase-js';
+export type LogInParams = {
+    email: string;
+    password: string;
+};
+export type CreateClientParams = {
+    url: string;
+    key: string;
+    options?: SupabaseClientOptions<'public'>;
+};
+export type ExecFunctionParams = {
+    schema?: string;
+    name: string;
+    args?: Record<string, any>;
+};
+export type UpdateUserParams = {
+    uid: string;
+    attributes: AdminUserAttributes;
+};
+export type SignUpParams = SignUpWithPasswordCredentials;

package/dist/libs/supabase/src/utils/types.js

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

package/dist/libs/swiftui/index.d.ts

@@ -0,0 +1,7 @@
+export { default as NavigationLink } from './src/NavigationLink';
+export { default as Icon } from './src/Icon';
+export { default as IconSection } from './src/IconSection';
+export { default as List } from './src/List';
+export { default as Text } from './src/Text';
+export { default as Picker } from './src/Picker';
+export { default as TextSubtitle } from './src/TextSubtitle';