@wix/astro 0.2.13 → 0.2.15

package/dist/components/TailwindEditor/index.js

@@ -0,0 +1,155 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState, useCallback } from 'react';
+import EditorPanel from './EditorPanel.js';
+import { extractAstroSourceInfo, applyChanges } from './utils.js';
+const TailwindEditor = () => {
+    const [showPanel, setShowPanel] = useState(false);
+    const [selectedElement, setSelectedElement] = useState(null);
+    const [originalClasses, setOriginalClasses] = useState([]);
+    const [currentClasses, setCurrentClasses] = useState([]);
+    const [selectionMode, setSelectionMode] = useState(false);
+    // Function to clear current selection - moved outside useEffect for reusability
+    const clearSelection = useCallback(() => {
+        if (selectedElement) {
+            // Reset the element to its original classes if panel was closed without applying
+            if (!showPanel) {
+                selectedElement.className = originalClasses.join(' ');
+            }
+            setSelectedElement(null);
+            setOriginalClasses([]);
+            setCurrentClasses([]);
+        }
+    }, [selectedElement, showPanel, originalClasses]);
+    useEffect(() => {
+        // Set up keyboard shortcuts
+        const toggleSelectionMode = (e) => {
+            // Alt+Shift+T to toggle selection mode
+            if (e.altKey && e.shiftKey && e.key === 'T') {
+                e.preventDefault();
+                setSelectionMode(prev => !prev);
+            }
+            // Escape to exit selection mode
+            if (e.key === 'Escape' && selectionMode) {
+                clearSelection();
+                setSelectionMode(false);
+            }
+        };
+        // Function to highlight elements on hover during selection mode
+        const highlightElement = (e) => {
+            if (!selectionMode)
+                return;
+            e.preventDefault();
+            e.stopPropagation();
+            const target = e.target;
+            // Check if the element has Astro source information
+            if (target && extractAstroSourceInfo(target)) {
+                // Add a highlight effect
+                target.style.outline = '2px solid #3b82f6';
+            }
+        };
+        // Function to remove highlight on mouseout
+        const removeHighlight = (e) => {
+            if (!selectionMode)
+                return;
+            const target = e.target;
+            if (target) {
+                target.style.outline = '';
+            }
+        };
+        // Function to select an element on click during selection mode
+        const selectElement = (e) => {
+            if (!selectionMode)
+                return;
+            e.preventDefault();
+            e.stopPropagation();
+            const target = e.target;
+            // Check if the element has Astro source information
+            const sourceInfo = target && extractAstroSourceInfo(target);
+            if (target && sourceInfo) {
+                setSelectedElement(target);
+                // Extract classes from the element
+                const classes = Array.from(target.classList);
+                setOriginalClasses(classes);
+                setCurrentClasses(classes);
+                // Exit selection mode and show editor panel
+                setSelectionMode(false);
+                setShowPanel(true);
+            }
+        };
+        // Add event listeners
+        document.addEventListener('keydown', toggleSelectionMode);
+        if (selectionMode) {
+            document.addEventListener('mouseover', highlightElement);
+            document.addEventListener('mouseout', removeHighlight);
+            document.addEventListener('click', selectElement);
+        }
+        // Clean up event listeners on unmount or when selectionMode changes
+        return () => {
+            document.removeEventListener('keydown', toggleSelectionMode);
+            document.removeEventListener('mouseover', highlightElement);
+            document.removeEventListener('mouseout', removeHighlight);
+            document.removeEventListener('click', selectElement);
+        };
+    }, [selectionMode, clearSelection]);
+    // Function to handle applying changes
+    const handleApplyChanges = async (changeSet) => {
+        if (changeSet.length === 0)
+            return;
+        try {
+            // Apply the changes to the actual files
+            const success = await applyChanges(changeSet);
+            if (success) {
+                console.log('Changes applied successfully!');
+                // Update the current classes
+                if (selectedElement) {
+                    const newClasses = Array.from(selectedElement.classList);
+                    setCurrentClasses(newClasses);
+                    setOriginalClasses(newClasses); // Update original classes to match new state
+                }
+            }
+            else {
+                console.error('Failed to apply changes.');
+            }
+        }
+        catch (error) {
+            console.error('Error applying changes:', error);
+        }
+    };
+    // Function to close the editor panel
+    const closePanel = () => {
+        setShowPanel(false);
+        clearSelection();
+    };
+    // Render selection mode indicator or editor panel
+    return (_jsxs(_Fragment, { children: [selectionMode && (_jsx("div", { style: {
+                    position: 'fixed',
+                    top: '20px',
+                    left: '20px',
+                    background: '#3b82f6',
+                    color: 'white',
+                    padding: '8px 16px',
+                    borderRadius: '4px',
+                    zIndex: 9999,
+                    boxShadow: '0 2px 5px rgba(0,0,0,0.2)',
+                    pointerEvents: 'none',
+                }, children: "Selection Mode: Click on an element to edit" })), showPanel && (_jsx(EditorPanel, { selectedElement: selectedElement, originalClasses: originalClasses, currentClasses: currentClasses, onApplyChanges: handleApplyChanges, onClose: closePanel })), _jsx("button", { id: "tailwind-editor-fab", onClick: () => setSelectionMode(prev => !prev), style: {
+                    position: 'fixed',
+                    bottom: '20px',
+                    right: '20px',
+                    background: selectionMode ? '#ef4444' : '#3b82f6',
+                    color: 'white',
+                    padding: '12px',
+                    borderRadius: '50%',
+                    width: '48px',
+                    height: '48px',
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    boxShadow: '0 2px 10px rgba(0,0,0,0.2)',
+                    cursor: 'pointer',
+                    zIndex: 9998,
+                    border: 'none',
+                }, title: selectionMode ? 'Exit Selection Mode' : 'Enter Selection Mode (Alt+Shift+T)', children: _jsx("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: _jsx("path", { d: "M12 2v20M2 12h20" }) }) })] }));
+};
+export default TailwindEditor;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/components/TailwindEditor/integration.d.ts

@@ -0,0 +1,3 @@
+import type { AstroIntegration } from 'astro';
+declare const tailwindEditor: () => AstroIntegration;
+export default tailwindEditor;

package/dist/components/TailwindEditor/integration.js

@@ -0,0 +1,18 @@
+import { fileURLToPath } from 'node:url';
+const tailwindEditor = () => {
+    return {
+        name: 'wix-tailwind-editor',
+        hooks: {
+            'astro:config:setup': ({ addDevToolbarApp }) => {
+                addDevToolbarApp({
+                    id: "wix-tailwind-editor",
+                    name: "Tailwind Editor",
+                    icon: "🎨",
+                    entrypoint: fileURLToPath(new URL('./dev-toolbar-app.js', import.meta.url))
+                });
+            },
+        },
+    };
+};
+export default tailwindEditor;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZWdyYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29tcG9uZW50cy9UYWlsd2luZEVkaXRvci9pbnRlZ3JhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBR3pDLE1BQU0sY0FBYyxHQUFHLEdBQXFCLEVBQUU7SUFDNUMsT0FBTztRQUNMLElBQUksRUFBRSxxQkFBcUI7UUFDM0IsS0FBSyxFQUFFO1lBQ0wsb0JBQW9CLEVBQUUsQ0FBQyxFQUFFLGdCQUFnQixFQUFFLEVBQUUsRUFBRTtnQkFDN0MsZ0JBQWdCLENBQUM7b0JBQ2YsRUFBRSxFQUFFLHFCQUFxQjtvQkFDekIsSUFBSSxFQUFFLGlCQUFpQjtvQkFDdkIsSUFBSSxFQUFFLElBQUk7b0JBQ1YsVUFBVSxFQUFFLGFBQWEsQ0FBQyxJQUFJLEdBQUcsQ0FBQyxzQkFBc0IsRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO2lCQUM1RSxDQUFDLENBQUM7WUFDTCxDQUFDO1NBQ0Y7S0FDRixDQUFDO0FBQ0osQ0FBQyxDQUFDO0FBRUYsZUFBZSxjQUFjLENBQUMifQ==

package/dist/components/TailwindEditor/types.d.ts

@@ -0,0 +1,35 @@
+export type ChangeSetItem = {
+    file: string;
+    line: number;
+    instruction: {
+        type: string;
+        delta?: {
+            added: string[];
+            removed: string[];
+        };
+        textContent?: string;
+        propName?: string;
+        path?: string;
+    };
+};
+export type ClassChangeInstruction = {
+    type: "class_change";
+    propName?: string;
+    path?: string;
+    builtinStyles?: string;
+    delta?: {
+        added: string[];
+        removed: string[];
+    };
+};
+export type TextChangeInstruction = {
+    type: "replace_text";
+    textContent: string;
+};
+export type SchemaMap = {
+    [componentName: string]: {
+        selectorToChangeInstruction: {
+            [selector: string]: ClassChangeInstruction;
+        };
+    };
+};

package/dist/components/TailwindEditor/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29tcG9uZW50cy9UYWlsd2luZEVkaXRvci90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/components/TailwindEditor/utils.d.ts

@@ -0,0 +1,22 @@
+import type { ChangeSetItem } from './types.js';
+import * as t from '@babel/types';
+export declare function calcFinalClasses(previous: string, changes: {
+    added: string[];
+    removed: string[];
+}): string;
+export declare function findNodeAtLine(ast: t.File, targetLine: number): null;
+export declare function hasCnImport(ast: t.File): boolean;
+export declare function addCnImportIfNotExist(ast: t.File): void;
+export declare function assignFinalValue(ast: t.File, previous: t.JSXAttribute | t.ObjectProperty, changes: {
+    added: string[];
+    removed: string[];
+}): boolean;
+export declare function updateComponentAttribute(node: t.JSXOpeningElement, delta: {
+    added: string[];
+    removed: string[];
+}, ast: t.File, propName?: string, path?: string): void;
+export declare function applyChanges(changeSet: ChangeSetItem[]): Promise<boolean>;
+export declare function extractAstroSourceInfo(element: HTMLElement): {
+    file: string;
+    line: number;
+} | null;

package/dist/components/TailwindEditor/utils.js

@@ -0,0 +1,234 @@
+import fs from 'fs/promises';
+import * as parser from '@babel/parser';
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import generate from '@babel/generator';
+// Helper function to calculate final classes
+export function calcFinalClasses(previous, changes) {
+    const currentClasses = previous.split(/\s+/);
+    const classesAfterRemoval = currentClasses.filter((cls) => !changes.removed.includes(cls));
+    return [...classesAfterRemoval, ...changes.added].filter(Boolean).join(' ');
+}
+// Helper function to find the node at a specific line number
+export function findNodeAtLine(ast, targetLine) {
+    let foundNode = null;
+    console.log(`[findNodeAtLine] Searching for JSX component at line ${targetLine}`);
+    // @ts-ignore - Traverse is actually callable but TypeScript doesn't recognize it correctly
+    traverse(ast, {
+        JSXOpeningElement(path) {
+            const loc = path.node.loc;
+            if (loc && loc.start.line === targetLine) {
+                console.log(`[findNodeAtLine] Found matching node:`, {
+                    type: path.node.type,
+                    name: path.node.name.type === 'JSXIdentifier'
+                        ? path.node.name.name
+                        : 'ComplexName',
+                    attributes: path.node.attributes.length,
+                });
+                foundNode = path.node;
+                path.stop();
+            }
+        },
+    });
+    return foundNode;
+}
+// Helper function to check if the file has the cn import
+export function hasCnImport(ast) {
+    let hasImport = false;
+    // @ts-ignore - Traverse is actually callable but TypeScript doesn't recognize it correctly
+    traverse(ast, {
+        ImportDeclaration(path) {
+            // Check if it's importing from utility file
+            if (t.isStringLiteral(path.node.source) &&
+                (path.node.source.value.includes('/utils') ||
+                    path.node.source.value.includes('/lib/utils'))) {
+                // Check if cn is among the imported specifiers
+                for (const specifier of path.node.specifiers) {
+                    if (t.isImportSpecifier(specifier) &&
+                        t.isIdentifier(specifier.imported) &&
+                        specifier.imported.name === 'cn') {
+                        hasImport = true;
+                        path.stop();
+                        break;
+                    }
+                }
+            }
+        },
+    });
+    return hasImport;
+}
+// Function to add cn import if not present
+export function addCnImportIfNotExist(ast) {
+    if (hasCnImport(ast)) {
+        return; // Already imported
+    }
+    // Create a new cn import specifier
+    const cnSpecifier = t.importSpecifier(t.identifier('cn'), t.identifier('cn'));
+    // Flag to track if we found and modified an existing import
+    let cnImportAdded = false;
+    // @ts-ignore - Traverse is actually callable but TypeScript doesn't recognize it correctly
+    traverse(ast, {
+        ImportDeclaration(path) {
+            if (t.isStringLiteral(path.node.source) &&
+                (path.node.source.value.includes('/utils') ||
+                    path.node.source.value.includes('/lib/utils'))) {
+                path.node.specifiers.push(cnSpecifier);
+                cnImportAdded = true;
+                path.stop();
+            }
+        },
+    });
+    // If we didn't find an existing import, add a new one
+    if (!cnImportAdded) {
+        const importDeclaration = t.importDeclaration([cnSpecifier], t.stringLiteral('./utils'));
+        // Add at the beginning of the file
+        if (ast.program.body.length > 0) {
+            ast.program.body.unshift(importDeclaration);
+        }
+        else {
+            ast.program.body.push(importDeclaration);
+        }
+    }
+}
+// Function to assign final class values
+export function assignFinalValue(ast, previous, changes) {
+    // Handle string literal
+    if (t.isStringLiteral(previous.value)) {
+        const str = previous.value.value;
+        let finalClasses = calcFinalClasses(str, changes);
+        if (finalClasses) {
+            previous.value = t.stringLiteral(finalClasses);
+            return true;
+        }
+        return false;
+    }
+    // Handle JSX expression container with string literal
+    if (t.isJSXExpressionContainer(previous.value) &&
+        t.isStringLiteral(previous.value.expression)) {
+        const str = previous.value.expression.value;
+        let finalClasses = calcFinalClasses(str, changes);
+        if (finalClasses) {
+            previous.value = t.jsxExpressionContainer(t.stringLiteral(finalClasses));
+            return true;
+        }
+        return false;
+    }
+    // Handle JSX expression container with cn call
+    if (t.isJSXExpressionContainer(previous.value)) {
+        const expression = previous.value.expression;
+        if (t.isCallExpression(expression) &&
+            t.isIdentifier(expression.callee) &&
+            expression.callee.name === 'cn') {
+            if (expression.arguments.length > 0 &&
+                t.isStringLiteral(expression.arguments[expression.arguments.length - 1])) {
+                // If it's already a cn call with a string as last argument, append to that string
+                const lastArg = expression.arguments[expression.arguments.length - 1];
+                const newString = calcFinalClasses(lastArg.value, changes);
+                if (newString) {
+                    expression.arguments[expression.arguments.length - 1] =
+                        t.stringLiteral(newString);
+                }
+                else {
+                    // Remove the last argument if it becomes empty
+                    expression.arguments.pop();
+                }
+            }
+            else {
+                // Otherwise add a new string literal argument
+                if (changes.added.length > 0) {
+                    expression.arguments.push(t.stringLiteral(changes.added.join(' ')));
+                }
+            }
+            return true;
+        }
+        else if (t.isExpression(expression)) {
+            // It's another expression, wrap it in cn call
+            addCnImportIfNotExist(ast);
+            if (changes.added.length > 0) {
+                previous.value = t.jsxExpressionContainer(t.callExpression(t.identifier('cn'), [
+                    expression,
+                    t.stringLiteral(changes.added.join(' ')),
+                ]));
+                return true;
+            }
+        }
+    }
+    return false;
+}
+// Function to update component attributes
+export function updateComponentAttribute(node, delta, ast, propName = 'className', path) {
+    let attr = node.attributes.find((attr) => t.isJSXAttribute(attr) &&
+        t.isJSXIdentifier(attr.name) &&
+        attr.name.name === propName);
+    if (!attr) {
+        // If attribute doesn't exist, create it
+        attr = t.jsxAttribute(t.jsxIdentifier(propName), t.stringLiteral(''));
+        node.attributes.push(attr);
+    }
+    // Update the attribute directly if no path is provided
+    if (!path) {
+        assignFinalValue(ast, attr, delta);
+    }
+    else {
+        // Path handling would go here, but that's a more complex case
+        // Simplified for this implementation
+        console.log(`Path-based updates not fully implemented: ${path}`);
+    }
+}
+// Function to handle applying changes to a file
+export async function applyChanges(changeSet) {
+    try {
+        for (const change of changeSet) {
+            const fileContent = await fs.readFile(change.file, 'utf-8');
+            // Parse the file with Babel
+            const ast = parser.parse(fileContent, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript'],
+            });
+            if (change.instruction.type === 'class_change') {
+                const node = findNodeAtLine(ast, change.line);
+                if (!node) {
+                    console.error(`Could not find node at line ${change.line} in ${change.file}`);
+                    continue;
+                }
+                const propName = change.instruction.propName || 'className';
+                const delta = change.instruction.delta || { added: [], removed: [] };
+                updateComponentAttribute(node, delta, ast, propName, change.instruction.path);
+            }
+            else if (change.instruction.type === 'replace_text') {
+                // Text replacement would go here
+                console.log('Text replacement not implemented yet');
+            }
+            // Generate the updated code
+            // @ts-ignore - Generate is actually callable but TypeScript doesn't recognize it correctly
+            const output = generate(ast);
+            // Write the changes back to the file
+            await fs.writeFile(change.file, output.code, 'utf-8');
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Error applying changes:', error);
+        return false;
+    }
+}
+// Extract Astro source information from DOM elements
+export function extractAstroSourceInfo(element) {
+    // Astro adds source information in a data attribute like data-astro-source="path:line:column"
+    const sourceAttr = element.getAttribute('data-astro-source');
+    if (!sourceAttr) {
+        return null;
+    }
+    const parts = sourceAttr.split(':');
+    if (parts.length < 2) {
+        return null;
+    }
+    const file = parts[0];
+    const lineStr = parts[1] || '1'; // Default to line 1 if not found
+    const line = parseInt(lineStr, 10);
+    if (!file || isNaN(line)) {
+        return null;
+    }
+    return { file, line };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/components/TailwindEditor/utils.ts"],"names":[],"mappings":"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"}

package/dist/components/login-helpers/bi-header-generator.d.ts

@@ -0,0 +1,11 @@
+import { APIMetadata, PublicMetadata } from '@wix/sdk-types';
+export declare const WixBIHeaderName = "x-wix-bi-gateway";
+export type WixBIHeaderValues = {
+    ['environment']: 'js-sdk' | string;
+    ['package-name']?: string;
+    ['method-fqn']?: string;
+    ['entity']?: string;
+};
+export declare function biHeaderGenerator(apiMetadata: APIMetadata, publicMetadata?: PublicMetadata, environment?: string): {
+    [WixBIHeaderName]: string;
+};

package/dist/components/login-helpers/bi-header-generator.js

@@ -0,0 +1,18 @@
+export const WixBIHeaderName = 'x-wix-bi-gateway';
+export function biHeaderGenerator(apiMetadata, publicMetadata, environment) {
+    return {
+        [WixBIHeaderName]: objectToKeyValue({
+            environment: `js-sdk${environment ? `-${environment}` : ``}`,
+            'package-name': apiMetadata.packageName ?? publicMetadata?.PACKAGE_NAME,
+            'method-fqn': apiMetadata.methodFqn,
+            entity: apiMetadata.entityFqdn,
+        }),
+    };
+}
+function objectToKeyValue(input) {
+    return Object.entries(input)
+        .filter(([_, value]) => Boolean(value))
+        .map(([key, value]) => `${key}=${value}`)
+        .join(',');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmktaGVhZGVyLWdlbmVyYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2NvbXBvbmVudHMvbG9naW4taGVscGVycy9iaS1oZWFkZXItZ2VuZXJhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxrQkFBa0IsQ0FBQztBQVNsRCxNQUFNLFVBQVUsaUJBQWlCLENBQy9CLFdBQXdCLEVBQ3hCLGNBQStCLEVBQy9CLFdBQW9CO0lBRXBCLE9BQU87UUFDTCxDQUFDLGVBQWUsQ0FBQyxFQUFFLGdCQUFnQixDQUFDO1lBQ2xDLFdBQVcsRUFBRSxTQUFTLFdBQVcsQ0FBQyxDQUFDLENBQUMsSUFBSSxXQUFXLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFO1lBQzVELGNBQWMsRUFBRSxXQUFXLENBQUMsV0FBVyxJQUFJLGNBQWMsRUFBRSxZQUFZO1lBQ3ZFLFlBQVksRUFBRSxXQUFXLENBQUMsU0FBUztZQUNuQyxNQUFNLEVBQUUsV0FBVyxDQUFDLFVBQVU7U0FDL0IsQ0FBQztLQUNILENBQUM7QUFDSixDQUFDO0FBRUQsU0FBUyxnQkFBZ0IsQ0FBQyxLQUF3QjtJQUNoRCxPQUFPLE1BQU0sQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDO1NBQ3pCLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLEtBQUssQ0FBQyxFQUFFLEVBQUUsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7U0FDdEMsR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsR0FBRyxJQUFJLEtBQUssRUFBRSxDQUFDO1NBQ3hDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNmLENBQUMifQ==

package/dist/components/login-helpers/iframeUtils.d.ts

@@ -0,0 +1,4 @@
+export declare function addListener(eventTarget: any, name: string, fn: Function): void;
+export declare function removeListener(eventTarget: any, name: string, fn: Function): void;
+export declare function loadFrame(src: string): HTMLIFrameElement;
+export declare function addPostMessageListener(state: string): Promise<unknown>;

package/dist/components/login-helpers/iframeUtils.js

@@ -0,0 +1,44 @@
+export function addListener(eventTarget, name, fn) {
+    if (eventTarget.addEventListener) {
+        eventTarget.addEventListener(name, fn);
+    }
+    else {
+        eventTarget.attachEvent('on' + name, fn);
+    }
+}
+export function removeListener(eventTarget, name, fn) {
+    if (eventTarget.removeEventListener) {
+        eventTarget.removeEventListener(name, fn);
+    }
+    else {
+        eventTarget.detachEvent('on' + name, fn);
+    }
+}
+export function loadFrame(src) {
+    const iframe = document.createElement('iframe');
+    iframe.style.display = 'none';
+    iframe.src = src;
+    return document.body.appendChild(iframe);
+}
+export function addPostMessageListener(state) {
+    let responseHandler;
+    let timeoutId;
+    const msgReceivedOrTimeout = new Promise((resolve, reject) => {
+        responseHandler = (e) => {
+            if (!e.data || e.data.state !== state) {
+                // A message not meant for us
+                return;
+            }
+            resolve(e.data);
+        };
+        addListener(window, 'message', responseHandler);
+        timeoutId = setTimeout(() => {
+            reject(new Error('OAuth flow timed out'));
+        }, 120000);
+    });
+    return msgReceivedOrTimeout.finally(() => {
+        clearTimeout(timeoutId);
+        removeListener(window, 'message', responseHandler);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/components/login-helpers/login-helpers.d.ts

@@ -0,0 +1,39 @@
+export interface OauthPKCE {
+    codeVerifier: string;
+    codeChallenge: string;
+    state: string;
+}
+export interface OauthData extends OauthPKCE {
+    originalUri: string;
+    redirectUri: string;
+}
+export interface OauthPKCE {
+    codeVerifier: string;
+    codeChallenge: string;
+    state: string;
+}
+export interface Token {
+    value: string;
+}
+export interface AccessToken extends Token {
+    expiresAt: number;
+}
+export declare enum TokenRole {
+    NONE = "none",
+    VISITOR = "visitor",
+    MEMBER = "member"
+}
+export interface TokenResponse {
+    access_token: string;
+    expires_in: number;
+    refresh_token: string | null;
+    token_type: string;
+    scope?: string | null;
+}
+export declare const getMemberTokensForDirectLogin: (sessionToken: string) => Promise<{
+    accessToken: AccessToken;
+    refreshToken: {
+        value: string;
+        role: TokenRole;
+    };
+}>;