@1771technologies/lytenyte-pro
Version:
325 lines (324 loc) • 8.09 kB
JavaScript
import * as React from "react";
import { m as mergeProps, P as PropTypes } from "./proptypes-BjYr2nFr.js";
import { jsx } from "react/jsx-runtime";
function getStyleHookProps(state, customMapping) {
let props = {};
Object.entries(state).forEach(([key, value]) => {
if (customMapping?.hasOwnProperty(key)) {
const customProps = customMapping[key](value);
if (customProps != null) {
props = {
...props,
...customProps
};
}
return;
}
if (value === true) {
props[`data-${key.toLowerCase()}`] = "";
} else if (value) {
props[`data-${key.toLowerCase()}`] = value.toString();
}
});
return props;
}
function resolveClassName(className, state) {
return typeof className === "function" ? className(state) : className;
}
function evaluateRenderProp(render, props, state) {
return typeof render === "function" ? render(props, state) : /* @__PURE__ */ React.cloneElement(render, {
...mergeProps(props, render.props),
ref: props.ref
});
}
function useForkRef(...refs) {
const cleanupRef = React.useRef(void 0);
const refEffect = React.useCallback((instance) => {
const cleanups = refs.map((ref) => {
if (ref == null) {
return null;
}
if (typeof ref === "function") {
const refCallback = ref;
const refCleanup = refCallback(instance);
return typeof refCleanup === "function" ? refCleanup : () => {
refCallback(null);
};
}
ref.current = instance;
return () => {
ref.current = null;
};
});
return () => {
cleanups.forEach((refCleanup) => refCleanup?.());
};
}, refs);
return React.useMemo(() => {
if (refs.every((ref) => ref == null)) {
return null;
}
return (value) => {
if (cleanupRef.current) {
cleanupRef.current();
cleanupRef.current = void 0;
}
if (value != null) {
cleanupRef.current = refEffect(value);
}
};
}, refs);
}
const majorVersion = parseInt(React.version, 10);
function isReactVersionAtLeast(reactVersionToCheck) {
return majorVersion >= reactVersionToCheck;
}
function useRenderPropForkRef(render, ...refs) {
let childRef;
if (typeof render !== "function") {
childRef = isReactVersionAtLeast(19) ? render.props.ref : render.ref;
} else {
childRef = null;
}
return useForkRef(childRef, ...refs);
}
const defaultRenderFunctions = {
button: (props) => {
return /* @__PURE__ */ jsx("button", {
type: "button",
...props
});
},
div: (props) => {
return /* @__PURE__ */ jsx("div", {
...props
});
},
h2: (props) => {
return /* @__PURE__ */ jsx("h2", {
...props
});
},
h3: (props) => {
return /* @__PURE__ */ jsx("h3", {
...props
});
},
output: (props) => {
return /* @__PURE__ */ jsx("output", {
...props
});
},
p: (props) => {
return /* @__PURE__ */ jsx("p", {
...props
});
},
span: (props) => {
return /* @__PURE__ */ jsx("span", {
...props
});
},
a: (props) => {
return /* @__PURE__ */ jsx("a", {
...props
});
},
label: (props) => {
return /* @__PURE__ */ jsx("label", {
...props
});
},
input: (props) => {
return /* @__PURE__ */ jsx("input", {
...props
});
},
fieldset: (props) => {
return /* @__PURE__ */ jsx("fieldset", {
...props
});
},
form: (props) => {
return /* @__PURE__ */ jsx("form", {
...props
});
},
img: (props) => {
return /* @__PURE__ */ jsx("img", {
alt: "",
...props
});
}
};
const emptyObject = {};
function useComponentRenderer(settings) {
const {
render: renderProp,
className: classNameProp,
state,
ref,
propGetter = (props) => props,
extraProps,
customStyleHookMapping,
styleHooks: generateStyleHooks = true
} = settings;
const className = resolveClassName(classNameProp, state);
const styleHooks = React.useMemo(() => {
if (!generateStyleHooks) {
return emptyObject;
}
return getStyleHookProps(state, customStyleHookMapping);
}, [state, customStyleHookMapping, generateStyleHooks]);
const ownProps = {
...styleHooks,
...extraProps
};
let resolvedRenderProp;
if (typeof renderProp === "string") {
resolvedRenderProp = defaultRenderFunctions[renderProp];
} else {
resolvedRenderProp = renderProp;
}
let refs = [];
if (ref !== void 0) {
refs = Array.isArray(ref) ? ref : [ref];
}
const renderedElementProps = propGetter(ownProps);
const propsWithRef = {
...renderedElementProps,
ref: useRenderPropForkRef(resolvedRenderProp, renderedElementProps.ref, ...refs)
};
if (className !== void 0) {
propsWithRef.className = className;
}
const renderElement = () => evaluateRenderProp(resolvedRenderProp, propsWithRef, state);
return {
renderElement
};
}
const TRIGGER_HOOK = {
"data-popup-open": ""
};
const PRESSABLE_TRIGGER_HOOK = {
"data-popup-open": "",
"data-pressed": ""
};
const POPUP_OPEN_HOOK = {
"data-open": ""
};
const POPUP_CLOSED_HOOK = {
"data-closed": ""
};
const ANCHOR_HIDDEN_HOOK = {
"data-anchor-hidden": ""
};
const triggerOpenStateMapping = {
open(value) {
if (value) {
return TRIGGER_HOOK;
}
return null;
}
};
const pressableTriggerOpenStateMapping = {
open(value) {
if (value) {
return PRESSABLE_TRIGGER_HOOK;
}
return null;
}
};
const popupStateMapping = {
open(value) {
if (value) {
return POPUP_OPEN_HOOK;
}
return POPUP_CLOSED_HOOK;
},
anchorHidden(value) {
if (value) {
return ANCHOR_HIDDEN_HOOK;
}
return null;
}
};
const STARTING_HOOK = {
"data-starting-style": ""
};
const ENDING_HOOK = {
"data-ending-style": ""
};
const transitionStatusMapping = {
transitionStatus(value) {
if (value === "starting") {
return STARTING_HOOK;
}
if (value === "ending") {
return ENDING_HOOK;
}
return null;
}
};
let globalId = 0;
function useGlobalId(idOverride, prefix = "mui") {
const [defaultId, setDefaultId] = React.useState(idOverride);
const id = idOverride || defaultId;
React.useEffect(() => {
if (defaultId == null) {
globalId += 1;
setDefaultId(`${prefix}-${globalId}`);
}
}, [defaultId, prefix]);
return id;
}
const safeReact = {
...React
};
const maybeReactUseId = safeReact.useId;
function useId(idOverride, prefix) {
if (maybeReactUseId !== void 0) {
const reactId = maybeReactUseId();
return idOverride ?? `${prefix}-${reactId}`;
}
return useGlobalId(idOverride, prefix);
}
function useBaseUiId(idOverride) {
return useId(idOverride, "base-ui");
}
const InternalBackdrop = /* @__PURE__ */ React.forwardRef(function InternalBackdrop2(props, ref) {
return /* @__PURE__ */ jsx("div", {
ref,
role: "presentation",
"data-floating-ui-inert": true,
...props,
style: {
position: "fixed",
inset: 0
}
});
});
process.env.NODE_ENV !== "production" ? InternalBackdrop.propTypes = {
// ┌────────────────────────────── Warning ──────────────────────────────┐
// │ These PropTypes are generated from the TypeScript type definitions. │
// │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
// └─────────────────────────────────────────────────────────────────────┘
/**
* @ignore
*/
children: PropTypes.node,
/**
* @ignore
*/
className: PropTypes.string
} : void 0;
export {
InternalBackdrop as I,
useComponentRenderer as a,
useBaseUiId as b,
pressableTriggerOpenStateMapping as c,
triggerOpenStateMapping as d,
popupStateMapping as p,
transitionStatusMapping as t,
useForkRef as u
};