ember-source 6.12.0 → 7.0.0-alpha.1

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

@@ -0,0 +1,250 @@
+import EmberObject from '../object/index.js';
+import '../-internals/environment/index.js';
+import { getHash } from './lib/location-utils.js';
+
+/**
+@module @ember/routing/history-location
+*/
+
+function _uuid() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    let r, v;
+    r = Math.random() * 16 | 0;
+    v = c === 'x' ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+/**
+  HistoryLocation implements the location API using the browser's
+  history.pushState API.
+
+  Using `HistoryLocation` results in URLs that are indistinguishable from a
+  standard URL. This relies upon the browser's `history` API.
+
+  Example:
+
+  ```app/router.js
+  Router.map(function() {
+    this.route('posts', function() {
+      this.route('new');
+    });
+  });
+
+  Router.reopen({
+    location: 'history'
+  });
+  ```
+
+  This will result in a posts.new url of `/posts/new`.
+
+  Keep in mind that your server must serve the Ember app at all the routes you
+  define.
+
+  Using `HistoryLocation` will also result in location states being recorded by
+  the browser `history` API with the following schema:
+
+  ```
+  window.history.state -> { path: '/', uuid: '3552e730-b4a6-46bd-b8bf-d8c3c1a97e0a' }
+  ```
+
+  This allows each in-app location state to be tracked uniquely across history
+  state changes via the `uuid` field.
+
+  @class HistoryLocation
+  @extends EmberObject
+  @protected
+*/
+class HistoryLocation extends EmberObject {
+  // SAFETY: both of these properties initialized via `init`.
+
+  history;
+  _popstateHandler;
+
+  /**
+    Will be pre-pended to path upon state change
+     @property rootURL
+    @default '/'
+    @private
+  */
+  rootURL = '/';
+
+  /**
+    @private
+     Returns normalized location.hash
+     @method getHash
+  */
+  getHash() {
+    return getHash(this.location);
+  }
+  init() {
+    this._super(...arguments);
+    let base = document.querySelector('base');
+    let baseURL = '';
+    if (base !== null && base.hasAttribute('href')) {
+      baseURL = base.getAttribute('href') ?? '';
+    }
+    this.baseURL = baseURL;
+    this.location = this.location ?? window.location;
+    this._popstateHandler = undefined;
+  }
+
+  /**
+    Used to set state on first call to setURL
+     @private
+    @method initState
+  */
+  initState() {
+    let history = this.history ?? window.history;
+    this.history = history;
+    let {
+      state
+    } = history;
+    let path = this.formatURL(this.getURL());
+    if (!state || state.path !== path) {
+      this.replaceState(path);
+    }
+  }
+
+  /**
+    Returns the current `location.pathname` without `rootURL` or `baseURL`
+     @private
+    @method getURL
+    @return url {String}
+  */
+  getURL() {
+    let {
+      location,
+      rootURL,
+      baseURL
+    } = this;
+    let path = location.pathname;
+
+    // remove trailing slashes if they exists
+    rootURL = rootURL.replace(/\/$/, '');
+    baseURL = baseURL.replace(/\/$/, '');
+
+    // remove baseURL and rootURL from start of path
+    let url = path.replace(new RegExp(`^${baseURL}(?=/|$)`), '').replace(new RegExp(`^${rootURL}(?=/|$)`), '').replace(/\/\//g, '/'); // remove extra slashes
+
+    let search = location.search || '';
+    url += search + this.getHash();
+    return url;
+  }
+
+  /**
+    Uses `history.pushState` to update the url without a page reload.
+     @private
+    @method setURL
+    @param path {String}
+  */
+  setURL(path) {
+    let {
+      state
+    } = this.history;
+    path = this.formatURL(path);
+    if (!state || state.path !== path) {
+      this.pushState(path);
+    }
+  }
+
+  /**
+    Uses `history.replaceState` to update the url without a page reload
+    or history modification.
+     @private
+    @method replaceURL
+    @param path {String}
+  */
+  replaceURL(path) {
+    let {
+      state
+    } = this.history;
+    path = this.formatURL(path);
+    if (!state || state.path !== path) {
+      this.replaceState(path);
+    }
+  }
+
+  /**
+   Pushes a new state.
+    @private
+   @method pushState
+   @param path {String}
+  */
+  pushState(path) {
+    let state = {
+      path,
+      uuid: _uuid()
+    };
+    this.history.pushState(state, '', path);
+  }
+
+  /**
+   Replaces the current state.
+    @private
+   @method replaceState
+   @param path {String}
+  */
+  replaceState(path) {
+    let state = {
+      path,
+      uuid: _uuid()
+    };
+    this.history.replaceState(state, '', path);
+  }
+
+  /**
+    Register a callback to be invoked whenever the browser
+    history changes, including using forward and back buttons.
+     @private
+    @method onUpdateURL
+    @param callback {Function}
+  */
+  onUpdateURL(callback) {
+    this._removeEventListener();
+    this._popstateHandler = () => {
+      callback(this.getURL());
+    };
+    window.addEventListener('popstate', this._popstateHandler);
+  }
+
+  /**
+    Formats url to be placed into href attribute.
+     @private
+    @method formatURL
+    @param url {String}
+    @return formatted url {String}
+  */
+  formatURL(url) {
+    let {
+      rootURL,
+      baseURL
+    } = this;
+    if (url !== '') {
+      // remove trailing slashes if they exists
+      rootURL = rootURL.replace(/\/$/, '');
+      baseURL = baseURL.replace(/\/$/, '');
+    } else if (baseURL[0] === '/' && rootURL[0] === '/') {
+      // if baseURL and rootURL both start with a slash
+      // ... remove trailing slash from baseURL if it exists
+      baseURL = baseURL.replace(/\/$/, '');
+    }
+    return baseURL + rootURL + url;
+  }
+
+  /**
+    Cleans up the HistoryLocation event listener.
+     @private
+    @method willDestroy
+  */
+  willDestroy() {
+    this._removeEventListener();
+  }
+  _removeEventListener() {
+    if (this._popstateHandler) {
+      window.removeEventListener('popstate', this._popstateHandler);
+    }
+  }
+}
+
+export { HistoryLocation as default };

package/dist/prod/packages/@ember/routing/index.js

@@ -0,0 +1,12 @@
+import '../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/index-CSVCFS_p.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+export { L as LinkTo } from '../../shared-chunks/index-DZLHQAlb.js';
+import '../-internals/container/index.js';
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+import '../../shared-chunks/on-CrTl7JQU.js';
+import '../../shared-chunks/constants-b-2IVErl.js';
+import '../runloop/index.js';

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

@@ -0,0 +1,37 @@
+/**
+  A two-tiered cache with support for fallback values when doing lookups.
+  Uses "buckets" and then "keys" to cache values.
+
+  @private
+  @class BucketCache
+*/
+class BucketCache {
+  cache;
+  constructor() {
+    this.cache = new Map();
+  }
+  has(bucketKey) {
+    return this.cache.has(bucketKey);
+  }
+  stash(bucketKey, key, value) {
+    let bucket = this.cache.get(bucketKey);
+    if (bucket === undefined) {
+      bucket = new Map();
+      this.cache.set(bucketKey, bucket);
+    }
+    bucket.set(key, value);
+  }
+  lookup(bucketKey, prop, defaultValue) {
+    if (!this.has(bucketKey)) {
+      return defaultValue;
+    }
+    let bucket = this.cache.get(bucketKey);
+    if (bucket.has(prop)) {
+      return bucket.get(prop);
+    } else {
+      return defaultValue;
+    }
+  }
+}
+
+export { BucketCache as default };

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

@@ -0,0 +1,16 @@
+/**
+  @module @ember/routing
+*/
+
+/**
+  Finds a controller instance.
+
+  @for Ember
+  @method controllerFor
+  @private
+*/
+function controllerFor(container, controllerName, lookupOptions) {
+  return container.lookup(`controller:${controllerName}`, lookupOptions);
+}
+
+export { controllerFor as default };

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

@@ -0,0 +1,178 @@
+import '../../-internals/environment/index.js';
+
+let uuid = 0;
+function isCallback(value) {
+  return typeof value === 'function';
+}
+class DSLImpl {
+  parent;
+  // eslint-disable-next-line @typescript-eslint/no-wrapper-object-types
+  matches;
+  enableLoadingSubstates;
+  explicitIndex = false;
+  options;
+  constructor(name = null, options) {
+    this.parent = name;
+    this.enableLoadingSubstates = Boolean(options && options.enableLoadingSubstates);
+    this.matches = [];
+    this.options = options;
+  }
+  route(name, _options, _callback) {
+    let options;
+    let callback = null;
+    let dummyErrorRoute = `/_unused_dummy_error_path_route_${name}/:error`;
+    if (isCallback(_options)) {
+      options = {};
+      callback = _options;
+    } else if (isCallback(_callback)) {
+      options = _options;
+      callback = _callback;
+    } else {
+      options = _options || {};
+    }
+    if (this.enableLoadingSubstates) {
+      createRoute(this, `${name}_loading`, {
+        resetNamespace: options.resetNamespace
+      });
+      createRoute(this, `${name}_error`, {
+        resetNamespace: options.resetNamespace,
+        path: dummyErrorRoute
+      });
+    }
+    if (callback) {
+      let fullName = getFullName(this, name, options.resetNamespace);
+      let dsl = new DSLImpl(fullName, this.options);
+      createRoute(dsl, 'loading');
+      createRoute(dsl, 'error', {
+        path: dummyErrorRoute
+      });
+      callback.call(dsl);
+      createRoute(this, name, options, dsl.generate());
+    } else {
+      createRoute(this, name, options);
+    }
+  }
+  push(url, name, callback,
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  serialize) {
+    let parts = name.split('.');
+    if (this.options.engineInfo) {
+      let localFullName = name.slice(this.options.engineInfo.fullName.length + 1);
+      let routeInfo = Object.assign({
+        localFullName
+      }, this.options.engineInfo);
+      if (serialize) {
+        routeInfo.serializeMethod = serialize;
+      }
+      this.options.addRouteForEngine(name, routeInfo);
+    } else if (serialize) {
+      throw new Error(`Defining a route serializer on route '${name}' outside an Engine is not allowed.`);
+    }
+    if (url === '' || url === '/' || parts[parts.length - 1] === 'index') {
+      this.explicitIndex = true;
+    }
+    this.matches.push(url, name, callback);
+  }
+  generate() {
+    let dslMatches = this.matches;
+    if (!this.explicitIndex) {
+      this.route('index', {
+        path: '/'
+      });
+    }
+    return match => {
+      for (let i = 0; i < dslMatches.length; i += 3) {
+        match(dslMatches[i]).to(dslMatches[i + 1], dslMatches[i + 2]);
+      }
+    };
+  }
+  mount(_name, options = {}) {
+    let engineRouteMap = this.options.resolveRouteMap(_name);
+    let name = _name;
+    if (options.as) {
+      name = options.as;
+    }
+    let fullName = getFullName(this, name, options.resetNamespace);
+    let engineInfo = {
+      name: _name,
+      instanceId: uuid++,
+      mountPoint: fullName,
+      fullName
+    };
+    let path = options.path;
+    if (typeof path !== 'string') {
+      path = `/${name}`;
+    }
+    let callback;
+    let dummyErrorRoute = `/_unused_dummy_error_path_route_${name}/:error`;
+    if (engineRouteMap) {
+      let shouldResetEngineInfo = false;
+      let oldEngineInfo = this.options.engineInfo;
+      if (oldEngineInfo) {
+        shouldResetEngineInfo = true;
+        this.options.engineInfo = engineInfo;
+      }
+      let optionsForChild = Object.assign({
+        engineInfo
+      }, this.options);
+      let childDSL = new DSLImpl(fullName, optionsForChild);
+      createRoute(childDSL, 'loading');
+      createRoute(childDSL, 'error', {
+        path: dummyErrorRoute
+      });
+      engineRouteMap.class.call(childDSL);
+      callback = childDSL.generate();
+      if (shouldResetEngineInfo) {
+        this.options.engineInfo = oldEngineInfo;
+      }
+    }
+    let localFullName = 'application';
+    let routeInfo = Object.assign({
+      localFullName
+    }, engineInfo);
+    if (this.enableLoadingSubstates) {
+      // These values are important to register the loading routes under their
+      // proper names for the Router and within the Engine's registry.
+      let substateName = `${name}_loading`;
+      let localFullName = `application_loading`;
+      let routeInfo = Object.assign({
+        localFullName
+      }, engineInfo);
+      createRoute(this, substateName, {
+        resetNamespace: options.resetNamespace
+      });
+      this.options.addRouteForEngine(substateName, routeInfo);
+      substateName = `${name}_error`;
+      localFullName = `application_error`;
+      routeInfo = Object.assign({
+        localFullName
+      }, engineInfo);
+      createRoute(this, substateName, {
+        resetNamespace: options.resetNamespace,
+        path: dummyErrorRoute
+      });
+      this.options.addRouteForEngine(substateName, routeInfo);
+    }
+    this.options.addRouteForEngine(fullName, routeInfo);
+    this.push(path, fullName, callback);
+  }
+}
+function canNest(dsl) {
+  return dsl.parent !== 'application';
+}
+function getFullName(dsl, name, resetNamespace) {
+  if (canNest(dsl) && resetNamespace !== true) {
+    return `${dsl.parent}.${name}`;
+  } else {
+    return name;
+  }
+}
+function createRoute(dsl, name, options = {}, callback) {
+  let fullName = getFullName(dsl, name, options.resetNamespace);
+  if (typeof options.path !== 'string') {
+    options.path = `/${name}`;
+  }
+  dsl.push(options.path, fullName, callback, options.serialize);
+}
+
+export { DSLImpl as default };

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

@@ -0,0 +1,62 @@
+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 '../../../shared-chunks/observers-R1ZklwWy.js';
+import '../../controller/index.js';
+
+/**
+ @module @ember/routing
+*/
+
+/**
+  Generates a controller factory
+
+  @for Ember
+  @method generateControllerFactory
+  @private
+*/
+
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+function generateControllerFactory(owner, controllerName) {
+  /* eslint-enable @typescript-eslint/no-empty-object-type */
+  let factoryManager = owner.factoryFor('controller:basic');
+  // `assert()` below after altering *tests*. It is left in this state for the
+  // moment in the interest of keeping type-only changes separate from changes
+  // to the runtime behavior of the system, even for tests.
+  let Factory = factoryManager.class;
+  // assert(
+  //   '[BUG] factory for `controller:main` is unexpectedly not a Controller',
+  //   ((factory): factory is typeof Controller => factory === Controller)(Factory)
+  // );
+
+  Factory = class extends Factory {
+    toString() {
+      return `(generated ${controllerName} controller)`;
+    }
+  };
+  let fullName = `controller:${controllerName}`;
+  owner.register(fullName, Factory);
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  return owner.factoryFor(fullName);
+}
+
+/**
+  Generates and instantiates a controller extending from `controller:basic`
+  if present, or `Controller` if not.
+
+  @for Ember
+  @method generateController
+  @private
+  @since 1.3.0
+*/
+function generateController(owner, controllerName) {
+  generateControllerFactory(owner, controllerName);
+  let fullName = `controller:${controllerName}`;
+  let instance = owner.lookup(fullName);
+  return instance;
+}
+
+export { generateController as default, generateControllerFactory };

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

@@ -0,0 +1,48 @@
+/**
+  @private
+
+  Returns the current `location.pathname`, ensuring it has a leading slash.
+*/
+function getPath(location) {
+  let pathname = location.pathname;
+  if (pathname[0] !== '/') {
+    pathname = `/${pathname}`;
+  }
+  return pathname;
+}
+
+/**
+  @private
+
+  Returns the current `location.search`.
+*/
+function getQuery(location) {
+  return location.search;
+}
+
+/**
+  @private
+
+  Returns the hash or empty string
+*/
+function getHash(location) {
+  if (location.hash !== undefined) {
+    return location.hash.substring(0);
+  }
+  return '';
+}
+function getFullPath(location) {
+  return getPath(location) + getQuery(location) + getHash(location);
+}
+
+/**
+  Replaces the current location, making sure we explicitly include the origin
+  to prevent redirecting to a different origin.
+
+  @private
+*/
+function replacePath(location, path) {
+  location.replace(location.origin + path);
+}
+
+export { getFullPath, getHash, getPath, getQuery, replacePath };

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

@@ -0,0 +1,9 @@
+class QueryParams {
+  values;
+  isQueryParams = true;
+  constructor(values = null) {
+    this.values = values;
+  }
+}
+
+export { QueryParams as default };

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

@@ -0,0 +1,26 @@
+import { shallowEqual } from './utils.js';
+
+class RouterState {
+  router;
+  emberRouter;
+  routerJsState;
+  constructor(emberRouter, router, routerJsState) {
+    this.emberRouter = emberRouter;
+    this.router = router;
+    this.routerJsState = routerJsState;
+  }
+  isActiveIntent(routeName, models, queryParams) {
+    let state = this.routerJsState;
+    if (!this.router.isActiveIntent(routeName, models, undefined, state)) {
+      return false;
+    }
+    if (queryParams !== undefined && Object.keys(queryParams).length > 0) {
+      let visibleQueryParams = Object.assign({}, queryParams);
+      this.emberRouter._prepareQueryParams(routeName, models, visibleQueryParams);
+      return shallowEqual(visibleQueryParams, state.queryParams);
+    }
+    return true;
+  }
+}
+
+export { RouterState as default };