@angular-wave/angular.ts 0.4.2 → 0.4.4

package/src/shared/jqlite/jqlite.js

@@ -3,7 +3,6 @@ import {
   arrayRemove,
   concat,
   extend,
-  forEach,
   isDefined,
   isFunction,
   isObject,
@@ -103,9 +102,9 @@ export function JQLite(element) {
 JQLite.prototype = {
   toString() {
     const value = [];
-    forEach(this, (e) => {
-      value.push(`${e}`);
-    });
+    for (var i = 0; i < this.length; i++) {
+      value.push(`${this[i]}`);
+    }
     return `[${value.join(", ")}]`;
   },
 
@@ -276,7 +275,7 @@ JQLite.prototype.off = function (type, fn) {
         }
       };
 
-      forEach(type.split(" "), (type) => {
+      type.split(" ").forEach((type) => {
         removeHandler(type);
         if (MOUSE_EVENT_MAP[type]) {
           removeHandler(MOUSE_EVENT_MAP[type]);
@@ -379,7 +378,7 @@ JQLite.prototype.val = function (value) {
       // read
       if (element.multiple && getNodeName(element) === "select") {
         const result = [];
-        forEach(element.options, (option) => {
+        Array.from(element.options).forEach((option) => {
           if (option.selected) {
             result.push(option.value || option.text);
           }
@@ -482,14 +481,16 @@ JQLite.prototype.replaceWith = function (arg1) {
     let index;
     const parent = element.parentNode;
     dealoc(element);
-    forEach(new JQLite(replaceNode), (node) => {
+    const nodes = new JQLite(replaceNode);
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
       if (index) {
         parent.insertBefore(node, index.nextSibling);
       } else {
         parent.replaceChild(node, element);
       }
       index = node;
-    });
+    }
   };
   for (let i = 0; i < this.length; i++) {
     addNodes(value, fn(this[i], arg1));
@@ -542,9 +543,10 @@ JQLite.prototype.prepend = function (node) {
     const element = this[i];
     if (element.nodeType === Node.ELEMENT_NODE) {
       const index = element.firstChild;
-      forEach(new JQLite(node), (child) => {
-        element.insertBefore(child, index);
-      });
+      const el = new JQLite(node);
+      for (let i = 0; i < el.length; i++) {
+        element.insertBefore(el[i], index);
+      }
     }
   }
   return this;
@@ -683,7 +685,7 @@ JQLite.prototype.triggerHandler = function (event, extraParameters) {
         ? [dummyEvent].concat(extraParameters)
         : [dummyEvent];
 
-      forEach(eventFnsCopy, (fn) => {
+      eventFnsCopy.forEach((fn) => {
         if (!dummyEvent.isImmediatePropagationStopped()) {
           fn.apply(element, handlerArgs);
         }
@@ -1093,9 +1095,6 @@ function createEventHandler(element, events) {
     }
   };
 
-  // TODO: this is a hack for angularMocks/clearDataCache that makes it possible to deregister all
-  //       events on `element`
-  eventHandler.elem = element;
   return eventHandler;
 }
 

package/src/shared/jqlite/jqlite.spec.js

@@ -8,7 +8,7 @@ import {
 } from "./jqlite";
 import { Angular } from "../../loader";
 import { createInjector } from "../../core/di/injector";
-import { equals, forEach } from "../utils";
+import { equals } from "../utils";
 import { browserTrigger } from "../test-utils";
 import { CACHE, EXPANDO } from "../../core/cache/cache";
 
@@ -902,7 +902,7 @@ describe("jqLite", () => {
     });
 
     it("should not fail on elements without the getAttribute method", () => {
-      forEach([window, document], (node) => {
+      [window, document].forEach((node) => {
         expect(() => {
           const elem = JQLite(node);
           elem.attr("foo");

package/src/shared/utils.js

@@ -288,86 +288,6 @@ export function snakeCase(name, separator) {
   );
 }
 
-/**
- * Invokes the `iterator` function once for each item in `obj` collection, which can be either an
- * object or an array. The `iterator` function is invoked with `iterator(value, key, obj)`, where `value`
- * is the value of an object property or an array element, `key` is the object property key or
- * array element index and obj is the `obj` itself. Specifying a `context` for the function is optional.
- *
- * It is worth noting that `.forEach` does not iterate over inherited properties because it filters
- * using the `hasOwnProperty` method.
- *
- * Unlike ES262's
- * [Array.prototype.forEach](http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18),
- * providing 'undefined' or 'null' values for `obj` will not throw a TypeError, but rather just
- * return the value provided.
- *
-   ```js
-     let values = {name: 'misko', gender: 'male'};
-     let log = [];
-     forEach(values, function(value, key) {
-       this.push(key + ': ' + value);
-     }, log);
-     expect(log).toEqual(['name: misko', 'gender: male']);
-   ```
- *
- * @param {Object|Array} obj Object to iterate over.
- * @param {Function} iterator Iterator function.
- * @param {Object=} context Object to become context (`this`) for the iterator function.
- * @returns {Object|Array} Reference to `obj`.
- */
-export function forEach(obj, iterator, context) {
-  let key;
-  let length;
-  if (obj) {
-    if (isFunction(obj)) {
-      for (key in obj) {
-        if (
-          key !== "prototype" &&
-          key !== "length" &&
-          key !== "name" &&
-          Object.prototype.hasOwnProperty.call(obj, key)
-        ) {
-          iterator.call(context, obj[key], key, obj);
-        }
-      }
-    } else if (Array.isArray(obj) || isArrayLike(obj)) {
-      const isPrimitive = typeof obj !== "object";
-      for (key = 0, length = obj.length; key < length; key++) {
-        if (isPrimitive || key in obj) {
-          iterator.call(context, obj[key], key, obj);
-        }
-      }
-    } else if (obj.forEach && obj.forEach !== forEach) {
-      obj.forEach(iterator, context, obj);
-    } else if (isBlankObject(obj)) {
-      // Object.create(null) fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
-      for (key in obj) {
-        iterator.call(context, obj[key], key, obj);
-      }
-    } else {
-      // Slow path for objects which do not have a method `hasOwnProperty`
-      for (key in obj) {
-        if (Object.hasOwnProperty.call(obj, key)) {
-          iterator.call(context, obj[key], key, obj);
-        }
-      }
-    }
-  }
-  return obj;
-}
-
-/**
- * when using forEach the params are value, key, but it is often useful to have key, value.
- * @param {function(string, *):any} iteratorFn
- * @returns {function(*, string)}
- */
-export function reverseParams(iteratorFn) {
-  return function (value, key) {
-    iteratorFn(key, value);
-  };
-}
-
 /**
  * Set or clear the hashkey for an object.
  * @param obj object
@@ -923,21 +843,24 @@ export function parseKeyValue(keyValue) {
 
 export function toKeyValue(obj) {
   const parts = [];
-  forEach(obj, (value, key) => {
-    if (Array.isArray(value)) {
-      forEach(value, (arrayValue) => {
+  obj &&
+    Object.entries(obj).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((arrayValue) => {
+          parts.push(
+            encodeUriQuery(key, true) +
+              (arrayValue === true
+                ? ""
+                : `=${encodeUriQuery(arrayValue, true)}`),
+          );
+        });
+      } else {
         parts.push(
           encodeUriQuery(key, true) +
-            (arrayValue === true ? "" : `=${encodeUriQuery(arrayValue, true)}`),
+            (value === true ? "" : `=${encodeUriQuery(value, true)}`),
         );
-      });
-    } else {
-      parts.push(
-        encodeUriQuery(key, true) +
-          (value === true ? "" : `=${encodeUriQuery(value, true)}`),
-      );
-    }
-  });
+      }
+    });
   return parts.length ? parts.join("&") : "";
 }
 

package/types/core/cache/cache.d.ts

@@ -6,7 +6,7 @@
  * @property {?Function} handle
  *
  */
-export const EXPANDO: "ngId";
+export const EXPANDO: "ng";
 /**
  * Expando cache for adding properties to DOM nodes with JavaScript.
  * This used to be an Object in JQLite decorator, but swapped out for a Map

package/types/core/model/model.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Creates a deep proxy for the target object, intercepting property changes
+ * and recursively applying proxies to nested objects.
+ *
+ * @param {Object} target - The object to be wrapped in a proxy.
+ * @param {Model} [context] - The context for the handler, used to track listeners.
+ * @returns {ProxyHandler<Object>} - A proxy that intercepts operations on the target object,
+ *                                     or the original value if the target is not an object.
+ */
+export function createModel(target?: any, context?: Model): ProxyHandler<any>;
+/**
+ * @typedef {Object} AsyncQueueTask
+ * @property {Model} handler
+ * @property {Function} fn
+ * @property {Object} locals
+ */
+export const $postUpdateQueue: any[];
+/**
+ * @type {Function[]}
+ */
+export const $$applyAsyncQueue: Function[];
+export class RootModelProvider {
+    rootModel: ProxyHandler<any>;
+    $get: (string | ((exceptionHandler: import("../exception-handler").ErrorHandler, parse: import("../parse/parse.js").ParseService) => ProxyHandler<any>))[];
+}
+export type ModelPhase = number;
+export namespace ModelPhase {
+    let NONE: number;
+    let WATCH: number;
+    let DIGEST: number;
+}
+export type AsyncQueueTask = {
+    handler: Model;
+    fn: Function;
+    locals: any;
+};
+/**
+ * Listener function definition.
+ */
+export type Listener = {
+    /**
+     * - The original target object.
+     */
+    originalTarget: any;
+    /**
+     * - The function invoked when changes are detected.
+     */
+    listenerFn: ListenerFunction;
+    watchFn: import("../parse/parse.js").CompiledExpression;
+    id: number;
+    oneTime: boolean;
+    property: string;
+    /**
+     * - The optional context in which a property exists
+     */
+    context?: any;
+    foreignListener?: ProxyConstructor;
+};
+/**
+ * Listener function type.
+ */
+export type ListenerFunction = (newValue: any, oldValue: any, originalTarget: any) => any;
+/**
+ * Model class for the Proxy. It intercepts operations like property access (get)
+ * and property setting (set), and adds support for deep change tracking and
+ * observer-like behavior.
+ */
+declare class Model {
+    /**
+     * Initializes the handler with the target object and a context.
+     *
+     * @param {Object} target - The target object being proxied.
+     * @param {Model} [context] - The context containing listeners.
+     */
+    constructor(target: any, context?: Model);
+    /** @type {Object} */
+    $target: any;
+    context: Model;
+    /** @type {Map<string, Array<Listener>>} Watch listeners */
+    listeners: Map<string, Array<Listener>>;
+    /** @type {Map<string, Array<Listener>>} Watch listeners from other proxies */
+    foreignListeners: Map<string, Array<Listener>>;
+    /** @type {WeakMap<Object, Array<string>>} */
+    objectListeners: WeakMap<any, Array<string>>;
+    /** @type {Map<Function, {oldValue: any, fn: Function}>} */
+    functionListeners: Map<Function, {
+        oldValue: any;
+        fn: Function;
+    }>;
+    /** @type {?number} */
+    listenerCache: number | null;
+    /** @type {Proxy} */
+    proxy: ProxyConstructor;
+    /**
+     * @type {Proxy[]}
+     */
+    children: ProxyConstructor[];
+    /**
+     * @type {number} Unique model ID (monotonically increasing) useful for debugging.
+     */
+    id: number;
+    /**
+     * @type {Model}
+     */
+    $root: Model;
+    $parent: Model;
+    /** @type {number} */
+    $$watchersCount: number;
+    /** @type {AsyncQueueTask[]} */
+    $$asyncQueue: AsyncQueueTask[];
+    /** @type {Map<String, Function[]>} Event listeners */
+    $$listeners: Map<string, Function[]>;
+    filters: any[];
+    /** @type {ModelPhase} */
+    state: ModelPhase;
+    /**
+     * Intercepts and handles property assignments on the target object. If a new value is
+     * an object, it will be recursively proxied.
+     *
+     * @param {Object} target - The target object.
+     * @param {string} property - The name of the property being set.
+     * @param {*} value - The new value being assigned to the property.
+     * @returns {boolean} - Returns true to indicate success of the operation.
+     */
+    set(target: any, property: string, value: any, proxy: any): boolean;
+    /**
+     * Intercepts property access on the target object. It checks for specific
+     * properties (`watch` and `sync`) and binds their methods. For other properties,
+     * it returns the value directly.
+     *
+     * @param {Object} target - The target object.
+     * @param {string|number|symbol} property - The name of the property being accessed.
+     * @param {Proxy} proxy - The proxy object being invoked
+     * @returns {*} - The value of the property or a method if accessing `watch` or `sync`.
+     */
+    get(target: any, property: string | number | symbol, proxy: ProxyConstructor): any;
+    /**
+     * @private
+     * @param {Listener[]} listeners
+     * @param {*} oldValue
+     */
+    private scheduleListener;
+    deleteProperty(target: any, property: any): boolean;
+    /**
+     * Registers a watcher for a property along with a listener function. The listener
+     * function is invoked when changes to that property are detected.
+     *
+     * @param {string} watchProp - An expression to be watched in the context of this model.
+     * @param {ListenerFunction} [listenerFn] - A function to execute when changes are detected on watched context.
+     */
+    $watch(watchProp: string, listenerFn?: ListenerFunction): () => void;
+    $watchGroup(watchArray: any, listenerFn: any): void;
+    $watchCollection(watchProp: any, listenerFn: any): () => void;
+    $new(isIsolated: boolean, parent: any): any;
+    registerKey(key: any, listener: any): void;
+    registerForeignKey(key: any, listener: any): void;
+    deregisterKey(key: any, id: any): boolean;
+    deregisterForeignKey(key: any, id: any): boolean;
+    /**
+     * @deprecated
+     */
+    $digest(): void;
+    $eval(expr: any, locals: any): any;
+    $evalAsync(expr: any, locals: any): Promise<any>;
+    $apply(expr: any): any;
+    $on(name: any, listener: any): () => void;
+    /**
+     * @param {string} name
+     * @param  {...any} args
+     * @returns
+     */
+    $emit(name: string, ...args: any[]): any;
+    /**
+     * @param {string} name
+     * @param  {...any} args
+     * @returns
+     */
+    $broadcast(name: string, ...args: any[]): any;
+    eventHelper({ name, event, broadcast }: {
+        name: any;
+        event: any;
+        broadcast: any;
+    }, ...args: any[]): any;
+    /**
+     * @private
+     * @returns {boolean}
+     */
+    private isRoot;
+    $applyAsync(expr: any): Promise<any>;
+    $postUpdate(fn: any): void;
+    $destroy(): void;
+    /**
+     * @param {number} count
+     */
+    incrementWatchersCount(count: number): void;
+    /**
+     * Invokes the registered listener function with watched property changes.
+     *
+     * @param {Listener} listener - The property path that was changed.
+     * @param {*} oldValue - The old value of the property.
+     */
+    notifyListener(listener: Listener, oldValue: any): void;
+}
+export {};

package/types/core/parse/parse.d.ts

@@ -4,10 +4,19 @@
  * @property {boolean} constant - Indicates if the expression is constant.
  * @property {boolean} [isPure]
  * @property {boolean} oneTime
+ * @property {import("./interpreter.js").DecoratedASTNode} decoratedNode
  * @property {function(import('../scope/scope').Scope, import('../scope/scope').WatchListener, boolean, CompiledExpression, string | ((scope:  import('../scope/scope').Scope) => any) | CompiledExpression): any} [$$watchDelegate]
  * @property {any[]|Function} inputs
  * @property {function(any, any): any} [assign] - Assigns a value to a context. If value is not provided,
  */
+/**
+ * @typedef {Object} CompiledExpressionHandlerMap
+ * @property {boolean} literal - Indicates if the expression is a literal.
+ * @property {boolean} constant - Indicates if the expression is constant.
+ * @property {boolean} [isPure]
+ * @property {boolean} oneTime
+ * @property {Map<string, Function>} keyMap - property keys to observe
+ */
 /**
  * @typedef {Function} CompiledExpressionFunction
  * @param {import('../scope/scope').Scope} context - An object against which any expressions embedded in the strings are evaluated against (typically a scope object).
@@ -61,6 +70,7 @@ export type CompiledExpressionProps = {
     constant: boolean;
     isPure?: boolean;
     oneTime: boolean;
+    decoratedNode: import("./interpreter.js").DecoratedASTNode;
     $$watchDelegate?: (arg0: import("../scope/scope").Scope, arg1: import("../scope/scope").WatchListener, arg2: boolean, arg3: CompiledExpression, arg4: string | ((scope: import("../scope/scope").Scope) => any) | CompiledExpression) => any;
     inputs: any[] | Function;
     /**
@@ -68,6 +78,22 @@ export type CompiledExpressionProps = {
      */
     assign?: (arg0: any, arg1: any) => any;
 };
+export type CompiledExpressionHandlerMap = {
+    /**
+     * - Indicates if the expression is a literal.
+     */
+    literal: boolean;
+    /**
+     * - Indicates if the expression is constant.
+     */
+    constant: boolean;
+    isPure?: boolean;
+    oneTime: boolean;
+    /**
+     * - property keys to observe
+     */
+    keyMap: Map<string, Function>;
+};
 export type CompiledExpressionFunction = Function;
 export type CompiledExpression = CompiledExpressionFunction & CompiledExpressionProps;
 export type ParseService = (arg0: CompiledExpression | string | ((arg0: import("../scope/scope").Scope) => any), arg1: ((arg0: any, arg1: import("../scope/scope").Scope, arg2: any) => any) | undefined, arg2: boolean | undefined) => CompiledExpression;

package/types/core/scope/scope.d.ts

@@ -56,7 +56,7 @@ export type TTL = number;
 export const TTL: TTL;
 /** @type {AsyncQueueTask[]} */
 export const $$asyncQueue: AsyncQueueTask[];
-export const $$postDigestQueue: any[];
+export const $postUpdateQueue: any[];
 /**
  * @type {Function[]}
  */
@@ -158,10 +158,6 @@ export class Scope {
     /** @type {number} */
     $$watchersCount: number;
     $$isolateBindings: any;
-    /**
-     * @type {?Scope}
-     */
-    $$ChildScope: Scope | null;
     /**
      * Creates a new child {@link Scope}.
      *
@@ -177,16 +173,21 @@ export class Scope {
      *         When creating widgets, it is useful for the widget to not accidentally read parent
      *         state.
      *
-     * @param {?Scope} [parent=this] The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
-     *                              of the newly created scope. Defaults to `this` scope if not provided.
-     *                              This is used when creating a transclude scope to correctly place it
-     *                              in the scope hierarchy while maintaining the correct prototypical
-     *                              inheritance.
      *
      * @returns {Scope} The newly created child scope.
      *
      */
-    $new(isolate: boolean | null, parent?: Scope | null): Scope;
+    $new(isolate: boolean | null): Scope;
+    /**
+     * Creates a transcluded scope
+     * @param {Scope} parent The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
+     * of the newly created scope. This is used when creating a transclude scope to correctly place it
+     *  in the scope hierarchy while maintaining the correct prototypical inheritance.
+     *
+     * @returns {Scope} The newly created child scope.
+     *
+     */
+    $transcluded(parent: Scope): Scope;
     /**
    * Registers a `listener` callback to be executed whenever the `watchExpression` changes.
    *
@@ -239,16 +240,16 @@ export class Scope {
        });
        expect(scope.counter).toEqual(0);
   
-       scope.$digest();
+       ;
        // the listener is always called during the first $digest loop after it was registered
        expect(scope.counter).toEqual(1);
   
-       scope.$digest();
+       ;
        // but now it will not be called unless the value changes
        expect(scope.counter).toEqual(1);
   
        scope.name = 'adam';
-       scope.$digest();
+       ;
        expect(scope.counter).toEqual(2);
   
        // Using a function as a watchExpression
@@ -270,12 +271,12 @@ export class Scope {
        expect(scope.foodCounter).toEqual(0);
   
        // Run the digest but since food has not changed count will still be zero
-       scope.$digest();
+       ;
        expect(scope.foodCounter).toEqual(0);
   
        // Update food and run digest.  Now the counter will increment
        food = 'cheeseburger';
-       scope.$digest();
+       ;
        expect(scope.foodCounter).toEqual(1);
   
    * ```
@@ -377,16 +378,16 @@ export class Scope {
        });
        expect(scope.counter).toEqual(0);
   
-       scope.$digest();
+       ;
        // the listener is always called during the first $digest loop after it was registered
        expect(scope.counter).toEqual(1);
   
-       scope.$digest();
+       ;
        // but now it will not be called unless the value changes
        expect(scope.counter).toEqual(1);
   
        scope.name = 'adam';
-       scope.$digest();
+       ;
        expect(scope.counter).toEqual(2);
    * ```
    *
@@ -411,7 +412,7 @@ export class Scope {
      * Some of the things to consider are:
      *
      * * Any external event on a directive/component will not trigger a digest while the hosting
-     *   scope is suspended - even if the event handler calls `$apply()` or `$rootScope.$digest()`.
+     *   scope is suspended - even if the event handler calls `$apply()` or ``.
      * * Transcluded content exists on a scope that inherits from outside a directive but exists
      *   as a child of the directive's containing scope. If the containing scope is suspended the
      *   transcluded scope will also be suspended, even if the scope from which the transcluded
@@ -614,7 +615,7 @@ export class Scope {
    * @returns {*} The result of evaluating the expression.
    */
     $eval(expr?: string | ((arg0: Scope) => any), locals?: (object) | undefined): any;
-    $$postDigest(fn: any): void;
+    $postUpdate(fn: any): void;
     /**
      * @private
      */

package/types/directive/channel/channel.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Dynamically updates an element's content based on events published on a specified channel.
+ * When the directive is applied, it listens for data sent via `EventBus` and
+ * updates the inner HTML of the element accordingly.
+ *
+ * When the scope is destroyed, the directive automatically unsubscribes from the channel.
+ *
+ *
+ * @returns {import("../../types").Directive}
+ */
+export function ngChannelDirective(): import("../../types").Directive;

package/types/directive/form/form.d.ts

@@ -75,6 +75,7 @@ export class FormController {
      * may not mean that the form is still `$dirty`.
      */
     $removeControl(control: any): void;
+    $setValidity: (_a: any, _b: any, _c: any) => void;
     /**
      * Sets the form to a dirty state.
      *

package/types/shared/common.d.ts

@@ -1,4 +1,3 @@
-export function forEach(obj: any, cb: any, thisArg: any): void;
 export function equals(o1: any, o2: any): any;
 /**
  * Builds proxy functions on the `to` object which pass through to the `from` object.

package/types/shared/utils.d.ts

@@ -163,41 +163,6 @@ export function isArrayBuffer(obj: any): boolean;
  */
 export function trim(value: any): string | any;
 export function snakeCase(name: any, separator: any): any;
-/**
- * Invokes the `iterator` function once for each item in `obj` collection, which can be either an
- * object or an array. The `iterator` function is invoked with `iterator(value, key, obj)`, where `value`
- * is the value of an object property or an array element, `key` is the object property key or
- * array element index and obj is the `obj` itself. Specifying a `context` for the function is optional.
- *
- * It is worth noting that `.forEach` does not iterate over inherited properties because it filters
- * using the `hasOwnProperty` method.
- *
- * Unlike ES262's
- * [Array.prototype.forEach](http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18),
- * providing 'undefined' or 'null' values for `obj` will not throw a TypeError, but rather just
- * return the value provided.
- *
-   ```js
-     let values = {name: 'misko', gender: 'male'};
-     let log = [];
-     forEach(values, function(value, key) {
-       this.push(key + ': ' + value);
-     }, log);
-     expect(log).toEqual(['name: misko', 'gender: male']);
-   ```
- *
- * @param {Object|Array} obj Object to iterate over.
- * @param {Function} iterator Iterator function.
- * @param {Object=} context Object to become context (`this`) for the iterator function.
- * @returns {Object|Array} Reference to `obj`.
- */
-export function forEach(obj: any | any[], iterator: Function, context?: any | undefined): any | any[];
-/**
- * when using forEach the params are value, key, but it is often useful to have key, value.
- * @param {function(string, *):any} iteratorFn
- * @returns {function(*, string)}
- */
-export function reverseParams(iteratorFn: (arg0: string, arg1: any) => any): (arg0: any, arg1: string) => any;
 /**
  * Set or clear the hashkey for an object.
  * @param obj object