@panneau/display-link 3.0.142

package/es/index.js

@@ -0,0 +1,55 @@
+import get from 'lodash/get';
+import PropTypes from 'prop-types';
+import React from 'react';
+import { FormattedMessage } from 'react-intl';
+import { Link as Link$2 } from 'wouter';
+
+var propTypes = {
+  item: PropTypes.shape({
+    id: PropTypes.oneOfType([PropTypes.string, PropTypes.number])
+  }),
+  value: PropTypes.string,
+  label: PropTypes.string,
+  labelPath: PropTypes.string,
+  external: PropTypes.bool,
+  target: PropTypes.string,
+  placeholder: PropTypes.oneOfType([PropTypes.node, PropTypes.string])
+};
+var defaultProps = {
+  item: null,
+  value: null,
+  label: null,
+  labelPath: null,
+  external: false,
+  target: null,
+  placeholder: null
+};
+var Link = function Link(_ref) {
+  var item = _ref.item,
+    label = _ref.label,
+    labelPath = _ref.labelPath,
+    value = _ref.value,
+    external = _ref.external,
+    target = _ref.target,
+    placeholder = _ref.placeholder;
+  var itemLabel = get(item, labelPath);
+  var finalValue = itemLabel || label || placeholder || /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: "e0xuLo",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Link"
+    }]
+  });
+  return external ? /*#__PURE__*/React.createElement("a", {
+    href: value,
+    target: target || '_blank',
+    rel: "noopener noreferrer"
+  }, finalValue) : /*#__PURE__*/React.createElement(Link$2, {
+    href: value
+  }, finalValue);
+};
+Link.propTypes = propTypes;
+Link.defaultProps = defaultProps;
+var Link$1 = Link;
+
+export { Link$1 as default };

package/lib/index.js

@@ -0,0 +1,339 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var get = require('lodash/get');
+var PropTypes = require('prop-types');
+var React = require('react');
+var reactIntl = require('react-intl');
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var regexparam = require('regexparam');
+var index_js = require('use-sync-external-store/shim/index.js');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+// React.useInsertionEffect is not available in React <18
+var useEffect = React__namespace.useEffect,
+  useLayoutEffect = React__namespace.useLayoutEffect,
+  useRef = React__namespace.useRef,
+  useBuiltinInsertionEffect = React__namespace.useInsertionEffect;
+
+// Copied from:
+// https://github.com/facebook/react/blob/main/packages/shared/ExecutionEnvironment.js
+var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+
+// Copied from:
+// https://github.com/reduxjs/react-redux/blob/master/src/utils/useIsomorphicLayoutEffect.ts
+// "React currently throws a warning when using useLayoutEffect on the server.
+// To get around it, we can conditionally useEffect on the server (no-op) and
+// useLayoutEffect in the browser."
+var useIsomorphicLayoutEffect = canUseDOM ? useLayoutEffect : useEffect;
+
+// useInsertionEffect is already a noop on the server.
+// See: https://github.com/facebook/react/blob/main/packages/react-server/src/ReactFizzHooks.js
+var useInsertionEffect = useBuiltinInsertionEffect || useIsomorphicLayoutEffect;
+
+// Userland polyfill while we wait for the forthcoming
+// https://github.com/reactjs/rfcs/blob/useevent/text/0000-useevent.md
+// Note: "A high-fidelity polyfill for useEvent is not possible because
+// there is no lifecycle or Hook in React that we can use to switch
+// .current at the right timing."
+// So we will have to make do with this "close enough" approach for now.
+var useEvent = function useEvent(fn) {
+  var ref = useRef([fn, function () {
+    return ref[0].apply(ref, arguments);
+  }]).current;
+  // Per Dan Abramov: useInsertionEffect executes marginally closer to the
+  // correct timing for ref synchronization than useLayoutEffect on React 18.
+  // See: https://github.com/facebook/react/pull/25881#issuecomment-1356244360
+  useInsertionEffect(function () {
+    ref[0] = fn;
+  });
+  return ref[1];
+};
+
+/**
+ * History API docs @see https://developer.mozilla.org/en-US/docs/Web/API/History
+ */
+var eventPopstate = "popstate";
+var eventPushState = "pushState";
+var eventReplaceState = "replaceState";
+var eventHashchange = "hashchange";
+var events = [eventPopstate, eventPushState, eventReplaceState, eventHashchange];
+var subscribeToLocationUpdates = function subscribeToLocationUpdates(callback) {
+  for (var _i = 0, _events = events; _i < _events.length; _i++) {
+    var event = _events[_i];
+    addEventListener(event, callback);
+  }
+  return function () {
+    for (var _i2 = 0, _events2 = events; _i2 < _events2.length; _i2++) {
+      var _event = _events2[_i2];
+      removeEventListener(_event, callback);
+    }
+  };
+};
+var useLocationProperty = function useLocationProperty(fn, ssrFn) {
+  return index_js.useSyncExternalStore(subscribeToLocationUpdates, fn, ssrFn);
+};
+var currentSearch = function currentSearch() {
+  return location.search;
+};
+var useSearch = function useSearch() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref$ssrSearch = _ref.ssrSearch,
+    ssrSearch = _ref$ssrSearch === void 0 ? "" : _ref$ssrSearch;
+  return useLocationProperty(currentSearch, function () {
+    return ssrSearch;
+  });
+};
+var currentPathname = function currentPathname() {
+  return location.pathname;
+};
+var usePathname = function usePathname() {
+  var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    ssrPath = _ref2.ssrPath;
+  return useLocationProperty(currentPathname, ssrPath ? function () {
+    return ssrPath;
+  } : currentPathname);
+};
+var navigate = function navigate(to) {
+  var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref3$replace = _ref3.replace,
+    replace = _ref3$replace === void 0 ? false : _ref3$replace,
+    _ref3$state = _ref3.state,
+    state = _ref3$state === void 0 ? null : _ref3$state;
+  return history[replace ? eventReplaceState : eventPushState](state, "", to);
+};
+
+// the 2nd argument of the `useBrowserLocation` return value is a function
+// that allows to perform a navigation.
+var useBrowserLocation = function useBrowserLocation() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return [usePathname(opts), navigate];
+};
+var patchKey = Symbol["for"]("wouter_v3");
+
+// While History API does have `popstate` event, the only
+// proper way to listen to changes via `push/replaceState`
+// is to monkey-patch these methods.
+//
+// See https://stackoverflow.com/a/4585031
+if (typeof history !== "undefined" && typeof window[patchKey] === "undefined") {
+  var _loop = function _loop() {
+    var type = _arr[_i3];
+    var original = history[type];
+    // TODO: we should be using unstable_batchedUpdates to avoid multiple re-renders,
+    // however that will require an additional peer dependency on react-dom.
+    // See: https://github.com/reactwg/react-18/discussions/86#discussioncomment-1567149
+    history[type] = function () {
+      var result = original.apply(this, arguments);
+      var event = new Event(type);
+      event.arguments = arguments;
+      dispatchEvent(event);
+      return result;
+    };
+  };
+  for (var _i3 = 0, _arr = [eventPushState, eventReplaceState]; _i3 < _arr.length; _i3++) {
+    _loop();
+  }
+
+  // patch history object only once
+  // See: https://github.com/molefrog/wouter/issues/167
+  Object.defineProperty(window, patchKey, {
+    value: true
+  });
+}
+
+var _excluded3 = ["to", "href", "onClick", "asChild", "children", "className", "replace", "state"];
+
+/*
+ * Transforms `path` into its relative `base` version
+ * If base isn't part of the path provided returns absolute path e.g. `~/app`
+ */
+var relativePath = function relativePath() {
+  var base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+  var path = arguments.length > 1 ? arguments[1] : undefined;
+  return !path.toLowerCase().indexOf(base.toLowerCase()) ? path.slice(base.length) || "/" : "~" + path;
+};
+var absolutePath = function absolutePath(to) {
+  var base = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+  return to[0] === "~" ? to.slice(1) : base + to;
+};
+
+/*
+ * decodes escape sequences such as %20
+ */
+var unescape = function unescape(str) {
+  try {
+    return decodeURI(str);
+  } catch (_e) {
+    // fail-safe mode: if string can't be decoded do nothing
+    return str;
+  }
+};
+
+/*
+ * Router and router context. Router is a lightweight object that represents the current
+ * routing options: how location is managed, base path etc.
+ *
+ * There is a default router present for most of the use cases, however it can be overridden
+ * via the <Router /> component.
+ */
+
+var defaultRouter = {
+  hook: useBrowserLocation,
+  searchHook: useSearch,
+  parser: regexparam.parse,
+  base: "",
+  // this option is used to override the current location during SSR
+  ssrPath: undefined,
+  ssrSearch: undefined,
+  // customizes how `href` props are transformed for <Link />
+  hrefs: function hrefs(x) {
+    return x;
+  }
+};
+var RouterCtx = React.createContext(defaultRouter);
+
+// gets the closest parent router from the context
+var useRouter = function useRouter() {
+  return React.useContext(RouterCtx);
+};
+
+/**
+ * Parameters context. Used by `useParams()` to get the
+ * matched params from the innermost `Route` component.
+ */
+
+React.createContext({});
+
+/*
+ * Part 1, Hooks API: useRoute and useLocation
+ */
+
+// Internal version of useLocation to avoid redundant useRouter calls
+
+var useLocationFromRouter = function useLocationFromRouter(router) {
+  var _router$hook = router.hook(router),
+    _router$hook2 = _slicedToArray(_router$hook, 2),
+    location = _router$hook2[0],
+    navigate = _router$hook2[1];
+
+  // the function reference should stay the same between re-renders, so that
+  // it can be passed down as an element prop without any performance concerns.
+  // (This is achieved via `useEvent`.)
+  return [unescape(relativePath(router.base, location)), useEvent(function (to, navOpts) {
+    return navigate(absolutePath(to, router.base), navOpts);
+  })];
+};
+var Link$2 = React.forwardRef(function (props, ref) {
+  var router = useRouter();
+  var _useLocationFromRoute3 = useLocationFromRouter(router),
+    _useLocationFromRoute4 = _slicedToArray(_useLocationFromRoute3, 2),
+    path = _useLocationFromRoute4[0],
+    navigate = _useLocationFromRoute4[1];
+  var to = props.to,
+    _props$href = props.href,
+    _href = _props$href === void 0 ? to : _props$href,
+    _onClick = props.onClick,
+    asChild = props.asChild,
+    children = props.children,
+    cls = props.className;
+    props.replace;
+    props.state;
+    var restProps = _objectWithoutProperties(props, _excluded3);
+  var onClick = useEvent(function (event) {
+    // ignores the navigation when clicked using right mouse button or
+    // by holding a special modifier key: ctrl, command, win, alt, shift
+    if (event.ctrlKey || event.metaKey || event.altKey || event.shiftKey || event.button !== 0) return;
+    _onClick === null || _onClick === void 0 || _onClick(event);
+    if (!event.defaultPrevented) {
+      event.preventDefault();
+      navigate(_href, props);
+    }
+  });
+
+  // handle nested routers and absolute paths
+  var href = router.hrefs(_href[0] === "~" ? _href.slice(1) : router.base + _href, router // pass router as a second argument for convinience
+  );
+  return asChild && React.isValidElement(children) ? React.cloneElement(children, {
+    onClick: onClick,
+    href: href
+  }) : React.createElement("a", _objectSpread(_objectSpread({}, restProps), {}, {
+    onClick: onClick,
+    href: href,
+    // `className` can be a function to apply the class if this link is active
+    className: cls !== null && cls !== void 0 && cls.call ? cls(path === href) : cls,
+    children: children,
+    ref: ref
+  }));
+});
+
+var propTypes = {
+  item: PropTypes.shape({
+    id: PropTypes.oneOfType([PropTypes.string, PropTypes.number])
+  }),
+  value: PropTypes.string,
+  label: PropTypes.string,
+  labelPath: PropTypes.string,
+  external: PropTypes.bool,
+  target: PropTypes.string,
+  placeholder: PropTypes.oneOfType([PropTypes.node, PropTypes.string])
+};
+var defaultProps = {
+  item: null,
+  value: null,
+  label: null,
+  labelPath: null,
+  external: false,
+  target: null,
+  placeholder: null
+};
+var Link = function Link(_ref) {
+  var item = _ref.item,
+    label = _ref.label,
+    labelPath = _ref.labelPath,
+    value = _ref.value,
+    external = _ref.external,
+    target = _ref.target,
+    placeholder = _ref.placeholder;
+  var itemLabel = get(item, labelPath);
+  var finalValue = itemLabel || label || placeholder || /*#__PURE__*/React.createElement(reactIntl.FormattedMessage, {
+    id: "e0xuLo",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Link"
+    }]
+  });
+  return external ? /*#__PURE__*/React.createElement("a", {
+    href: value,
+    target: target || '_blank',
+    rel: "noopener noreferrer"
+  }, finalValue) : /*#__PURE__*/React.createElement(Link$2, {
+    href: value
+  }, finalValue);
+};
+Link.propTypes = propTypes;
+Link.defaultProps = defaultProps;
+var Link$1 = Link;
+
+exports.default = Link$1;

package/package.json

@@ -0,0 +1,60 @@
+{
+    "name": "@panneau/display-link",
+    "version": "3.0.142",
+    "description": "Link item value in list",
+    "keywords": [
+        "javascript"
+    ],
+    "homepage": "https://github.com/folkloreinc/panneau-js",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/folkloreinc/panneau-js.git"
+    },
+    "author": {
+        "name": "Folklore",
+        "email": "info@folklore.email"
+    },
+    "contributors": [
+        {
+            "name": "David Mongeau-Petitpas",
+            "email": "dmp@folklore.email"
+        },
+        {
+            "name": "Nicolas Roy-Bourdages",
+            "email": "nrb@folklore.email"
+        }
+    ],
+    "license": "ISC",
+    "main": "lib/index.js",
+    "module": "es/index.js",
+    "files": [
+        "lib",
+        "es",
+        "assets"
+    ],
+    "scripts": {
+        "prepublishOnly": "npm run build",
+        "build": "../../scripts/prepare-package.sh"
+    },
+    "devDependencies": {
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
+        "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0"
+    },
+    "peerDependencies": {
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
+        "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0"
+    },
+    "dependencies": {
+        "@babel/runtime": "^7.12.5",
+        "@panneau/core": "^3.0.142",
+        "@panneau/themes": "^3.0.142",
+        "lodash": "^4.17.21",
+        "prop-types": "^15.7.2",
+        "react-intl": "^5.15.8||^6.0.0",
+        "wouter": "^3.1.0"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "gitHead": "293308a0e1b7175dcc56128f6dbc1416845d0b15"
+}