ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/prod/packages/@ember/routing/lib/routing-service.js

@@ -0,0 +1,125 @@
+import { getOwner } from '../../-internals/owner/index.js';
+import '../../-internals/environment/index.js';
+import '../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../../@glimmer/validator/index.js';
+import '../../../shared-chunks/reference-BNqcwZWH.js';
+import '../../../shared-chunks/capabilities-DGmQ_mz4.js';
+import '../../../shared-chunks/observers-R1ZklwWy.js';
+import { readOnly } from '../../object/lib/computed/computed_macros.js';
+import '../../object/index.js';
+import '../../object/core.js';
+import '../../-internals/runtime/lib/mixins/registry_proxy.js';
+import '../../-internals/runtime/lib/mixins/container_proxy.js';
+import '../../-internals/runtime/lib/mixins/comparable.js';
+import '../../-internals/runtime/lib/mixins/action_handler.js';
+import '../../-internals/runtime/lib/mixins/-proxy.js';
+import '../../enumerable/mutable.js';
+import '../../-internals/runtime/lib/mixins/target_action_support.js';
+import '../../-internals/runtime/lib/ext/rsvp.js';
+import '../../array/index.js';
+import Service from '../../service/index.js';
+import '../router.js';
+import { ROUTER } from '../router-service.js';
+
+/**
+@module ember
+*/
+
+
+/**
+  The Routing service is used by LinkTo, and provides facilities for
+  the component/view layer to interact with the router.
+
+  This is a private service for internal usage only. For public usage,
+  refer to the `Router` service.
+
+  @private
+  @class RoutingService
+*/
+class RoutingService extends Service {
+  [ROUTER];
+  get router() {
+    let router = this[ROUTER];
+    if (router !== undefined) {
+      return router;
+    }
+    let owner = getOwner(this);
+    let _router = owner.lookup('router:main');
+    _router.setupRouter();
+    return this[ROUTER] = _router;
+  }
+  hasRoute(routeName) {
+    return this.router.hasRoute(routeName);
+  }
+  transitionTo(routeName, models, queryParams, shouldReplace) {
+    let transition = this.router._doTransition(routeName, models, queryParams);
+    if (shouldReplace) {
+      transition.method('replace');
+    }
+    return transition;
+  }
+  normalizeQueryParams(routeName, models, queryParams) {
+    this.router._prepareQueryParams(routeName, models, queryParams);
+  }
+  _generateURL(routeName, models, queryParams) {
+    let visibleQueryParams = {};
+    if (queryParams) {
+      Object.assign(visibleQueryParams, queryParams);
+      this.normalizeQueryParams(routeName, models, visibleQueryParams);
+    }
+    return this.router.generate(routeName, ...models, {
+      queryParams: visibleQueryParams
+    });
+  }
+  generateURL(routeName, models, queryParams) {
+    if (this.router._initialTransitionStarted) {
+      return this._generateURL(routeName, models, queryParams);
+    } else {
+      // Swallow error when transition has not started.
+      // When rendering in tests without visit(), we cannot infer the route context which <LinkTo/> needs be aware of
+      try {
+        return this._generateURL(routeName, models, queryParams);
+      } catch (_e) {
+        return;
+      }
+    }
+  }
+  isActiveForRoute(contexts, queryParams, routeName, routerState) {
+    let handlers = this.router._routerMicrolib.recognizer.handlersFor(routeName);
+    let leafName = handlers[handlers.length - 1].handler;
+    let maximumContexts = numberOfContextsAcceptedByHandler(routeName, handlers);
+
+    // NOTE: any ugliness in the calculation of activeness is largely
+    // due to the fact that we support automatic normalizing of
+    // `resource` -> `resource.index`, even though there might be
+    // dynamic segments / query params defined on `resource.index`
+    // which complicates (and makes somewhat ambiguous) the calculation
+    // of activeness for links that link to `resource` instead of
+    // directly to `resource.index`.
+
+    // if we don't have enough contexts revert back to full route name
+    // this is because the leaf route will use one of the contexts
+    if (contexts.length > maximumContexts) {
+      routeName = leafName;
+    }
+    return routerState.isActiveIntent(routeName, contexts, queryParams);
+  }
+}
+RoutingService.reopen({
+  targetState: readOnly('router.targetState'),
+  currentState: readOnly('router.currentState'),
+  currentRouteName: readOnly('router.currentRouteName'),
+  currentPath: readOnly('router.currentPath')
+});
+function numberOfContextsAcceptedByHandler(handlerName, handlerInfos) {
+  let req = 0;
+  for (let i = 0; i < handlerInfos.length; i++) {
+    req += handlerInfos[i].names.length;
+    if (handlerInfos[i].handler === handlerName) {
+      break;
+    }
+  }
+  return req;
+}
+
+export { RoutingService as default };

package/dist/prod/packages/@ember/routing/lib/utils.js

@@ -0,0 +1,236 @@
+import '../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../-internals/environment/index.js';
+import '../../../@glimmer/validator/index.js';
+import '../../../shared-chunks/reference-BNqcwZWH.js';
+import '../../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { g as get } from '../../../shared-chunks/observers-R1ZklwWy.js';
+import { getOwner } from '../../-internals/owner/index.js';
+import '../../engine/instance.js';
+import '../../../route-recognizer/index.js';
+import '../../../shared-chunks/rsvp-CnCSY930.js';
+import { S as STATE_SYMBOL } from '../../../shared-chunks/unrecognized-url-error-DDBwfzdm.js';
+
+const ALL_PERIODS_REGEX = /\./g;
+function extractRouteArgs(args) {
+  // SAFETY: This should just be the same thing
+  args = args.slice();
+  let possibleOptions = args[args.length - 1];
+  let queryParams;
+  if (isRouteOptions(possibleOptions)) {
+    args.pop(); // Remove options
+    queryParams = possibleOptions.queryParams;
+  } else {
+    queryParams = {};
+  }
+  let routeName;
+  if (typeof args[0] === 'string') {
+    routeName = args.shift();
+  }
+
+  // SAFTEY: We removed the name and options if they existed, only models left.
+  let models = args;
+  return {
+    routeName,
+    models,
+    queryParams
+  };
+}
+function getActiveTargetName(router) {
+  let routeInfos = router.activeTransition ? router.activeTransition[STATE_SYMBOL].routeInfos : router.state.routeInfos;
+  let lastRouteInfo = routeInfos[routeInfos.length - 1];
+  return lastRouteInfo.name;
+}
+function stashParamNames(router, routeInfos) {
+  if (routeInfos['_namesStashed']) {
+    return;
+  }
+
+  // This helper exists because router.js/route-recognizer.js awkwardly
+  // keeps separate a routeInfo's list of parameter names depending
+  // on whether a URL transition or named transition is happening.
+  // Hopefully we can remove this in the future.
+  let routeInfo = routeInfos[routeInfos.length - 1];
+  let targetRouteName = routeInfo.name;
+  let recogHandlers = router._routerMicrolib.recognizer.handlersFor(targetRouteName);
+  let dynamicParent;
+  for (let i = 0; i < routeInfos.length; ++i) {
+    let routeInfo = routeInfos[i];
+    let names = recogHandlers[i].names;
+    if (names.length) {
+      dynamicParent = routeInfo;
+    }
+    routeInfo['_names'] = names;
+    let route = routeInfo.route;
+    route._stashNames(routeInfo, dynamicParent);
+  }
+  routeInfos['_namesStashed'] = true;
+}
+function _calculateCacheValuePrefix(prefix, part) {
+  // calculates the dot separated sections from prefix that are also
+  // at the start of part - which gives us the route name
+
+  // given : prefix = site.article.comments, part = site.article.id
+  //      - returns: site.article (use get(values[site.article], 'id') to get the dynamic part - used below)
+
+  // given : prefix = site.article, part = site.article.id
+  //      - returns: site.article. (use get(values[site.article], 'id') to get the dynamic part - used below)
+
+  let prefixParts = prefix.split('.');
+  let currPrefix = '';
+  for (let i = 0; i < prefixParts.length; i++) {
+    let currPart = prefixParts.slice(0, i + 1).join('.');
+    if (part.indexOf(currPart) !== 0) {
+      break;
+    }
+    currPrefix = currPart;
+  }
+  return currPrefix;
+}
+
+/*
+  Stolen from Controller
+*/
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+function calculateCacheKey(prefix, parts = [], values) {
+  let suffixes = '';
+  for (let part of parts) {
+    let cacheValuePrefix = _calculateCacheValuePrefix(prefix, part);
+    let value;
+    if (values) {
+      if (cacheValuePrefix && cacheValuePrefix in values) {
+        let partRemovedPrefix = part.indexOf(cacheValuePrefix) === 0 ? part.substring(cacheValuePrefix.length + 1) : part;
+        value = get(values[cacheValuePrefix], partRemovedPrefix);
+      } else {
+        value = get(values, part);
+      }
+    }
+    suffixes += `::${part}:${value}`;
+  }
+  return prefix + suffixes.replace(ALL_PERIODS_REGEX, '-');
+}
+
+/*
+  Controller-defined query parameters can come in three shapes:
+
+  Array
+    queryParams: ['foo', 'bar']
+  Array of simple objects where value is an alias
+    queryParams: [
+      {
+        'foo': 'rename_foo_to_this'
+      },
+      {
+        'bar': 'call_bar_this_instead'
+      }
+    ]
+  Array of fully defined objects
+    queryParams: [
+      {
+        'foo': {
+          as: 'rename_foo_to_this'
+        },
+      }
+      {
+        'bar': {
+          as: 'call_bar_this_instead',
+          scope: 'controller'
+        }
+      }
+    ]
+
+  This helper normalizes all three possible styles into the
+  'Array of fully defined objects' style.
+*/
+function normalizeControllerQueryParams(queryParams) {
+  let qpMap = {};
+  for (let queryParam of queryParams) {
+    accumulateQueryParamDescriptors(queryParam, qpMap);
+  }
+  return qpMap;
+}
+function accumulateQueryParamDescriptors(_desc, accum) {
+  let desc = typeof _desc === 'string' ? {
+    [_desc]: {
+      as: null
+    }
+  } : _desc;
+  for (let key in desc) {
+    if (!Object.prototype.hasOwnProperty.call(desc, key)) {
+      return;
+    }
+    let _singleDesc = desc[key];
+    let singleDesc = typeof _singleDesc === 'string' ? {
+      as: _singleDesc
+    } : _singleDesc;
+    let partialVal = accum[key] || {
+      as: null,
+      scope: 'model'
+    };
+    let val = {
+      ...partialVal,
+      ...singleDesc
+    };
+    accum[key] = val;
+  }
+}
+
+/*
+  Check if a routeName resembles a url instead
+
+  @private
+*/
+function resemblesURL(str) {
+  return typeof str === 'string' && (str === '' || str[0] === '/');
+}
+
+/*
+  Returns an arguments array where the route name arg is prefixed based on the mount point
+
+  @private
+*/
+function prefixRouteNameArg(route, args) {
+  let routeName;
+  let owner = getOwner(route);
+  let prefix = owner.mountPoint;
+
+  // only alter the routeName if it's actually referencing a route.
+  if (owner.routable && typeof args[0] === 'string') {
+    routeName = args[0];
+    if (resemblesURL(routeName)) {
+      throw new Error('Programmatic transitions by URL cannot be used within an Engine. Please use the route name instead.');
+    } else {
+      routeName = `${prefix}.${routeName}`;
+      args[0] = routeName;
+    }
+  }
+  return args;
+}
+function shallowEqual(a, b) {
+  let aCount = 0;
+  let bCount = 0;
+  for (let kA in a) {
+    if (Object.prototype.hasOwnProperty.call(a, kA)) {
+      if (a[kA] !== b[kA]) {
+        return false;
+      }
+      aCount++;
+    }
+  }
+  for (let kB in b) {
+    if (Object.prototype.hasOwnProperty.call(b, kB)) {
+      bCount++;
+    }
+  }
+  return aCount === bCount;
+}
+function isRouteOptions(value) {
+  if (value && typeof value === 'object') {
+    let qps = value.queryParams;
+    if (qps && typeof qps === 'object') {
+      return Object.keys(qps).every(k => typeof k === 'string');
+    }
+  }
+  return false;
+}
+
+export { calculateCacheKey, extractRouteArgs, getActiveTargetName, normalizeControllerQueryParams, prefixRouteNameArg, resemblesURL, shallowEqual, stashParamNames };

package/dist/prod/packages/@ember/routing/none-location.js

@@ -0,0 +1,120 @@
+import EmberObject from '../object/index.js';
+import '../-internals/environment/index.js';
+
+/**
+@module @ember/routing/none-location
+*/
+
+/**
+  NoneLocation does not interact with the browser. It is useful for
+  testing, or when you need to manage state with your Router, but temporarily
+  don't want it to muck with the URL (for example when you embed your
+  application in a larger page).
+
+  Using `NoneLocation` causes Ember to not store the applications URL state
+  in the actual URL. This is generally used for testing purposes.
+
+  @class NoneLocation
+  @extends EmberObject
+  @protected
+*/
+class NoneLocation extends EmberObject {
+  updateCallback;
+
+  // Set in reopen so it can be overwritten with extend
+
+  /**
+    Will be pre-pended to path.
+     @private
+    @property rootURL
+    @default '/'
+  */
+  // Set in reopen so it can be overwritten with extend
+
+  initState() {
+    this._super(...arguments);
+    let {
+      rootURL
+    } = this;
+  }
+
+  /**
+    Returns the current path without `rootURL`.
+     @private
+    @method getURL
+    @return {String} path
+  */
+  getURL() {
+    let {
+      path,
+      rootURL
+    } = this;
+
+    // remove trailing slashes if they exists
+    rootURL = rootURL.replace(/\/$/, '');
+
+    // remove rootURL from url
+    return path.replace(new RegExp(`^${rootURL}(?=/|$)`), '');
+  }
+
+  /**
+    Set the path and remembers what was set. Using this method
+    to change the path will not invoke the `updateURL` callback.
+     @private
+    @method setURL
+    @param path {String}
+  */
+  setURL(path) {
+    this.path = path;
+  }
+
+  /**
+    Register a callback to be invoked when the path changes. These
+    callbacks will execute when the user presses the back or forward
+    button, but not after `setURL` is invoked.
+     @private
+    @method onUpdateURL
+    @param callback {Function}
+  */
+  onUpdateURL(callback) {
+    this.updateCallback = callback;
+  }
+
+  /**
+    Sets the path and calls the `updateURL` callback.
+     @private
+    @method handleURL
+    @param url {String}
+  */
+  handleURL(url) {
+    this.path = url;
+    if (this.updateCallback) {
+      this.updateCallback(url);
+    }
+  }
+
+  /**
+    Given a URL, formats it to be placed into the page as part
+    of an element's `href` attribute.
+     @private
+    @method formatURL
+    @param {String} url
+    @return {String} url
+  */
+  formatURL(url) {
+    let {
+      rootURL
+    } = this;
+    if (url !== '') {
+      // remove trailing slashes if they exists
+      rootURL = rootURL.replace(/\/$/, '');
+    }
+    return rootURL + url;
+  }
+}
+NoneLocation.reopen({
+  path: '',
+  rootURL: '/'
+});
+
+export { NoneLocation as default };