We need to have documentation for the prototype methods, for example can-define/map/map.prototype.forEach.

This is shown within the how to read the api guide - https://canjs.com/doc/guides/api.html#DocumentationStructure

https://canjs.com/doc/can-define/map/map.prototype.forEach.html

define.setup does the following:

Object.defineProperty(this,"constructor", {value: this.constructor, enumerable: false, writable: false});
Object.defineProperty(this,canMetaSymbol, {value: Object.create(null), enumerable: false, writable: false});

This makes it so if a can.meta is already established, this gets overwritten every time .initialize() is called ...

This creates problems for can-stache-define-element because:

• elements exist before they are initialized
• elements should be able to be re-initialized when disconnected

I think we might want to separate define.setup into "initialize" and "finalizeInstance".

finalizeInstance should prepare the instance for anything that needs to exist for a working instance. It's similar to finalizeClass. It needs to be called only once on the instance for "all time".

initialize() should be able to be called multiple times without breaking what has been done in finalizeClass.

SAME AS canjs/can-observable-array#83

With the changes to make class fields observable, setting expando properties using .set is now broken. Here is an example:

class Foo extends ObservableObject{}
const foo = new Foo();
foo.set("action", 10);

This is the error thrown:

Uncaught TypeError: Cannot read property 'action' of undefined
    at Object.get MyMap{}.action [as get] (define.js:809)
    at Object.defineProperty (can-observable-object.js:29)
    at Function.defineProperty (<anonymous>)
    at Object_defineNamedPrototypeProperty (define.js:81)
    at Function.define.property (define.js:410)
    at Object.define.expando [as defineExpando] (define.js:1167)
    at Proxy.setKeyValue (mixin-mapprops.js:57)
    at Proxy.set (mixin-mapprops.js:108)
    at canRoute._onStartComplete (route-observable-test.js:229)
    at eval (can-route.js:84)

This is a meta issue for all of the documentation needed. Much of this comes from the design doc.

• static define = {}
• getters/setters on the prototype
• DefineObject
• DefineArray
• static items = Todo
• type.maybe()
• type.convert()
• type.check()
• type.maybeConvert()
• type.Any
• static propertyDefaults = {}
• new ExtendedDefineClass({propNotDefined: "value"})
• static seal = false

PropDefinitions

• age: 36 - default
• age: Number primitive constructor
• age: NumberType constructor
• age: type.convert(Number) using can-type
• age: function() { } Used as the default value
• age: {} propDefinition

PropDefinitions object

• type
• default: Primitive | Function | Object
• get default() { }
• get() { }
• set( [newVal] [,lastSet] ){}
• async( [resolve] ){}
• value( {resolve, listenTo, stopListening, lastSet}){}
• required: Boolean=false
• enumerable: Boolean
• serialize(value): Any

The dependency can-observable-mixin was updated from 1.0.0-pre.11 to 1.0.0.

🚨 View failing branch.

This version is covered by your current version range and after updating it in your project the build failed.

can-observable-mixin is a direct dependency of this project, and it is very likely causing it to break. If other packages depend on yours, this update is probably also breaking those in turn.

Your Greenkeeper Bot 🌴

From canjs/can-type#3:

We probably want a type section in can-define-object.

Probably before https://canjs.com/doc/can-define-object.html#Declarativeproperties, a section on Typed properties or something like this would make sense.

I think if someone tries:

var s = new Symbol();

o = new DefineObject();

ObservationRecorder.start();
o[s]
var records = ObservationRecorder.stop();

records will include something for the symbol. This creates unnecessary bindings. We should never listen to a symbol property.

Not sure why, something throws when route.start() is called.

When using Steal, the following code:

class Todo extends ObservableObject {
}

new Todo();

throws with:

Uncaught TypeError: Class constructor ObservableObject cannot be invoked without 'new'

Ref: canjs/can-stache-element#26

• create a can-define-object-legacy branch
• update readme with a deprecation notice and link to can-observable-object
• publish a patch to NPM
• rename repository and package name to can-observable-object
• Rename export to ObservableObject
• use can-define-mixin that supports props
• update documentation to show ObservableObject and props everywhere
• publish can-observable-object
• update canjs#master to use new package and export both DefineObject and ObservableObject
• npm deprecate can-define-object

Using canReflect.setKeyValue dispatches more than one event:

Using setKeyValue will have a descriptor with getter and setter and this case should be handled in the returned proxy.

Another issue to fix is to add the instance to the observable instances in observable-mixin:
https://github.com/canjs/can-observable-mixin/blob/dea26780f37fc75aeba6ea9d8409f0701e90d157/src/mixin-proxy.js#L80

These all work:

class Obj extends DefineObject {
    static define = {
        name: { default: "Kevin" },
        get excitedName() {
            return this.name + "!!!";
        },
        lowerCaseName: {
            get() {
                return this.name.toLowerCase()
            }
        }
    };
    get upperCaseName() {
        return this.name.toUpperCase()
    }
  }

Should we document them all?