10 examples of 'typescript add property to object' in JavaScript

110
function defineReturnStringProperty(obj,prop,value){
111
	return 'Object.defineProperty('+obj+', "'+prop+'", {value: function() {return "' + value + '";}});';
112
}

276
function createObjectProperty(name) {
277
    return t.objectProperty(t.identifier(name), t.objectExpression([]));
278
}

111
function addProperty(object, value, observer) {
112
  var key = 1;
113
  while (key in object) {
114
    key++;
115
  }
116
  object[key] = value;
117
  observer(value, key, null);
118
  return key;
119
}

48
definePropertiesFromObject(properties) {
49
	Object.keys(properties).forEach(function (propertyName) {
50
		Reflect.defineProperty(this, propertyName, properties[propertyName]);
51
	}, this);
52
}

48
export function addProperty(node, property, value) {
49
  return {
50
    type: ADD_PROPERTY,
51
    node: node,
52
    property: property,
53
    value: value
54
  };
55
}

6
function add(obj, prop, val = null) {
7
  var _prop = '_' + prop;
8
  if (!obj.hasOwnProperty(_prop)) obj[_prop] = val;
9
10
  Object.defineProperty(obj, prop, {
11
    get: function() { return this[_prop]; },
12
    set: function(v) {
13
      if(v !== this[`_${prop}`]){
14
        this.emit('change', {property:prop, oldValue: this[`_${prop}`], 'value':v});
15
        this[`_${prop}`] = v;
16
      }
17
    },
18
    enumerable: true,
19
    configurable: true
20
  });
21
22
}

7
function propertiesToObject(t, props) {
8
  const keyedProps = {};
9
10
  function handleSpreadProperty(node) {
11
    if (typeof node.properties === 'undefined') return;
12
13
    node.properties.forEach(sprop => {
14
      if (t.isSpreadProperty(sprop)) {
15
        throw new Error('TODO: handle spread properties in spread properties');
16
      }
17
18
      keyedProps[sprop.key.name] = sprop.value.value;
19
    });
20
  }
21
22
  props.forEach(prop => {
23
    if (t.isSpreadProperty(prop)) {
24
      handleSpreadProperty(prop.get('argument').resolve().node);
25
    } else {
26
      // turn the key into a literal form
27
      const key = prop.toComputedKey();
28
      if (!t.isLiteral(key)) return; // probably computed
29
30
      // ensure that the value is a string
31
      const value = prop.get('value').resolve();
32
      if (!value.isLiteral()) return;
33
34
      // register property as one we'll try and autoprefix
35
      keyedProps[key.value] = value.node.value;
36
    }
37
38
    // remove property as it'll get added later again later
39
    prop.dangerouslyRemove();
40
  });
41
42
  return keyedProps;
43
}

5
function _setProperty(obj, key, value) { return obj[key] = value; }

108
function property(name: string, value: string): ts.PropertyAssignment {
109
  return ts.createPropertyAssignment(name, ts.createStringLiteral(value));
110
}

29
function objectProperty() {
30
    let o = arguments[0];
31
    // go through keys in the arguments
32
    for (let i = 1; i < arguments.length; ++i) {
33
        // if o is empty or is not an object, we can't get any property, so return undefined
34
        if (empty(o) || typeof(o) !== "object") {
35
            return undefined;
36
        }
37
        // get the next level down, which might be another object to check a property of (in which case we'll loop again)
38
        // or might be the final value to return, which could itself be an object (in which case the loop will end here)
39
        o = o[arguments[i]];
40
    }
41
    // if we get here return whatever we came up with.  It might be an object or a scalar
42
    return o;
43
}