@madronejs/core 1.0.16

package/dist/core.umd.js

@@ -0,0 +1 @@
+(function(l,y){typeof exports=="object"&&typeof module<"u"?y(exports):typeof define=="function"&&define.amd?define(["exports"],y):(l=typeof globalThis<"u"?globalThis:l||self,y(l.madrone={}))})(this,function(l){"use strict";const y=new Set;let te;function Re(){return[...y]}function Pe(){return Re().at(-1)}function ne(){te=Pe()}function re(e){e&&(y.add(e),ne())}function Te(e){y.delete(e),ne()}function C(){return te}const ce=new WeakMap;function V(e){var t;return(((t=C())==null?void 0:t.toRaw)??(()=>e))(e)}function S(e){ce.set(V(e),Date.now())}function Ie(e){return ce.get(V(e))}function _(e,n,t){var a;const r=C();if(!r)throw new Error("No integration specified");typeof t.get=="function"&&(r!=null&&r.defineComputed)?r.defineComputed(e,n,{get:t.get.bind(e),set:(a=t.set)==null?void 0:a.bind(e),enumerable:t.enumerable,configurable:t.configurable,cache:t.cache??!0}):!t.get&&(r!=null&&r.defineProperty)&&r.defineProperty(e,n,{value:t.value,enumerable:t.enumerable,configurable:t.configurable,deep:t.deep})}function ae(e,n){var a,f;const t=Object.getOwnPropertyDescriptors(e),r=(u,d)=>{var h;return(h=n==null?void 0:n[u])==null?void 0:h[d]};for(const[u,d]of Object.entries(t))_(e,u,{get:(a=d.get)==null?void 0:a.bind(e),set:(f=d.set)==null?void 0:f.bind(e),value:r(u,"value")??d.value,enumerable:r(u,"enumerable")??d.enumerable,configurable:r(u,"configurable")??d.configurable,cache:r(u,"cache")??!0,deep:r(u,"deep")??!0});return e}function ue(e,n,t){var a;const r=C();return(a=r==null?void 0:r.watch)==null?void 0:a.call(r,e,n,t)}const N=Symbol("keys"),$=Symbol("computed"),L=new WeakMap,j=new WeakMap,R=new WeakMap,P=new WeakMap;let B=[],W=null;const _e=e=>L.has(e),ie=e=>j.has(e),U=e=>L.get(e),Me=e=>j.get(e),Ee=e=>ie(e)?Me(e):e,Ae=(e,n)=>{L.set(e,n),j.set(n,e)},He=()=>{W===null&&(W=setTimeout(()=>{const e=B;for(B=[];e.length>0;)e.shift()();W=null}))},Ge=e=>{B.push(e),He()},se=(e,n)=>{const t=P.get(e),r=t==null?void 0:t.get(n);if(r){for(const a of r)R.get(a).delete(e);r.clear(),t.delete(n),t.size===0&&P.delete(e)}},fe=(e,n)=>{const t=De();if(!t)return;P.has(t)||P.set(t,new Map),R.has(e)||R.set(e,new Map);const r=R.get(e),a=P.get(t);r.has(n)||r.set(n,new Set),a.has(n)||a.set(n,new Set);const f=r.get(n),u=a.get(n);f.add(t),u.add(e)},de=(e,n)=>{const t=U(e);t&&fe(t,n)},oe=(e,n)=>{const t=R.get(e);if(t!=null&&t.get(n))for(const r of t.get(n))r.setDirty(),se(r,n)},T=(e,n)=>{oe(U(e),n)},Y=[];function De(){return Y.at(-1)}class K{static create(...n){return new K(...n)}constructor(n){this.name=n.name,this.get=n.get,this.set=n.set,this.cache=!!(n.cache??!0),this.alive=!0,this.dirty=!0,this.cachedVal=void 0,this.hooks={onGet:n.onGet,onSet:n.onSet,onChange:n.onChange,onImmediateChange:n.onImmediateChange}}callHook(n){typeof this.hooks[n]=="function"&&this.hooks[n](this)}dispose(){se(this,$),this.alive=!1,this.dirty=!1,this.cachedVal=void 0,this.prev=void 0}wrap(n){Y.push(this);const t=n();return Y.pop(),t}setHook(n,t){this.hooks[n]=t}setDirty(){this.alive&&!this.dirty&&(this.dirty=!0,oe(this,$),this.prev=this.cachedVal,this.callHook("onImmediateChange"),Ge(()=>this.notifyChange()))}notifyChange(){this.callHook("onChange"),this.prev=void 0}run(){if(!this.alive)return;const n=this.wrap(()=>((this.cache&&this.dirty||!this.cache)&&(this.cachedVal=this.get(),this.dirty=!1),this.cachedVal));return fe(this,$),this.callHook("onGet"),n}get value(){return this.run()}set value(n){if(typeof this.set=="function")this.set(n),this.callHook("onSet");else throw new TypeError(`No setter defined for "${this.name}"`)}}function le(...e){return K.create(...e)}function Ve(e){return le(e)}const M=e=>{const{name:n,target:t,key:r,receiver:a,value:f,keysChanged:u=!1,valueChanged:d=!1}=e;return{name:n,target:t,key:r,receiver:a,value:f,keysChanged:u,valueChanged:d}},Ne=(e,n,t,r)=>{var a;de(n,t),(a=e==null?void 0:e.onGet)==null||a.call(e,M({name:e.name,target:n,key:t,receiver:r}))},$e=(e,n,t,r)=>{var h;const a=n[t],f=Array.isArray(n);let u=!1,d=!1;t in n||(T(n,N),d=!0,f&&T(n,"length")),(a!==r||f)&&(T(n,t),u=!0),(d||u)&&((h=e==null?void 0:e.onSet)==null||h.call(e,M({name:e.name,target:n,key:t,value:r,keysChanged:d,valueChanged:u})))},Le=(e,n,t)=>{var r;T(n,t),T(n,N),(r=e==null?void 0:e.onDelete)==null||r.call(e,M({name:e.name,target:n,key:t,keysChanged:!0}))},he=(e,n,t)=>{var r;de(n,N),(r=e==null?void 0:e.onHas)==null||r.call(e,M({name:e.name,target:n,key:t}))};function me(e){const n=e.needsProxy||(()=>!0);return{get:(t,r,a)=>{var u;Ne(e,t,r,a);const f=Reflect.get(t,r,a);return n({target:t,key:r,value:f})&&(e!=null&&e.deep)&&((u=Object.getOwnPropertyDescriptor(t,r))!=null&&u.configurable)?O(f,e):f},set:(t,r,a)=>($e(e,t,r,a),Reflect.set(t,r,a)),deleteProperty:(...t)=>(Le(e,...t),Reflect.deleteProperty(...t)),has:(t,r)=>(he(e,t),Reflect.has(t,r)),ownKeys:t=>(he(e,t),Reflect.ownKeys(t)),getPrototypeOf:t=>Object.getPrototypeOf(t)}}const E=Object.freeze({object:e=>({...me(e)}),array:e=>({...me(e)})});function O(e,n){if(_e(e))return U(e);if(ie(e))return e;const t=n||{},r={...t,deep:(t==null?void 0:t.deep)??!0},a=O.getStringType(e);if(!O.hasHandler(a))return e;const f=new Proxy(e,O.typeHandler(a,r));return Ae(e,f),f}O.getStringType=e=>Object.prototype.toString.call(e).slice(8,-1).toLowerCase(),O.hasHandler=e=>!!E[e],O.typeHandler=(e,n)=>{var t;return(t=E[e])==null?void 0:t.call(E,n)};function X(e,n,t){const r=le({get:e,onChange:({value:f,prev:u})=>n(f,u)}),a=r.run();return t!=null&&t.immediate&&n(a),()=>r.dispose()}function A(e,n,t){var f,u,d,h;let r,a;if(n.cache){const v=Ve({...n,get:n.get,name:e,onImmediateChange:(f=t==null?void 0:t.computed)==null?void 0:f.onImmediateChange,onChange:(u=t==null?void 0:t.computed)==null?void 0:u.onChange,onGet:(d=t==null?void 0:t.computed)==null?void 0:d.onGet,onSet:(h=t==null?void 0:t.computed)==null?void 0:h.onSet});r=function(){return S(this),v.value},a=function(g){v.value=g}}else r=function(){return S(this),n.get.call(this)},a=function(...m){n.set.call(this,...m)};return{enumerable:n.enumerable,configurable:n.configurable,get:r,set:a}}function H(e,n,t){var f,u,d,h,v,m;const r={value:n.value},a=O(r,{name:e,onGet:(f=t==null?void 0:t.reactive)==null?void 0:f.onGet,onHas:(u=t==null?void 0:t.reactive)==null?void 0:u.onHas,onSet:(d=t==null?void 0:t.reactive)==null?void 0:d.onSet,onDelete:(h=t==null?void 0:t.reactive)==null?void 0:h.onDelete,needsProxy:(v=t==null?void 0:t.reactive)==null?void 0:v.needsProxy,deep:n.deep??((m=t==null?void 0:t.reactive)==null?void 0:m.deep)});return{configurable:n.configurable,enumerable:n.enumerable,get:function(){S(this);const{value:b}=a;return Array.isArray(b)&&Reflect.get(b,"length"),b},set:function(b){a.value=b}}}function k(e,n,t,r){Object.defineProperty(e,n,A(n,t,r))}function z(e,n,t,r){Object.defineProperty(e,n,H(n,t,r))}const G={toRaw:Ee,watch:X,describeProperty:H,defineProperty:z,describeComputed:A,defineComputed:k},F=new Set(["__proto__","__ob__"]),I="value";function je(e){const{observable:n,set:t}=e,r=new WeakMap,a=(c,i)=>{let o=r.get(c);o||(o=new Map,r.set(c,o));let w=o.get(i);return w||(w=n({[I]:0}),o.set(i,w)),w},f=t?c=>t(c,I,c[I]+1):c=>{c[I]+=1},u=(c,i)=>{F.has(i)||Reflect.get(a(c,i),I)},d=(c,i)=>{F.has(i)||f(a(c,i))},h=(c,i)=>{const o=r.get(c);o&&d(o,i),r.delete(c)},g={computed:{onGet:c=>{u(c,c.name)},onImmediateChange:c=>{d(c,c.name)}},reactive:{onGet:({target:c,key:i})=>{S(c),u(c,i)},onHas:({target:c,key:i})=>{u(c,i)},onDelete:({target:c,key:i})=>{h(c,i)},onSet:({target:c,key:i,keysChanged:o})=>{d(c,i),o&&d(c)},needsProxy:({key:c})=>!F.has(c)}};function b(c,i){return A(c,i,g)}function x(c,i){return H(c,i,g)}function ee(c,i,o){return k(c,i,o,g)}function s(c,i,o){return z(c,i,o,g)}return{toRaw:G.toRaw,watch:X,describeProperty:x,defineProperty:s,describeComputed:b,defineComputed:ee}}const q=new Set(["__proto__","__ob__"]),Q="value",Be=e=>{e[Q]+=1};function We({reactive:e,toRaw:n}={}){const t=n??(s=>s),r=new WeakMap,a=(s,c)=>{const i=t(s);let o=r.get(i);o||(o=new Map,r.set(i,o));let w=o.get(c);return w||(w=e({[Q]:0}),o.set(c,w)),w},f=(s,c)=>{q.has(c)||Reflect.get(a(s,c),Q)},u=(s,c)=>{q.has(c)||Be(a(s,c))},d=(s,c)=>{const i=t(s),o=r.get(i);o&&u(o,c),r.delete(i)},m={computed:{onGet:s=>{f(s,s.name)},onImmediateChange:s=>{u(s,s.name)}},reactive:{onGet:({target:s,key:c})=>{S(s),f(s,c)},onHas:({target:s,key:c})=>{f(s,c)},onDelete:({target:s,key:c})=>{d(s,c)},onSet:({target:s,key:c,keysChanged:i})=>{u(s,c),i&&u(s)},needsProxy:({key:s})=>!q.has(s)}};function g(s,c){return A(s,c,m)}function b(s,c){return H(s,c,m)}function x(s,c,i){return k(s,c,i,m)}function ee(s,c,i){return z(s,c,i,m)}return{toRaw:G.toRaw,watch:X,describeProperty:b,defineProperty:ee,describeComputed:g,defineComputed:x}}function ge(...e){const n={},t={};for(const r of e){const a=typeof r=="function"?r():r;Object.assign(n,Object.getOwnPropertyDescriptors(a??r??{}))}return Object.defineProperties(t,n),t}function ve(e,n){Object.defineProperties(e.prototype,Object.getOwnPropertyDescriptors(ge(...[...n,e].map(t=>t.prototype))))}const D=new WeakMap;function Ue(...e){return n=>{e!=null&&e.length&&ve(n,e)}}function be(e){D.has(e)||D.set(e,new Set)}function we(e,n){return be(e),D.get(e).has(n)}function Oe(e,n){be(e),D.get(e).add(n)}function ye(e,n,t,r){var f;return C()&&!we(e,n)?(_(e,n,{...t,get:t.get.bind(e),set:(f=t.set)==null?void 0:f.bind(e),enumerable:!0,...r==null?void 0:r.descriptors,cache:!0}),Oe(e,n),!0):!1}function Ce(e,n,t,r){if(typeof t.get=="function"){const a={...t,enumerable:!0,configurable:!0};return a.get=function(){return ye(this,n,t,r),this[n]},a.set=function(u){ye(this,n,t,r),this[n]=u},a}return t}function Se(e,n,t){return Ce(e,n,t)}Se.configure=function(n){return(t,r,a)=>Ce(t,r,a,{descriptors:n})};function J(e,n,t){return C()&&!we(e,n)?(Oe(e,n),_(e,n,{...Object.getOwnPropertyDescriptor(e,n),enumerable:!0,...t==null?void 0:t.descriptors}),!0):!1}function Z(e,n,t){typeof e=="function"?J(e,n):Object.defineProperty(e,n,{configurable:!0,enumerable:!0,get(){if(J(this,n,t))return this[n]},set(r){J(this,n,t)&&(this[n]=r)}})}function p(e,n){return Z(e,n)}p.shallow=function(n,t){return Z(n,t,{descriptors:{deep:!1}})},p.configure=function(n){return(t,r)=>Z(t,r,{descriptors:n})},re(G);const Ye={use:re,unuse:Te,auto:ae,define:_,watch:ue,lastAccessed:Ie};l.MadroneState=G,l.MadroneVue2=je,l.MadroneVue3=We,l.applyClassMixins=ve,l.auto=ae,l.classMixin=Ue,l.computed=Se,l.default=Ye,l.merge=ge,l.reactive=p,l.toRaw=V,l.watch=ue,Object.defineProperties(l,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@madronejs/core",
+  "version": "1.0.16",
+  "description": "Object composition and reactivity framework.",
+  "private": false,
+  "main": "./dist/core.umd.js",
+  "module": "./dist/core.mjs",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/core.mjs",
+      "require": "./dist/core.umd.js",
+      "types": "./types"
+    }
+  },
+  "license": "MIT",
+  "files": [
+    "dist/*.js",
+    "dist/*.mjs",
+    "types/**/*.d.ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/madronejs/madrone.git"
+  },
+  "bugs": {
+    "url": "https://github.com/madronejs/madrone/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "reactivity",
+    "composition",
+    "state management",
+    "madrone",
+    "vue"
+  ],
+  "devDependencies": {
+    "@types/lodash": "^4.14.197",
+    "@typescript-eslint/eslint-plugin": "^6.7.3",
+    "@typescript-eslint/parser": "^6.7.3",
+    "@vitest/coverage-v8": "^0.34.6",
+    "eslint": "^8.50.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-unicorn": "^48.0.1",
+    "happy-dom": "^12.6.0",
+    "lodash": "4.17.21",
+    "tsc-alias": "^1.8.7",
+    "typedoc": "^0.25.0",
+    "typescript": "^4.9.5",
+    "vite": "^4.4.10",
+    "vitest": "^0.34.6",
+    "vue2": "npm:vue@^2.7.14",
+    "vue3": "npm:vue@^3.3.4"
+  },
+  "engines": {
+    "node": "^18.8",
+    "pnpm": "^8.7.0"
+  },
+  "packageManager": "pnpm@8.7.0",
+  "scripts": {
+    "lint": "eslint src/ --ext .js,.jsx,.ts,.tsx",
+    "test": "vitest",
+    "test-ci": "CI=true NODE_ENV=test vitest run --coverage",
+    "docs": "typedoc --entryPoints src/index.ts",
+    "cleanup": "rm -rf ./dist && rm -rf ./types",
+    "cov": "CI=true NODE_ENV=test vitest run --coverage && open coverage/lcov-report/index.html",
+    "build": "vite build",
+    "build-types": "tsc -p ./tsconfig.types.json && tsc-alias -p tsconfig.types.json",
+    "build-all": "pnpm cleanup && pnpm build && pnpm build-types"
+  }
+}

package/types/__spec__/decorateComputed.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=decorateComputed.spec.d.ts.map

package/types/__spec__/decorateReactive.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=decorateReactive.spec.d.ts.map

package/types/__spec__/examples.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=examples.spec.d.ts.map

package/types/__spec__/merge.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=merge.spec.d.ts.map

package/types/auto.d.ts

@@ -0,0 +1,7 @@
+import { MadroneDescriptor, WatcherOptions } from './interfaces';
+export declare function define<T extends object>(obj: T, key: string, descriptor: MadroneDescriptor): void;
+export declare function auto<T extends object>(obj: T, objDescriptors?: {
+    [K in keyof T]?: MadroneDescriptor;
+}): T;
+export declare function watch<T>(scope: () => T, handler: (val: T, old: T) => any, options?: WatcherOptions): () => void;
+//# sourceMappingURL=auto.d.ts.map

package/types/decorate.d.ts

@@ -0,0 +1,24 @@
+import { DecoratorDescriptorType } from './interfaces';
+export declare function classMixin(...mixins: Array<Function>): (target: Function) => void;
+/**
+ * Configure a getter property to be cached
+ * @param target The target to add the computed property to
+ * @param key The name of the computed property
+ * @param descriptor property descriptors
+ * @returns the modified property descriptors
+ */
+export declare function computed(target: any, key: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+export declare namespace computed {
+    var configure: (descriptorOverrides: DecoratorDescriptorType) => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+}
+/**
+ * Configure a reactive property
+ * @param target The target to add the reactive property to
+ * @param key The name of the reactive property
+ */
+export declare function reactive(target: any, key: string): void;
+export declare namespace reactive {
+    var shallow: (target: any, key: string) => void;
+    var configure: (descriptorOverrides: DecoratorDescriptorType) => (target: any, key: string) => void;
+}
+//# sourceMappingURL=decorate.d.ts.map

package/types/global.d.ts

@@ -0,0 +1,12 @@
+import { Integration } from './interfaces';
+export declare function getIntegrations(): Integration[];
+export declare function addIntegration(integration: Integration): void;
+export declare function removeIntegration(integration: any): void;
+export declare function getIntegration(): Integration;
+/** Get the raw value of an object (without the proxy) */
+export declare function toRaw<T>(obj: T): T;
+/** Mark an object as accessed */
+export declare function objectAccessed(obj: object): void;
+/** The last time any reactive property was accessed on a given object */
+export declare function lastAccessed(obj: object): number;
+//# sourceMappingURL=global.d.ts.map

package/types/index.d.ts

@@ -0,0 +1,24 @@
+import { addIntegration, removeIntegration, lastAccessed } from './global';
+import { auto, define, watch } from './auto';
+declare const Madrone: {
+    /** Configure a global plugin */
+    use: typeof addIntegration;
+    /** Remove a global plugin */
+    unuse: typeof removeIntegration;
+    /** Create reactive objects */
+    auto: typeof auto;
+    /** Define properties on objects */
+    define: typeof define;
+    /** Watch reactive objects */
+    watch: typeof watch;
+    /** Get the last time any reactive property was touched on a given object */
+    lastAccessed: typeof lastAccessed;
+};
+export default Madrone;
+export * from './integrations';
+export * from './interfaces';
+export * from './decorate';
+export { toRaw } from './global';
+export { merge, applyClassMixins } from './util';
+export { watch, auto } from './auto';
+//# sourceMappingURL=index.d.ts.map

package/types/integrations/MadroneState.d.ts

@@ -0,0 +1,25 @@
+import { Integration, MadroneComputedDescriptor, MadronePropertyDescriptor } from '../interfaces';
+import { ReactiveOptions } from '../reactivity/interfaces';
+import { ObservableHooksType } from '../reactivity/Observer';
+type MadroneStateOptions<T = any> = {
+    reactive?: ReactiveOptions;
+    computed?: ObservableHooksType<T>;
+};
+export declare function describeComputed<T = any>(name: string, config: MadroneComputedDescriptor, options?: MadroneStateOptions<T>): {
+    enumerable: boolean;
+    configurable: boolean;
+    get: any;
+    set: any;
+};
+export declare function describeProperty(name: string, config: MadronePropertyDescriptor, options?: MadroneStateOptions): {
+    configurable: boolean;
+    enumerable: boolean;
+    get: () => any;
+    set: (val: any) => void;
+};
+export declare function defineComputed(target: any, name: string, config: MadroneComputedDescriptor, options: any): void;
+export declare function defineProperty(target: any, name: string, config: MadronePropertyDescriptor, options?: any): void;
+declare const MadroneState: Integration;
+export default MadroneState;
+export { Watcher as watch } from '../reactivity';
+//# sourceMappingURL=MadroneState.d.ts.map

package/types/integrations/MadroneVue2.d.ts

@@ -0,0 +1,3 @@
+import { Integration } from '../interfaces';
+export default function MadroneVue2(opts: any): Integration;
+//# sourceMappingURL=MadroneVue2.d.ts.map

package/types/integrations/MadroneVue3.d.ts

@@ -0,0 +1,3 @@
+import type { Integration } from '../interfaces';
+export default function MadroneVue3({ reactive, toRaw }?: any): Integration;
+//# sourceMappingURL=MadroneVue3.d.ts.map

package/types/integrations/__spec__/madroneState.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=madroneState.spec.d.ts.map

package/types/integrations/__spec__/testAccess.d.ts

@@ -0,0 +1,2 @@
+export default function testClass(integrationName: any, integration: any): void;
+//# sourceMappingURL=testAccess.d.ts.map

package/types/integrations/__spec__/testAll.d.ts

@@ -0,0 +1,4 @@
+export default function testAll(name: string, integration: any, options?: {
+    blacklist?: Array<string>;
+}): void;
+//# sourceMappingURL=testAll.d.ts.map

package/types/integrations/__spec__/testAuto.d.ts

@@ -0,0 +1,2 @@
+export default function testAuto(name: any, integration: any): void;
+//# sourceMappingURL=testAuto.d.ts.map

package/types/integrations/__spec__/testClass.d.ts

@@ -0,0 +1,2 @@
+export default function testClass(name: any, integration: any): void;
+//# sourceMappingURL=testClass.d.ts.map

package/types/integrations/__spec__/testVue.d.ts

@@ -0,0 +1,2 @@
+export default function testVue(name: any, integration: any, options: any): void;
+//# sourceMappingURL=testVue.d.ts.map

package/types/integrations/__spec__/vue2.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=vue2.spec.d.ts.map

package/types/integrations/__spec__/vue3.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=vue3.spec.d.ts.map

package/types/integrations/index.d.ts

@@ -0,0 +1,4 @@
+export { default as MadroneState } from './MadroneState';
+export { default as MadroneVue2 } from './MadroneVue2';
+export { default as MadroneVue3 } from './MadroneVue3';
+//# sourceMappingURL=index.d.ts.map

package/types/interfaces.d.ts

@@ -0,0 +1,27 @@
+export interface MadroneDescriptor extends PropertyDescriptor {
+    /** Cache a computed property */
+    cache?: boolean;
+    /** Define a deeply reactive property */
+    deep?: boolean;
+}
+export type MadroneComputedDescriptor = Pick<MadroneDescriptor, 'get' | 'set' | 'cache' | 'enumerable' | 'configurable'>;
+export type MadronePropertyDescriptor = Pick<MadroneDescriptor, 'configurable' | 'enumerable' | 'value' | 'deep'>;
+export interface MadroneDescriptorMap {
+    [key: string]: MadroneDescriptor;
+}
+export type DecoratorDescriptorType = Omit<MadroneDescriptor, 'get' | 'set' | 'writable' | 'value'>;
+export type DecoratorOptionType = {
+    descriptors?: DecoratorDescriptorType;
+};
+export type WatcherOptions = {
+    immediate?: boolean;
+};
+export interface Integration {
+    defineProperty: (target: any, name: string, config: MadronePropertyDescriptor, options?: any) => any;
+    defineComputed: (target: any, name: string, config: MadroneComputedDescriptor, options?: any) => any;
+    toRaw?: <T>(target: T) => T;
+    watch?: <T>(scope: () => any, handler: (val: T, old?: T) => any, options?: WatcherOptions) => () => void;
+    describeComputed?: (name: string, config: MadroneComputedDescriptor, options?: any) => PropertyDescriptor;
+    describeProperty?: (name: string, config: MadronePropertyDescriptor, options?: any) => PropertyDescriptor;
+}
+//# sourceMappingURL=interfaces.d.ts.map

package/types/reactivity/Computed.d.ts

@@ -0,0 +1,8 @@
+import { ObservableOptions } from './Observer';
+/**
+ * Create a new computed instance
+ * @param options the computed options
+ * @returns the created instance
+ */
+export default function Computed<T>(options: ObservableOptions<T>): import("./Observer").ObservableItem<T>;
+//# sourceMappingURL=Computed.d.ts.map

package/types/reactivity/Observer.d.ts

@@ -0,0 +1,50 @@
+export declare function getCurrentObserver(): ObservableItem<any>;
+export declare enum OBSERVER_HOOK {
+    onGet = "onGet",
+    onSet = "onSet",
+    onChange = "onChange",
+    onImmediateChange = "onImmediateChange"
+}
+export type ObservableHookType<T> = (obs: ObservableItem<T>) => void;
+export type ObservableHooksType<T> = {
+    onGet?: ObservableHookType<T>;
+    onSet?: ObservableHookType<T>;
+    onChange?: ObservableHookType<T>;
+    onImmediateChange?: ObservableHookType<T>;
+};
+export type ObservableOptions<T> = {
+    get: () => T;
+    name?: string;
+    set?: (val: T) => void;
+    cache?: boolean;
+} & ObservableHooksType<T>;
+declare class ObservableItem<T> {
+    static create<CType>(...args: ConstructorParameters<typeof ObservableItem<CType>>): ObservableItem<CType>;
+    constructor(options: ObservableOptions<T>);
+    name: string;
+    alive: boolean;
+    dirty: boolean;
+    prev: T;
+    cache: boolean;
+    private cachedVal;
+    private hooks;
+    private get;
+    private set;
+    private callHook;
+    /**
+     * Stop observing and dispose of the observer
+     * @returns {void}
+     */
+    dispose(): void;
+    private wrap;
+    setHook(hook: OBSERVER_HOOK, cb: ObservableHookType<T>): void;
+    setDirty(): void;
+    private notifyChange;
+    run(): T;
+    /** The value of the observer */
+    get value(): T;
+    set value(val: T);
+}
+export { ObservableItem };
+export default function Observer<T = any>(...args: Parameters<typeof ObservableItem.create<T>>): ObservableItem<T>;
+//# sourceMappingURL=Observer.d.ts.map

package/types/reactivity/Reactive.d.ts

@@ -0,0 +1,15 @@
+import { ReactiveOptions } from './interfaces';
+/**
+ * Observe an object
+ * @param {Object} target the object to observe
+ * @param {Object} options the observation options
+ * @returns {Proxy} a proxied version of the object that can be observed
+ */
+declare function Reactive<T extends object>(target: T, options?: ReactiveOptions<T>): T;
+declare namespace Reactive {
+    var getStringType: (obj: any) => any;
+    var hasHandler: (type: any) => boolean;
+    var typeHandler: (type: any, hooks: any) => any;
+}
+export default Reactive;
+//# sourceMappingURL=Reactive.d.ts.map

package/types/reactivity/Watcher.d.ts

@@ -0,0 +1,10 @@
+import { WatcherOptions } from '../interfaces';
+/**
+ * Watch an observable for changes
+ * @param get the getter function returning the item to watch
+ * @param handler the callback whenever the value returned from `get` changes
+ * @param {Boolean} [options.deep] deeply watch the value
+ * @returns a disposer
+ */
+export default function Watcher<T>(get: () => T, handler: (val?: T, old?: T) => any, options?: WatcherOptions): () => void;
+//# sourceMappingURL=Watcher.d.ts.map

package/types/reactivity/__spec__/observer.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=observer.spec.d.ts.map

package/types/reactivity/__spec__/observer_array.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=observer_array.spec.d.ts.map

package/types/reactivity/__spec__/observer_object.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=observer_object.spec.d.ts.map

package/types/reactivity/__spec__/observer_set.xspec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=observer_set.xspec.d.ts.map

package/types/reactivity/__spec__/reactive.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reactive.spec.d.ts.map

package/types/reactivity/__spec__/reactive_array.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reactive_array.spec.d.ts.map

package/types/reactivity/__spec__/reactive_object.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reactive_object.spec.d.ts.map

package/types/reactivity/__spec__/reactive_set.xspec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reactive_set.xspec.d.ts.map

package/types/reactivity/__spec__/watcher.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=watcher.spec.d.ts.map

package/types/reactivity/global.d.ts

@@ -0,0 +1,51 @@
+import { ObservableItem } from './Observer';
+export declare const KEYS_SYMBOL: unique symbol;
+export declare const OBSERVER_SYMBOL: unique symbol;
+/** Check if the current target has a proxy associated with it */
+export declare const isReactiveTarget: (target: any) => boolean;
+/** Check if the current proxy has a target object */
+export declare const isReactive: (trk: any) => boolean;
+export declare const getReactive: (target: any) => any;
+export declare const getTarget: (tracker: any) => any;
+export declare const getProxy: (targetOrProxy: any) => any;
+export declare const toRaw: (targetOrProxy: any) => any;
+export declare const getDependencies: (observer: any) => Map<string | symbol | ObservableItem<any>, Set<any>>;
+/** Get the list of items that are observing a given proxy */
+export declare const getObservers: (tracker: any) => Map<string | symbol | ObservableItem<any>, Set<ObservableItem<any>>>;
+export declare const addReactive: (target: any, proxy: any) => void;
+export declare const schedule: (task: any) => void;
+/**
+ * Clear all of the current dependencies an observer has
+ * @param {Observable} obs the observable to clear it's dependencies
+ * @param {String} key the key to clear
+ * @returns {void}
+ */
+export declare const observerClear: (obs: ObservableItem<any>, key: string | symbol | ObservableItem<any>) => void;
+/**
+ * Make an observer depend on a trackable item
+ * @param {trackable} trk the trackable item we're depending on
+ * @param {String} key the key to depend on
+ * @returns {void}
+ */
+export declare const dependTracker: (trk: object, key: string | symbol | ObservableItem<any>) => void;
+/**
+ * Make an observer depend on a raw target
+ * @param target the target to depend on
+ * @param key the key to depend on
+ * @returns {void}
+ */
+export declare const dependTarget: (target: object, key: string | symbol) => void;
+/**
+ * Tell all observers of a trackable that the trackable changed
+ * @param trk the trackable that changed
+ * @param key the key on the trackable that changed
+ * @return {void}
+ */
+export declare const trackerChanged: (trk: any, key: any) => void;
+/**
+ * Tell all observers listening to this target that this changed
+ * @param target the target that changed
+ * @param key the key on the trackable that changed
+ */
+export declare const targetChanged: (target: any, key: string | symbol) => void;
+//# sourceMappingURL=global.d.ts.map

package/types/reactivity/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Computed } from './Computed';
+export { default as Reactive } from './Reactive';
+export { default as Watcher } from './Watcher';
+export { toRaw } from './global';
+//# sourceMappingURL=index.d.ts.map

package/types/reactivity/interfaces.d.ts

@@ -0,0 +1,28 @@
+export type TypeHandlerOptions<T extends object = any> = {
+    name?: string;
+    deep?: boolean;
+    receiver?: any;
+    target?: T;
+    key?: keyof T;
+    value?: T[keyof T];
+    keysChanged?: boolean;
+    valueChanged?: boolean;
+};
+export type HandlerHookType<T extends object = any> = (options: TypeHandlerOptions<T>) => void;
+export type CheckProxyHookType<T extends object = any> = (options: {
+    target: T;
+    key: keyof T;
+    value: T[keyof T];
+}) => boolean;
+export type ReactiveHandlerHooks<T extends object = any> = {
+    onGet: HandlerHookType<T>;
+    onSet: HandlerHookType<T>;
+    onDelete: HandlerHookType<T>;
+    onHas: HandlerHookType<T>;
+    needsProxy: CheckProxyHookType<T>;
+};
+export type ReactiveOptions<T extends object = any> = {
+    name?: any;
+    deep?: boolean;
+} & Partial<ReactiveHandlerHooks<T>>;
+//# sourceMappingURL=interfaces.d.ts.map

package/types/reactivity/typeHandlers.d.ts

@@ -0,0 +1,20 @@
+declare const _default: Readonly<{
+    object: (options: any) => {
+        get: (target: any, prop: any, receiver: any) => any;
+        set: (target: object, propertyKey: PropertyKey, value: any) => boolean;
+        deleteProperty: (target: object, propertyKey: PropertyKey) => boolean;
+        has: (target: any, key: any) => boolean;
+        ownKeys: (target: any) => (string | symbol)[];
+        getPrototypeOf: (target: any) => any;
+    };
+    array: (options: any) => {
+        get: (target: any, prop: any, receiver: any) => any;
+        set: (target: object, propertyKey: PropertyKey, value: any) => boolean;
+        deleteProperty: (target: object, propertyKey: PropertyKey) => boolean;
+        has: (target: any, key: any) => boolean;
+        ownKeys: (target: any) => (string | symbol)[];
+        getPrototypeOf: (target: any) => any;
+    };
+}>;
+export default _default;
+//# sourceMappingURL=typeHandlers.d.ts.map

package/types/test/util.d.ts

@@ -0,0 +1,2 @@
+export declare function delay(t?: any, v?: any): Promise<unknown>;
+//# sourceMappingURL=util.d.ts.map

package/types/util.d.ts

@@ -0,0 +1,32 @@
+type OptionalPropertyNames<T> = {
+    [K in keyof T]-?: any extends {
+        [P in K]: T[K];
+    } ? K : never;
+}[keyof T];
+type SpreadProperties<L, R, K extends keyof L & keyof R> = {
+    [P in K]: L[P] | Exclude<R[P], undefined>;
+};
+type Id<T> = T extends infer U ? {
+    [K in keyof U]: U[K];
+} : never;
+export type SpreadTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>> & Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>> & SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>>;
+export type Spread<A extends readonly [...any]> = A extends [infer L, ...infer R] ? SpreadTwo<L extends (...any: any[]) => any ? ReturnType<L> : L, Spread<R>> : unknown;
+/**
+ * Merge multiple object definitions into a single new object definition
+ * @param types
+ * @returns The new object definition
+ */
+export declare function merge<A extends object[]>(...types: [...A]): Spread<A>;
+/**
+ * Extend the prototype of a base class with the prototypes of other classes. Mutates the base class.
+ * @param base Base class that the mixins will be mixed into. Any naming conflicts will prefer this base class.
+ * @param constructors List of mixin classes that will be applied to the base class.
+ */
+export declare function applyClassMixins(base: any, mixins: [...any]): void;
+export declare function getDefaultDescriptors(obj: any, defaults?: any): {
+    [x: string]: TypedPropertyDescriptor<any>;
+} & {
+    [x: string]: PropertyDescriptor;
+};
+export {};
+//# sourceMappingURL=util.d.ts.map