├── .gitignore
├── LICENSE
├── README.md
├── alert
    ├── jin-alert.env=node.jam.js
    └── jin-alert.env=web.jam.js
├── alias
    └── jin_alias.jam.js
├── application
    └── jin_application.env=node.ts
├── async2defer
    └── jin_async2defer.env=node.jam.js
├── async2sync
    ├── async2sync.ts
    └── jin_async2sync.env=node.jam.js
├── atom
    ├── flag
    │   └── atom-flag.ts
    ├── get
    │   └── get.ts
    ├── list
    │   └── atom-list.ts
    ├── map
    │   └── atom-map.ts
    ├── numb
    │   └── numb.ts
    ├── prop
    │   ├── prop.stage=dev.ts
    │   └── prop.ts
    ├── status
    │   └── status.ts
    ├── str
    │   └── str.ts
    └── wait
    │   └── wait.ts
├── atom1
    ├── clearable
    │   └── jin-atom-clearable.jam.js
    ├── failable
    │   └── jin-atom-failable.jam.js
    ├── getable
    │   └── jin-atom-getable.jam.js
    ├── jin-atom.jam.js
    ├── logable
    │   └── jin-atom-logable.jam.js
    ├── mergable
    │   └── jin-atom-mergable.jam.js
    ├── prop
    │   └── jin-atom-prop.jam.js
    ├── pullable
    │   ├── jin-atom-pullable.jam.js
    │   └── jin-atom-pullable_test.stage=dev.jam.js
    ├── pushable
    │   ├── jin-atom-pushable.jam.js
    │   └── jin-atom-pushable_test.stage=dev.jam.js
    └── variable
    │   ├── jin-atom-variable.jam.js
    │   └── jin-atom-variable_test.stage=dev.jam.js
├── audio
    └── jin-audio.jam.js
├── autoloader
    └── jin_autoloader.env=node.jam.js
├── ball
    ├── jin-ball.stage=dev.ts
    ├── jin-ball.ts
    └── jin-ball_input.tree
├── bench
    ├── app
    │   ├── index.html
    │   ├── jin-bench-app.css
    │   ├── jin-bench-app.jam.js
    │   └── jin-bench-app.sample.html
    ├── case
    │   ├── jin-bench-case.css
    │   ├── jin-bench-case.jam.js
    │   └── jin-bench-case.sample.html
    ├── header
    │   └── jin-bench-header.css
    ├── jin-bench.demo.html
    └── jin-bench.jam.js
├── build
    ├── jin-build.env=node.jam.js
    ├── jin-build.meta.tree
    ├── jin-build_auto.env=node.jam.js
    ├── jin-build_cssCompiled.env=node.jam.js
    ├── jin-build_cssIndex.env=node.jam.js
    ├── jin-build_dependTree.env=node.jam.js
    ├── jin-build_jsCompiled.env=node.jam.js
    ├── jin-build_jsIndexNode.env=node.jam.js
    └── jin-build_jsIndexWeb.env=node.jam.js
├── cache
    └── cache.ts
├── chat
    ├── jin-chat-x.demo.html
    ├── jin-chat.demo.html
    └── jin-chat.jam.js
├── concater
    └── jin-concater.ts
├── confirm
    └── jin_confirm.env=node.jam.js
├── cookie
    └── jin-cookie.jam.js
├── coverage
    └── jin_coverage.env=node.jam.js
├── crier
    ├── jin_crier.env=node.jam.js
    └── jin_crier.env=node.stage=dev.jam.js
├── crypt
    └── crypt.env=node.ts
├── date
    └── today
    │   └── jin-date-today.jam.js
├── db
    └── oriento
    │   └── oriento.env=node.ts
├── debuild
    └── debuild.env=node.jam.js
├── defer
    ├── defer.ts
    └── jin_defer_test.stage=dev.jam.js
├── definer
    └── jin-definer.jam.js
├── demo.html
├── dnd
    ├── jin_dnd.demo.html
    ├── jin_dnd_event.env=web.jam.js
    ├── jin_dnd_onDrag.env=web.jam.js
    ├── jin_dnd_onDrop.env=web.jam.js
    ├── jin_dnd_onEnd.env=web.jam.js
    ├── jin_dnd_onEnter.env=web.jam.js
    ├── jin_dnd_onLeave.env=web.jam.js
    ├── jin_dnd_onOver.env=web.jam.js
    └── jin_dnd_onStart.env=web.jam.js
├── doc
    └── jin_doc.jam.js
├── docs
    └── jin-docs.jam.js
├── dom
    ├── dom.ts
    ├── event
    │   ├── jin_dom_event.env=web.jam.js
    │   ├── jin_dom_event_onBlur.env=web.jam.js
    │   ├── jin_dom_event_onChange.env=web.jam.js
    │   ├── jin_dom_event_onClick.env=web.jam.js
    │   ├── jin_dom_event_onDoubleClick.env=web.jam.js
    │   ├── jin_dom_event_onInput.env=web.jam.js
    │   ├── jin_dom_event_onPress.env=web.jam.js
    │   ├── jin_dom_event_onResize.env=web.jam.js
    │   ├── jin_dom_event_onScroll.env=web.jam.js
    │   └── jin_dom_event_onWheel.env=web.jam.js
    ├── jin-dom-test.env=web.stage=dev.jam.js
    ├── jin_dom.env=node.jam.js
    ├── jin_dom.env=web.jam.js
    ├── jin_dom.jam.js
    ├── range
    │   └── jin-dom-range.env=web.jam.js
    └── selection
    │   └── jin-dom-selection.jam.js
├── dom2
    └── listener
    │   └── dom2.ts
├── dumb
    └── dumb.ts
├── editor
    ├── jin-editor.css
    ├── jin-editor.env=web.jam.js
    ├── jin-editor.env=web.jam.js.rej
    ├── jin-editor.sample.html
    └── jin-editor.sample.html.rej
├── ensure
    ├── number.jam.js
    └── string.jam.js
├── enumeration
    └── enumeration.ts
├── env
    └── jin_env.jam.js
├── error
    └── error.ts
├── event
    ├── jin_event.doc.xml
    └── jin_event.jam.js
├── eventProof
    ├── jin_eventProof.doc.xml
    └── jin_eventProof.env=web.jam.js
├── execute
    └── jin_execute.env=node.jam.js
├── fiberize
    └── jin_fiberize.env=node.jam.js
├── field
    ├── jin-field.css
    ├── jin-field.jam.js
    └── jin-field.sample.html
├── file
    ├── file.ts
    ├── jin-file-base.env=node.jam.js
    ├── jin-file-type-css.env=node.jam.js
    ├── jin-file-type-demoTree.env=node.jam.js
    ├── jin-file-type-html.env=node.jam.js
    ├── jin-file-type-jamJS.env=node.jam.js
    ├── jin-file-type-js.env=node.jam.js
    ├── jin-file-type-metaTree.env=node.jam.js
    ├── jin-file-type-ngHtml.env=node.jam.js
    ├── jin-file-type-png.env=node.jam.js
    ├── jin-file-type-sampleHTML.env=node.jam.js
    ├── jin-file-type-text.env=node.jam.js
    ├── jin-file-type-tree.env=node.jam.js
    ├── jin-file-type-ts.env=node.jam.js
    ├── jin-file-type-viewTree.env=node.jam.js
    ├── jin-file-type-viewTree0.env=node.jam.js
    └── jin-file.env=node.jam.js
├── func
    ├── collector
    │   └── collector.ts
    ├── filter
    │   └── filter.ts
    ├── iterator
    │   └── iterator.ts
    ├── jin_func.jam.js
    ├── limiter
    │   └── limiter.ts
    ├── make
    │   └── make.jam.js
    ├── mapper
    │   └── mapper.ts
    ├── name
    │   └── name.jam.js
    ├── pipe
    │   └── pipe.ts
    ├── pipeline
    │   └── pipeline.ts
    └── usages
    │   └── usages.jam.js
├── git-init.cmd
├── glob
    └── jin_glob.jam.js
├── handler
    └── handler.ts
├── html
    └── html.ts
├── identical
    └── jin_identical.jam.js
├── jin.env=node.jam.js
├── jin.jam.js
├── jsonp
    └── jsonp.env=web.ts
├── klass
    ├── jin_class.doc.xml
    ├── jin_class.doc.xml.tree
    └── jin_klass.jam.js
├── konst
    └── jin-konst.jam.js
├── l10n
    └── jin-l10n.jam.js
├── lazyProxy
    └── jin_lazyProxy.jam.js
├── list
    ├── jin-list-proto.jam.js
    ├── jin-list-test.stage=dev.jam.js
    ├── jin-list.css
    ├── jin-list.env=node.jam.js
    └── jin-list.env=web.jam.js
├── listener
    └── jin_listener.jam.js
├── log
    ├── jin-log.env=node.jam.js
    ├── jin-log.env=web.jam.js
    ├── log.env=web.ts
    └── log.ts
├── mailer
    └── mailer.ts
├── makeId
    ├── jin_makeId.doc.xml
    └── jin_makeId.jam.js
├── merge
    └── jin-merge.jam.js
├── method
    ├── jin-method.doc.md
    ├── jin_method.jam.js
    └── naming
    │   └── jin_method_naming.jam.js
├── middle4pack
    └── jin_middle4pack.env=node.jam.js
├── middle4static
    └── jin_middle4static.env=node.jam.js
├── minify
    └── jin_minify_js.env=node.jam.js
├── mixin
    └── jin_mixin.jam.js
├── mock
    └── jin_mock.jam.js
├── model
    ├── model.stage=dev.ts
    └── model.ts
├── module
    └── jin-module.jam.js
├── object
    ├── object.stage=dev.ts
    └── object.ts
├── onDomReady
    └── jin_onDomReady.env=web.jam.js
├── onElemAdd
    ├── jin_onElemAdd.doc.xml
    └── jin_onElemAdd.env=web.jam.js
├── onElemDrop
    ├── jin_onElemDrop.doc.xml
    └── jin_onElemDrop.env=web.jam.js
├── pack
    └── props
    │   └── props.meta.tree
├── package.json
├── param
    ├── jin_param.jam.js
    ├── jin_param_hash.env=node.jam.js
    ├── jin_param_hash.env=web.jam.js
    └── param.ts
├── path
    └── jin_path.jam.js
├── persistent
    └── jin_persistent.env=node.jam.js
├── pipe
    ├── jin-pipe.jam.js
    └── pipe.ts
├── plotter
    ├── jin-plotter.css
    ├── jin-plotter.jam.js
    └── jin-plotter.sample.html
├── pointer
    └── pointer.ts
├── pool
    └── jin-pool.jam.js
├── press
    ├── jin-press-onEnter.env=web.jam.js
    ├── jin-press-onEscape.env=web.jam.js
    ├── jin-press-onGoDown.env=web.jam.js
    ├── jin-press-onGoLeft.env=web.jam.js
    ├── jin-press-onGoRight.env=web.jam.js
    └── jin-press-onGoUp.env=web.jam.js
├── prop
    ├── proxy
    │   └── proxy.ts
    └── vary
    │   ├── vary.stage=dev.ts
    │   └── vary.ts
├── property
    └── jin_property.jam.js
├── proxy
    └── jin_proxy.jam.js
├── registry
    ├── jin_registry.doc.xml
    └── jin_registry.jam.js
├── request
    ├── jin_request.env=node.jam.js
    ├── jin_request.env=web.jam.js
    └── request.ts
├── root
    └── jin_root.jam.js
├── sample
    ├── demo
    │   ├── jin-sample-demo.css
    │   ├── jin-sample-demo.jam.js
    │   └── jin-sample-demo.sample.html
    └── jin_sample.jam.js
├── schedule
    └── schedule.ts
├── server
    ├── jin-server.jam.js
    └── server.ts
├── set
    ├── jin-set-proto.jam.js
    ├── jin-set.css
    ├── jin-set.env=node.jam.js
    ├── jin-set.env=web.jam.js
    └── set.ts
├── sleep
    └── jin_sleep.env=node.jam.js
├── slide
    ├── jin-slide.css
    ├── jin-slide.demo.html
    ├── jin-slide.env=web.jam.js
    └── jin-slide.sample.html
├── socket
    └── socket.ts
├── state
    ├── local
    │   └── jin_state_local.env=web.jam.js
    └── url
    │   └── url.env=web.ts
├── storage
    ├── jin_storage.jam.js
    └── mongo
    │   └── jin_storage_mongo.env=node.jam.js
├── support
    └── jin_support.env=web.jam.js
├── sync
    └── sync.ts
├── sync2async
    ├── jin_sync2async.env=node.jam.js
    ├── jin_sync2async.env=web.jam.js
    └── sync2async.ts
├── sync2middle
    ├── jin_sync2middle.env=node.jam.js
    └── sync2middle.ts
├── test
    ├── jin-method-tests.stage=dev.jam.js
    ├── jin-mixin-tests.stage=dev.jam.js
    ├── jin_test.doc.xml
    ├── jin_test.jam.js
    └── test.ts
├── test2
    ├── test.stage=dev.ts
    └── test.ts
├── thread
    ├── jin_thread.doc.xml
    ├── jin_thread.env=node.jam.js
    └── jin_thread.env=web.jam.js
├── throttle
    └── jin_throttle.jam.js
├── time
    ├── base
    │   └── base.ts
    ├── duration
    │   ├── duration.ts
    │   └── duration_tests.stage=dev.ts
    ├── moment
    │   ├── moment.ts
    │   └── moment_tests.stage=dev.ts
    ├── range
    │   ├── range.ts
    │   └── range_tests.stage=dev.ts
    └── readme.md
├── time1
    ├── format
    │   └── format.jam.js
    ├── moment
    │   ├── moment.jam.js
    │   ├── moment_patterns.jam.js
    │   └── moment_tests.stage=dev.jam.js
    ├── period
    │   ├── period.jam.js
    │   ├── period_patterns.jam.js
    │   └── period_tests.stage=dev.jam.js
    ├── range
    │   └── time-range.jam.js
    ├── time.jam.js
    └── time.ts
├── trade
    ├── jin-trade-legend-item.css
    ├── jin-trade-legend-item.jam.js
    ├── jin-trade-legend-item.sample.html
    ├── jin-trade.css
    ├── jin-trade.demo.html
    ├── jin-trade.jam.js
    └── jin-trade.sample.html
├── trait
    └── jin_trait.jam.js
├── tree
    ├── jin_tree.jam.js
    └── tree.ts
├── tree2
    ├── tree.stage=dev.ts
    └── tree.ts
├── type
    ├── type.ts
    └── type_tests.test.ts
├── uri
    ├── jin-uri-query.jam.js
    ├── jin_uri.jam.js
    └── uri.ts
├── value
    ├── jin-value.jam.js
    └── value.ts
├── vary2string
    └── jin_vary2string.jam.js
├── vector
    ├── jin-vector_tests.stage=dev.jam.js
    └── jin_vector.jam.js
├── view
    ├── active.env=web.ts
    ├── model.ts
    └── sample.ts
├── view1
    └── jin_view.env=web.jam.js
├── when
    └── when.ts
└── wrapper
    └── jin_wrapper.jam.js


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | -*
3 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | This is free and unencumbered software released into the public domain.
 2 | 
 3 | Anyone is free to copy, modify, publish, use, compile, sell, or
 4 | distribute this software, either in source code form or as a compiled
 5 | binary, for any purpose, commercial or non-commercial, and by any
 6 | means.
 7 | 
 8 | In jurisdictions that recognize copyright laws, the author or authors
 9 | of this software dedicate any and all copyright interest in the
10 | software to the public domain. We make this dedication for the benefit
11 | of the public at large and to the detriment of our heirs and
12 | successors. We intend this dedication to be an overt act of
13 | relinquishment in perpetuity of all present and future rights to this
14 | software under copyright law.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 
24 | For more information, please refer to <http://unlicense.org>
25 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Stable modules
 2 | ========
 3 | 
 4 | [$jin.time](time/readme.md) - proper date/time/duration/range arithmetic
 5 | 
 6 | [$jin.method](method/jin-method.doc.md) - method definer (obsolete, use TS instead)
 7 | 
 8 | Building your package
 9 | =======
10 | 
11 | Instal builder
12 | 
13 | 	npm install pms
14 | 
15 | Create build-script "build.js" and put into:
16 | 
17 | ```js
18 | with( require( 'pms' ) ) // loads prebuilded builder (may be old version)
19 | $pms.application( function( ){
20 |     with( $jin.build( 'jin/build?env=node' ).jsIndexNode()[0].load() ){ // build and load $jin.build package
21 |     	$jin.build( 'jin/atom?env=web' ).jsCompiled() // builds $jin.atom standalone js-library
22 | 	
23 | 	// builds js for $foo.bar
24 |     	$jin.build( 'jin/slide?env=web' ).jsIndexWeb() // use jsCompiled instead
25 |     	$jin.build( 'jin/slide?env=web' ).jsCompiled() // supports TS and source maps
26 | 
27 | 	// builds css for $foo.bar
28 |     	$jin.build( 'jin/slide?env=web' ).cssIndex() // use cssCompiled instaed 
29 |     	$jin.build( 'jin/slide?env=web' ).cssCompiled() // supports Stylus and source maps
30 |     	
31 |     	//wait for file changes
32 |     	$jin.alert( 'Press any key to stop automatic rebuild' )
33 |     }
34 | })
35 | ```
36 | 
37 | Create your namespace(foo) and application(bar) directories:
38 | 
39 | 	/
40 | 		build.js
41 | 		jin/
42 | 			...
43 | 		foo/
44 | 			bar/
45 | 
46 | Put into foo/bar file "foo-bar.meta.tree":
47 | 
48 | 	include =jin/atom
49 | 	include =jin/view
50 | 
51 | Or(!) simple use its in JAM-file "foo-bar.jam.js":
52 | 
53 | ```js
54 | $jin.alert( 'Hello world' ) // Isomorphic alert
55 | ```
56 | 
57 | Then run building:
58 | 
59 | 	node --harmony build.js
60 | 
61 | That builds all needed js and css files. You can find them in "-mix" subdirectories.
62 | 


--------------------------------------------------------------------------------
/alert/jin-alert.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.alert = $jin.async2sync( function jin_alert( message, done ){
 2 | 	$jin.log.info( message )
 3 | 	
 4 | 	var rawMode = process.stdin.isRaw
 5 | 	process.stdin.setRawMode( true )
 6 | 	
 7 | 	process.stdin.resume()
 8 | 	process.stdin.once( 'data', function jin_alert_handle_press( data ){
 9 | 		
10 | 		process.stdin.pause()
11 | 		process.stdin.setRawMode( rawMode )
12 | 		
13 | 		done( null, data )
14 | 	} )
15 | } )
16 | 


--------------------------------------------------------------------------------
/alert/jin-alert.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Выдаёт сообщение пользователю и ждет от него подтверждения. В отличие от window.alert работает в различных окружениях.
 3 |  *
 4 |  * @name $jin.alert
 5 |  * @method alert
 6 |  * @param {string} message
 7 |  * @static
 8 |  * @member $jin
 9 |  */
10 | $jin.method({ '$jin.alert': function( message ){
11 | 	alert( message )
12 | }})
13 | 


--------------------------------------------------------------------------------
/alias/jin_alias.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.alias = function( ){ // arguments: resolveName*, name, aliasedName
 2 |     var resolveList = [].slice.call( arguments )
 3 |     var aliasedName = String( resolveList.pop() )
 4 |     var name = String( resolveList.pop() )
 5 |     
 6 |     var alias = function( ){
 7 |         return this[ alias.$jin_alias_name ].apply( this, arguments )
 8 |     }
 9 |     
10 |     alias.$jin_alias_name = aliasedName
11 |     
12 |     return $jin.method.apply( null, resolveList.concat([ name, alias ]) )
13 | }
14 | 


--------------------------------------------------------------------------------
/application/jin_application.env=node.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Запускает функцию в волокне. Если мы уже находимся в волокне, то просто запускает функцию.
 3 |  *
 4 |  * Используется как правило, для запуска приложения в волокне, чтобы внутри можно было свободно использовать псевдосинхронные функции,
 5 |  * которые приостанавливают волокно до завершения асинхронных операций.
 6 |  */
 7 | module $jin {
 8 |     export function application( app , done? ) {
 9 |         return $jin.sync2async( app ).call( null , done )
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/async2sync/async2sync.ts:
--------------------------------------------------------------------------------
1 | declare module $jin {
2 |     export function async2sync( handler )
3 | }


--------------------------------------------------------------------------------
/atom/flag/atom-flag.ts:
--------------------------------------------------------------------------------
 1 | module $jin.atom {
 2 |     
 3 |     export class flag extends $jin.atom.prop<boolean> {
 4 |         
 5 |         toggle( ) {
 6 |             this.set( !this.get() )
 7 |         }
 8 |         
 9 |     }
10 |     
11 | }


--------------------------------------------------------------------------------
/atom/get/get.ts:
--------------------------------------------------------------------------------
 1 | module $jin.atom {
 2 | 
 3 |     export function get( map ) {
 4 | 
 5 |         var res : any = []
 6 | 
 7 |         var wait = null
 8 |         for( var key in map ) {
 9 |             try {
10 |                 res[ key ] = map[ key ].get()
11 |             } catch( error ) {
12 |                 if( error instanceof $jin.atom.wait ) {
13 |                     wait = wait || error
14 |                 } else {
15 |                     throw error
16 |                 }
17 |             }
18 |         }
19 | 
20 |         if( wait ) throw wait
21 | 
22 |         return res
23 |     }
24 | 
25 | }


--------------------------------------------------------------------------------
/atom/list/atom-list.ts:
--------------------------------------------------------------------------------
 1 | module $jin.atom {
 2 |     
 3 |     export class list < ItemType , OwnerType extends $jin.object.iface > extends $jin.atom.prop < ItemType[] , OwnerType > {
 4 | 
 5 |         constructor( config ) {
 6 |             return <any>super( config )
 7 |         }
 8 | 
 9 |         merge( next : ItemType[] , prev : ItemType[] ) {
10 |             next = super.merge( next , prev )
11 |             
12 |             if( !next || !prev ) return next
13 |             if( next.length !== prev.length ) return next
14 |             
15 |             for( var i = 0 ; i < next.length ; ++i ) {
16 |                 if( next[ i ] !== prev[ i ] ) return next
17 |             }
18 |             
19 |             return prev
20 |         }
21 | 
22 |         notify( error? : Error , next? : ItemType[] , prev? : ItemType[] ) {
23 |             super.notify( error , next , prev )
24 |             if( prev ) {
25 |                 if( next ) {
26 |                     var dropped = prev.filter( item => next.indexOf( item ) === -1 )
27 |                 } else {
28 |                     var dropped = prev
29 |                 }
30 |                 dropped.forEach( item => {
31 |                     if( !item ) return
32 |                     if( item.owner === this ) return
33 |                     item['destroy']()
34 |                 } )
35 |             }
36 |         }
37 |         
38 |         append( values : ItemType[] ) {
39 |             var value = this.get()
40 |             value.push.apply( value, values )
41 |             this.notify( null , value )
42 |         }
43 | 
44 |         prepend( values : ItemType[] ) {
45 |             var value = this.get()
46 |             value.unshift.apply( value, values )
47 |             this.notify( null , value )
48 |         }
49 | 
50 |         cut( from : number , to : number ) {
51 |             var value = this.get()
52 |             value.splice( from, to )
53 |             this.notify( null , value )
54 |         }
55 |         
56 |     }
57 |     
58 | }


--------------------------------------------------------------------------------
/atom/map/atom-map.ts:
--------------------------------------------------------------------------------
 1 | module $jin.atom {
 2 | 
 3 |     export interface hashMap < ValueType > {
 4 |         [ index : number ] : ValueType;
 5 |         [ index : string ] : ValueType;
 6 |     }
 7 | 
 8 |     export class map < ValueType , OwnerType extends $jin.object.iface >
 9 |     extends $jin.atom.prop < hashMap < ValueType > , OwnerType > {
10 |         
11 |         patch( patch : hashMap < ValueType > ) {
12 |             var next : hashMap < ValueType > = {}
13 |             var prev = this.get()
14 | 
15 |             if( prev ) {
16 |                 for (var key in prev) {
17 |                     if (!prev.hasOwnProperty(key)) continue
18 |                     next[key] = prev[key]
19 |                 }
20 |             }
21 | 
22 |             for( var key in patch ) {
23 |                 if( !patch.hasOwnProperty( key ) ) continue
24 |                 next[ key ] = patch[ key ]
25 |             }
26 | 
27 |             this.set( next )
28 | 
29 |             return this.owner
30 |         }
31 | 
32 |         itemSet( key : string , value : ValueType ) {
33 |             var patch : hashMap < ValueType > = {}
34 |             patch[ key ] = value
35 |             this.patch( patch )
36 |         }
37 | 
38 |     }
39 |     
40 | }


--------------------------------------------------------------------------------
/atom/numb/numb.ts:
--------------------------------------------------------------------------------
 1 | module $jin.atom {
 2 |     
 3 |     export class numb extends $jin.atom.prop < number > {
 4 |         
 5 |         summ( value ) {
 6 |             this.set( this.get() + value )
 7 |         }
 8 | 
 9 |         multiply( value ) {
10 |             this.set( this.get() * value )
11 |         }
12 | 
13 |     }
14 |     
15 | }


--------------------------------------------------------------------------------
/atom/prop/prop.stage=dev.ts:
--------------------------------------------------------------------------------
 1 | module $jin.prop.test {
 2 | 
 3 |     $jin.test( test => {
 4 |         var atom1 = new $jin.atom.prop<number,any>({
 5 |             pull : prev => 0
 6 |         })
 7 |         var atom2 = new $jin.atom.prop<number,any>({
 8 |             pull : prev => atom1.get() + 111
 9 |         })
10 |         var atom3 = new $jin.atom.prop<number,any>({
11 |             pull : prev => atom2.get() + 333
12 |         })
13 | 
14 |         test.equal( atom3.get(), 444 )
15 |         test.equal( atom2.get(), 111 )
16 | 
17 |         atom1.push( 666 )
18 |         test.equal( atom3.get(), 444 )
19 |         test.equal( atom2.get(), 777 )
20 |         test.equal( atom3.get(), 1110 )
21 |     } )
22 | 
23 |     class AtomTriplet extends $jin.object<any> {
24 |         get value1( ) {
25 |             return new $jin.atom.prop<number,AtomTriplet>( {
26 |                 owner : this,
27 |                 name : '_value1'
28 |             } )
29 |         }
30 |         get value2( ) {
31 |             return new $jin.atom.prop<number,AtomTriplet>( {
32 |                 owner : this,
33 |                 name : '_value2',
34 |                 pull : atom => this.value1.get() + 111
35 |             } )
36 |         }
37 |         get value3( ) {
38 |             return new $jin.atom.prop<number,AtomTriplet>( {
39 |                 owner : this,
40 |                 name : '_value3',
41 |                 pull : atom => this.value1.get() && this.value2.get()
42 |             } )
43 |         }
44 |     }
45 | 
46 |     $jin.test( test => {
47 |         var obj = new AtomTriplet({})
48 |         test.equal( obj.value1, obj.value1 )
49 |         test.unique( obj.value1, obj.value2 )
50 |         obj.value1.push( 666 )
51 |         test.equal( obj.value2.get(), 777 )
52 |     } )
53 | 
54 |     $jin.test( test => {
55 |         var log = []
56 | 
57 |         var source = new $jin.atom.prop<number,any>({})
58 | 
59 |         var target = source.then( value => {
60 |             log.push( 'then:' + value )
61 |             return value + 111
62 |         } )
63 | 
64 |         target.then( value => log.push( 'and:' + value ) )
65 | 
66 |         log.push( 'end' )
67 | 
68 |         setTimeout( () => {
69 |             test.equal( log.join( ';' ), 'end;then:666;and:777' )
70 |             test.done( true )
71 |         }, 0 )
72 | 
73 |         source.push( 666 )
74 | 
75 |         test.timeout( 100 )
76 | 
77 |     } )
78 | 
79 | }
80 | 


--------------------------------------------------------------------------------
/atom/status/status.ts:
--------------------------------------------------------------------------------
 1 | module $jin.atom {
 2 | 
 3 |     export class status extends $jin.enumeration {
 4 |         static clear = new status( 'clear' )
 5 |         static pull = new status( 'pull' )
 6 |         static actual = new status( 'actual' )
 7 |         static error = new status( 'error' )
 8 |         static destroyed = new status( 'destroyed' )
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/atom/str/str.ts:
--------------------------------------------------------------------------------
 1 | module $jin.atom {
 2 |     
 3 |     export class str extends $jin.atom.prop < string > {
 4 |         
 5 |         append( value ) {
 6 |             this.set( this.get() + value )
 7 |         }
 8 | 
 9 |         prepend( value ) {
10 |             this.set( value + this.get() )
11 |         }
12 | 
13 |         replace( regexp : RegExp , handler : ( ...found : string[] ) => string  ) {
14 |             this.set( this.get().replace( regexp , handler ) )
15 |         }
16 | 
17 |     }
18 |     
19 | }


--------------------------------------------------------------------------------
/atom/wait/wait.ts:
--------------------------------------------------------------------------------
 1 | module $jin.atom {
 2 | 
 3 |     export class wait {
 4 | 
 5 |         _nativeError : Error
 6 | 
 7 |         // prevent prints to console
 8 |         jin_log_isLogged = true
 9 | 
10 |         constructor( public message : string ) {
11 |             this._nativeError = new Error( message )
12 |         }
13 | 
14 |         toString() {
15 |             return String( this._nativeError )
16 |         }
17 | 
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/atom1/clearable/jin-atom-clearable.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.atom1.clearable#freeze
 3 |  * @method freeze
 4 |  * @member $jin.atom1.clearable
 5 |  */
 6 | $jin.method({ '$jin.atom1.clearable..freeze': function( ){
 7 | 	this._clear.call( this._owner )
 8 | 	
 9 | 	return this['$jin.atom1.pullable..freeze']()
10 | }})
11 | 


--------------------------------------------------------------------------------
/atom1/failable/jin-atom-failable.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.atom1.failable#fail
 3 |  * @method fail
 4 |  * @member $jin.atom1.failable
 5 |  */
 6 | $jin.method({ '$jin.atom1.failable..fail': function( error ){
 7 | 	this[ '$jin.atom1.variable..fail' ]( error )
 8 | 	
 9 | 	return $jin.atom1.bound( function( ){
10 | 		return this._fail.call( this._owner, error )
11 | 	}.bind(this) )
12 | }})
13 | 
14 | 


--------------------------------------------------------------------------------
/atom1/getable/jin-atom-getable.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.atom1.getable#get
 3 |  * @method get
 4 |  * @member $jin.atom1.getable
 5 |  */
 6 | $jin.method({ '$jin.atom1.getable..get': function( ){
 7 | 	var value = this['$jin.atom1.pullable..get']()
 8 | 	return this._get.call( this._owner, value )
 9 | }})
10 | 


--------------------------------------------------------------------------------
/atom1/logable/jin-atom-logable.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.atom1.logable#notify
 3 |  * @method notify
 4 |  * @member $jin.atom1.logable
 5 |  */
 6 | $jin.method({ '$jin.atom1.logable..notify': function( next, prev ){
 7 | 
 8 | 	$jin.atom1.logable.history().push([ this._name, '=', this._value/*, this*/ ])
 9 | 
10 | 	$jin.atom1.logable.deferLog()
11 | 
12 | 	return ( this[ '$jin.atom1.pushable..notify' ] || this[ '$jin.atom1.variable..notify' ] ).call( this, next, prev )
13 | }})
14 | 
15 | /**
16 |  * @name $jin.atom1.logable.history
17 |  * @method history
18 |  * @static
19 |  * @member $jin.atom1.logable
20 |  */
21 | $jin.property({ '$jin.atom1.logable.history': function( ){
22 | 	return []
23 | }})
24 | 
25 | /**
26 |  * @name $jin.atom1.logable.deferLog
27 |  * @method deferLog
28 |  * @member $jin.atom1.logable
29 |  * @static
30 |  */
31 | $jin.property({ '$jin.atom1.logable.deferLog': function( next  ){
32 | 	if( arguments.length ) return next
33 | 	
34 | 	return new $jin.schedule( 0, function defferedLogging( ){
35 | 		this.deferLog( void 0 )
36 | 		
37 | 		if( console.groupCollapsed ) console.groupCollapsed( '$jin.atom1.logable' )
38 | 		
39 | 		this.history().forEach( function jin_atom_defferedLog( row ){
40 | 			$jin.log.apply( $jin, row )
41 | 		} )
42 | 		this.history( [] )
43 | 		
44 | 		if( console.groupEnd ) console.groupEnd( '$jin.atom1.logable' )
45 | 		
46 | 	}.bind( this ) )
47 | }})
48 | 


--------------------------------------------------------------------------------
/atom1/mergable/jin-atom-mergable.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Записать новое значение (предварительно слив с текущим).
 3 |  *
 4 |  * @name $jin.atom1.mergable#put
 5 |  * @method put
 6 |  * @param {any} next
 7 |  * @member $jin.atom1.mergable
 8 |  */
 9 | $jin.method({ '$jin.atom1.mergable..put': function( next ){
10 | 	
11 | 	var prev = ( this._status === this.constructor.statusError ) ? null : this._value
12 | 	var next2 = this._merge.call( this._owner, next, prev )
13 | 	
14 | 	return this['$jin.atom1.variable..put']( next2 )
15 | }})
16 | 


--------------------------------------------------------------------------------
/atom1/pushable/jin-atom-pushable.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.atom1.pushable#notify
 3 |  * @method notify
 4 |  * @member $jin.atom1.pushable
 5 |  */
 6 | $jin.method({ '$jin.atom1.pushable..notify': function( next, prev ){
 7 | 	$jin.atom1.bound( function( ){
 8 | 		if( this._status === this.constructor.statusNull ) return
 9 | 		if( this._status === this.constructor.statusError ) return
10 | 		
11 | 		this._push.call( this._owner, next, prev )
12 | 	}.bind(this) )
13 | 
14 | 	return this[ '$jin.atom1.variable..notify' ]( next, prev )
15 | }})
16 | 
17 | 


--------------------------------------------------------------------------------
/atom1/pushable/jin-atom-pushable_test.stage=dev.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.test( function pushing( test ){
 2 | 	var x
 3 |     var y = $jin.atom1({
 4 | 		name: 'test',
 5 | 		pull: function(){
 6 | 			return 12
 7 | 		},
 8 | 		push: function( next, prev ){
 9 | 			x = next + '<-' + prev
10 | 		}
11 | 	})
12 | 	y.get()
13 | 	
14 | 	new $jin.defer( function( ){
15 | 	    test.equal( x, '12<-undefined' )
16 | 	} )
17 | } )
18 | 


--------------------------------------------------------------------------------
/atom1/variable/jin-atom-variable_test.stage=dev.jam.js:
--------------------------------------------------------------------------------
  1 | $jin.test( function mutating( test ){
  2 |     var x = $jin.atom1({
  3 | 		name: 'test',
  4 | 		value: 12
  5 | 	})
  6 | 	
  7 | 	x.mutate( function( prev ){
  8 | 		return prev + 30
  9 | 	} )
 10 | 	
 11 | 	test.equal( x.get(), 42 )
 12 | } )
 13 | 
 14 | $jin.test( function instant_resolve( test ){
 15 | 	test.timeout( 0 )
 16 |     
 17 | 	var x = $jin.atom1({
 18 | 		name: 'test',
 19 | 		value: 1
 20 | 	})
 21 | 	
 22 | 	x.then( function( value ){
 23 | 		test.equal( value, 1 ).done( true )
 24 | 	} )
 25 | } )
 26 | 
 27 | $jin.test( function instant_fail( test ){
 28 | 	test.timeout( 1 )
 29 |     
 30 | 	var error = new Error( 'test error' )
 31 | 	var x = $jin.atom1({
 32 | 		name: 'test',
 33 | 		error: error
 34 | 	})
 35 | 	
 36 | 	x['catch']( function( error2 ){
 37 | 		test.equal( error, error2 ).done( true )
 38 | 	} )
 39 | } )
 40 | 
 41 | $jin.test( function instant_then_fail( test ){
 42 | 	test.timeout( 1 )
 43 |     
 44 | 	var error = new Error( 'test error' )
 45 | 	var x = $jin.atom1({
 46 | 		name: 'test',
 47 | 		error: error
 48 | 	})
 49 | 	
 50 | 	x.then( function(){}, function( error2 ){
 51 | 		test.equal( error, error2 ).done( true )
 52 | 	} )
 53 | } )
 54 | 
 55 | $jin.test( function defer_resolve( test ){
 56 | 	test.timeout( 100 )
 57 |     
 58 | 	var x = $jin.atom1({
 59 | 		name: 'test'
 60 | 	})
 61 | 	
 62 | 	x.then( function( value ){
 63 | 		test.equal( value, 1 ).done( true )
 64 | 	} )
 65 | 	
 66 | 	new $jin.schedule( 0, function(){
 67 | 		x.put( 1 )
 68 | 	})
 69 | } )
 70 | 
 71 | $jin.test( function double_change( test ){
 72 | 	test.timeout( 100 )
 73 |     
 74 | 	var x = $jin.atom1({
 75 | 		name: 'test'
 76 | 	})
 77 | 	var done = false
 78 | 	
 79 | 	x.then( function( value ){
 80 | 		if( done ) test.fail()
 81 | 		done = true
 82 | 		x.put( 2 )
 83 | 		new $jin.defer( function(){
 84 | 			test.done( true )
 85 | 		} )
 86 | 	} )
 87 | 	
 88 | 	x.put( 1 )
 89 | } )
 90 | 
 91 | $jin.test( function pipeline( test ){
 92 | 	test.timeout( 100 )
 93 |     
 94 | 	var x = $jin.atom1({
 95 | 		name: 'test'
 96 | 	})
 97 | 	
 98 | 	x
 99 | 	.then( function( value ){
100 | 		return value + 1
101 | 	} )
102 | 	.then( function( value ){
103 | 		test.equal( value, 2 ).done( true )
104 | 	} )
105 | 	
106 | 	x.put( 1 )
107 | } )
108 | 
109 | $jin.test( function defer_fail( test ){
110 | 	test.timeout( 100 )
111 |     
112 | 	var error = new Error( 'test error' )
113 | 	$jin.log.error.ignore( error )
114 | 	
115 | 	var x = $jin.atom1({
116 | 		name: 'test'
117 | 	})
118 | 	
119 | 	x['catch']( function( error2 ){
120 | 		test.equal( error, error2 ).done( true )
121 | 	} )
122 | 	
123 | 	new $jin.schedule( 0, function(){
124 | 		x.fail( error )
125 | 	})
126 | } )
127 | 


--------------------------------------------------------------------------------
/audio/jin-audio.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.audio.input
 3 |  * @method input
 4 |  * @static
 5 |  * @member $jin.audio
 6 |  */
 7 | $jin.atom1.prop({ '$jin.audio.input': {
 8 | 	pull: function( ){
 9 | 		
10 | 		var constraint = { audio: true }
11 | 		
12 | 		var onDone = function( stream ){
13 | 			$jin.audio.input( stream )
14 | 		}
15 | 		
16 | 		var onError = function( error ){
17 | 			$jin.log.error( error )
18 | 		}
19 | 		
20 | 		var getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia
21 | 		
22 | 		getUserMedia.call( navigator, constraint, onDone, onError )
23 | 		
24 | 	}
25 | }})
26 | 
27 | /**
28 |  * @name $jin.audio.inputText
29 |  * @method inputText
30 |  * @static
31 |  * @member $jin.audio
32 |  */
33 | $jin.atom1.prop({ '$jin.audio.inputText': {
34 | 	pull: function( ){
35 | 		
36 | 		var SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition
37 | 		var recognition = new SpeechRecognition()
38 | 		
39 | 		recognition.continuous = true
40 | 		recognition.interimResults = true
41 | 		recognition.lang = 'ru'
42 | 		
43 | 		recognition.onresult = function( event ){
44 | 			var tokens = []
45 | 			for( var i = 0; i < event.results.length; ++i ){
46 | 				var result = event.results[ i ]
47 | 				tokens.push( result.item( 0 ).transcript )
48 | 			}
49 | 			$jin.audio.inputText( tokens )
50 | 		}
51 | 		
52 | 		recognition.onerror = function( event ){
53 | 			$jin.log( event )
54 | 		}
55 | 		
56 | 		recognition.onend = function( event ){
57 | 			recognition.start()
58 | 		}
59 | 		
60 | 		recognition.start()
61 | 		
62 | 		return []
63 | 	}
64 | }})
65 | 
66 | /**
67 |  * @name $jin.audio.output
68 |  * @method output
69 |  * @static
70 |  * @member $jin.audio
71 |  */
72 | $jin.atom1.prop({ '$jin.audio.output': {
73 | 	pull: function( ){
74 | 		return []
75 | 	},
76 | 	put: function( next, prev ){
77 | 		
78 | 		if( !prev ) prev = []
79 | 		
80 | 		var AudioContext = window.AudioContext || window.webkitAudioContext
81 | 		
82 | 		var context = new AudioContext
83 | 		var source = context.createMediaStreamSource( next )
84 | 		source.connect( context.destination )
85 | 		$jin.log( 'source', source )
86 | 		
87 | 		prev.push( next )
88 | 		
89 | 		$jin.audio.output_atom().notify()
90 | 		
91 | 		return prev
92 | 	}
93 | }})
94 | 


--------------------------------------------------------------------------------
/autoloader/jin_autoloader.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | this.$jin.autoloader=
 2 | $jin.proxy( { get: function( prefix, name ){
 3 |     var path= ( prefix || '' ) + name
 4 |     
 5 |     try {
 6 |         path= require.resolve( path )
 7 |     } catch( error ){
 8 |         if( error.code !== 'MODULE_NOT_FOUND' ) throw error
 9 |         if( path === 'npm' ) throw error
10 |         
11 |         if( name === 'constructor' ) return function(){ return function(){} }
12 |         
13 |         if( name === 'inspect' ) return function(){ return '$jin.autoloader( "' + prefix + '" )' }
14 |         
15 |         $jin.log.error( 'Module [' + path + '] not found')
16 |         $jin.log.info( 'npm install ' + path )
17 |         
18 |         var npm= $jin.autoloader('').npm
19 |         $jin.async2sync( npm.load ).call( npm, {} )
20 |         $jin.async2sync( npm.commands.install ).call( npm, [ path ] )
21 |     }
22 |     
23 |     return require( path )
24 | } } )
25 | 


--------------------------------------------------------------------------------
/ball/jin-ball.stage=dev.ts:
--------------------------------------------------------------------------------
 1 | module $jin.ball.test {
 2 | 
 3 |     var input = $jin.ball.parse(
 4 |         "# sample program\n" +
 5 |         "title < string =qwerty\n" +
 6 |         "false < bool =false\n" +
 7 |         "disabled-val < false\n" +
 8 |         "input\n" +
 9 |         "\t@ value concat\n" +
10 |         "\t\tstring =title\n" +
11 |         "\t\tstring =123456\n" +
12 |         "\t@ disabled disabled-val\n"
13 |     );
14 | 
15 |     console.log( input.rows().toString() );
16 |     console.log( $jin.ball.baseContext.rows().toString() );
17 |     console.log( input.execute( $jin.ball.baseContext ).rows().toString() );
18 | 
19 | }
20 | 


--------------------------------------------------------------------------------
/ball/jin-ball_input.tree:
--------------------------------------------------------------------------------
1 | > title string =qwerty
2 | > false bool =false
3 | > disabled-val false
4 | input
5 |  @ value concat
6 |   title
7 |   string =123456
8 |  @ disabled disabled-val
9 | 


--------------------------------------------------------------------------------
/bench/app/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | 	<head>
 4 | 		<title>jin bench</title>
 5 | 		<meta charset="utf-8" />
 6 | 		<style>
 7 | 			html, body {
 8 | 				width: 100%;
 9 | 				height: 100%;
10 | 				padding: 0;
11 | 				margin: 0;
12 | 				background: #eee;
13 | 				text-align: center;
14 | 			}
15 | 		</style>
16 | 		<link href="-mix/index.env=web.stage=dev.css" rel="stylesheet" />
17 | 	</head>
18 | 	<body>
19 | 		<script src="-mix/index.env=web.stage=dev.js"></script>
20 | 		<script>
21 | 			$jin.bench.app({ name: 'app=bench' }).element().parent( document.body )
22 | 		</script>
23 | 	</body>
24 | </html>


--------------------------------------------------------------------------------
/bench/app/jin-bench-app.css:
--------------------------------------------------------------------------------
 1 | @-webkit-keyframes jin-bench-app-show {
 2 | 	from {
 3 | 		-webkit-transform: scaleX( 0 );
 4 | 	}
 5 | 	to {
 6 | 		-webkit-transform: scaleX( 1 );
 7 | 	}
 8 | }
 9 | 
10 | @keyframes jin-bench-app-show {
11 | 	from {
12 | 		transform: scaleX( 0 );
13 | 	}
14 | 	to {
15 | 		transform: scaleX( 1 );
16 | 	}
17 | }
18 | 
19 | [jin-bench-app]{
20 | 	line-height: 1.5em;
21 | 	font-family: monospace;
22 | 	box-sizing: border-box;
23 | 	padding: 1%;
24 | 	display: inline-flex;
25 | 	flex-direction: column;
26 | 	text-align: left;
27 | 	min-width: 60em;
28 | }
29 | 
30 | [jin-bench-app] * {
31 | 	-webkit-animation: jin-bench-app-show .1s;
32 | 	animation: jin-bench-app-show .1s;
33 | }
34 | 
35 | [jin-bench-app-head] {
36 | 	margin: .5em;
37 | 	text-align: center;
38 | }
39 | 
40 | [jin-bench-app-setup] {
41 | 	white-space: pre;
42 | 	margin: .5em;
43 | 	line-height: 1.5em;
44 | 	font-family: monospace;
45 | }
46 | 
47 | [jin-bench-app-setup][jin-view2-focused="setup"] {
48 | 	outline: 1px solid steelblue;
49 | }
50 | 
51 | [jin-bench-app-tearDown] {
52 | 	white-space: pre;
53 | 	margin: .5em;
54 | 	line-height: 1.5em;
55 | 	font-family: monospace;
56 | }
57 | 
58 | [jin-bench-app-tearDown][jin-view2-focused="tearDown"] {
59 | 	outline: 1px solid steelblue;
60 | }
61 | 
62 | [jin-bench-app-cases]{
63 | 	display: flex;
64 | 	flex-direction: row-reverse;
65 | 	border-spacing: 1em 0;
66 | }
67 | 
68 | 


--------------------------------------------------------------------------------
/bench/app/jin-bench-app.sample.html:
--------------------------------------------------------------------------------
 1 | <div jin-bench-app="" id="{id}">
 2 | 	<div jin-bench-app-head="">
 3 | 		<div jin-bench-app-title="">
 4 | 			{titleEditor}
 5 | 		</div>
 6 | 		<button jin-bench-app-runner=""
 7 | 			jin-sample-events="
 8 | 				onclick=run
 9 | 			"
10 | 			>
11 | 			Bench!
12 | 		</button>
13 | 	</div>
14 | 	<div jin-bench-app-setup="">
15 | 		{setup}
16 | 	</div>
17 | 	<div jin-bench-app-cases="">
18 | 		{cases}
19 | 	</div>
20 | 	<div jin-bench-app-teardown="">
21 | 		{tearDown}
22 | 	</div>
23 | </div>
24 | 


--------------------------------------------------------------------------------
/bench/case/jin-bench-case.css:
--------------------------------------------------------------------------------
 1 | [jin-bench-case]{
 2 | 	display: flex;
 3 | 	flex-direction: column;
 4 | 	flex-align: stretch;
 5 | 	flex: 1;
 6 | }
 7 | 
 8 | [jin-bench-case-title]{
 9 | 	line-height: 1.5em;
10 | 	font-family: monospace;
11 | 	white-space: pre;
12 | 	margin: .5em;
13 | 	min-width: 10em;
14 | 	display: flex;
15 | }
16 | 
17 | [jin-bench-case-code]{
18 | 	line-height: 1.5em;
19 | 	font-family: monospace;
20 | 	white-space: pre;
21 | 	margin: .5em;
22 | 	min-width: 10em;
23 | 	flex: 1;
24 | 	display: flex;
25 | }
26 | 
27 | [jin-bench-case-measure] {
28 | 	padding: 0 .2em;
29 | 	margin: .5em;
30 | 	text-align: right;
31 | 	font-weight: bold;
32 | 	position: relative;
33 | 	background: #f6f6f6;
34 | 	z-index: 0;
35 | }
36 | 
37 | [jin-field-label][jin-view2-focused]:before,
38 | [jin-field-label]:hover:before {
39 | 	top: -2em;
40 | 	opacity: 1;
41 | }
42 | 


--------------------------------------------------------------------------------
/bench/case/jin-bench-case.sample.html:
--------------------------------------------------------------------------------
 1 | <div jin-bench-case="" id="{id}">
 2 | 	<div jin-bench-case-measure="compileOuter">
 3 | 		{measureCompileOuter}
 4 | 	</div>
 5 | 	<div jin-bench-case-measure="compileInner">
 6 | 		{measureCompileInner}
 7 | 	</div>
 8 | 	<div jin-bench-case-measure="executeOuter">
 9 | 		{measureExecuteOuter}
10 | 	</div>
11 | 	<div jin-bench-case-measure="executeInner">
12 | 		{measureExecuteInner}
13 | 	</div>
14 | 	<div jin-bench-case-title="">
15 | 		{title}
16 | 	</div>
17 | 	<div jin-bench-case-code="">
18 | 		{code}
19 | 	</div>
20 | </div>
21 | 


--------------------------------------------------------------------------------
/bench/header/jin-bench-header.css:
--------------------------------------------------------------------------------
 1 | [jin-bench-header] {
 2 | 	display: table-row;
 3 | }
 4 | 
 5 | [jin-bench-header-column] {
 6 | 	display: table-cell;
 7 | 	font-family: sans-serif;
 8 | 	color: #666;
 9 | }
10 | 


--------------------------------------------------------------------------------
/bench/jin-bench.demo.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | 	<head>
 4 | 
 5 | 	</head>
 6 | 	<body>
 7 | 		<script src="-mix/index.env=web.stage=dev.js"></script>
 8 | 		<script>
 9 | 			$jin.bench.log([ 'with({x:1}){###x = 2###}', 'with({x:1}){###x++###}', '###this.x###' ])
10 | 		</script>
11 | 	</body>
12 | </html>


--------------------------------------------------------------------------------
/build/jin-build.meta.tree:
--------------------------------------------------------------------------------
1 | include =jin/application
2 | include =jin/alert
3 | include =jin/param
4 | 


--------------------------------------------------------------------------------
/build/jin-build_auto.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.module( function(){ this[ '$jin.build' ] = {
 2 | 	
 3 | 	'.auto': [ $jin.atom1.prop, {
 4 | 		pull: function( ){
 5 | 			var vary = this.vary()
 6 | 			
 7 | 			var result = {}
 8 | 			
 9 | 			if( /|web/.test( vary.env ) ){
10 | 				var urn = $jin.uri( this.urn().json() ).query( 'env', 'web' ).query( 'stage', 'dev' )
11 | 				result.jsIndexWeb = $jin.build( urn + '' ).jsIndexWeb()
12 | 				result.cssIndex = $jin.build( urn ).cssIndex()
13 | 			}
14 | 			if( /|node/.test( vary.env ) ){
15 | 				var urn = $jin.uri( this.urn().json() ).query( 'env', 'node' ).query( 'stage', 'dev' )
16 | 				result.jsIndexNode = $jin.build( urn ).jsIndexNode()
17 | 			}
18 | 			if( /|release/.test( vary.stage ) ){
19 | 				var urn = $jin.uri( this.urn().json() ).query( 'env', 'web' ).query( 'stage', 'release' )
20 | 				result.jsCompiled = $jin.build( urn ).jsCompiled()
21 | 				result.cssCompiled = $jin.build( urn ).cssCompiled()
22 | 				
23 | 				var urn = $jin.uri( this.urn().json() ).query( 'env', 'node' ).query( 'stage', 'release' )
24 | 				result.jsCompiled = $jin.build( urn ).jsCompiled()
25 | 			}
26 | 			
27 | 			return result
28 | 		},
29 | 		merge: function( next, prev ){
30 | 			return ( String( next ) == String( prev ) ) ? prev : next
31 | 		}
32 | 	}]
33 | 	
34 | }})
35 | 


--------------------------------------------------------------------------------
/build/jin-build_cssCompiled.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.build#cssCompiled
 3 |  * @method cssCompiled
 4 |  * @member $jin.build
 5 |  */
 6 | $jin.atom1.prop.list({ '$jin.build..cssCompiled': {
 7 | 	pull: function( prev ){
 8 | 		var target = this.pack().buildFile( 'index', this.vary(), 'css' )
 9 | 		var targetMap = target.parent().resolve( target.name() + '.map' )
10 | 
11 | 		var root = null //$node.postcss.root({})
12 | 		this.cssSources().forEach( function( src ){
13 | 			var root2 = $node.postcss.parse( src.content() , { from : src.path() } )
14 | 			if( root ) root = root.append( root2 )
15 | 			else root = root2
16 | 		} )
17 | 
18 | 		var cssnext = $node.cssnext
19 | 		var processor = $node.postcss( cssnext().plugins )
20 | 		var result = processor.process( root , { to : target.relate() , map : { inline : false } } )
21 | 		target.content( result.css )
22 | 		targetMap.content( JSON.stringify( result.map , null , '\t' ) )
23 | 		
24 | 		$jin.log( target.relate() ) 
25 | 		
26 | 		return [ target , targetMap ]
27 | 	}
28 | }})
29 | 


--------------------------------------------------------------------------------
/build/jin-build_cssIndex.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.build#cssIndex
 3 |  * @method cssIndex
 4 |  * @member $jin.build
 5 |  */
 6 | $jin.atom1.prop.list({ '$jin.build..cssIndex': {
 7 | 	pull: function( prev ){
 8 | 		var pack = this.pack()
 9 | 		var vary = this.vary()
10 | 		
11 | 		var target = pack.buildFile( 'index', vary, 'css' )
12 | 		var targets = [ target ]
13 | 		
14 | 		var sources = this.cssSources()
15 | 		
16 | 		if( sources.length > 30  ){
17 | 			var lines = []
18 | 			
19 | 			var page = 0
20 | 			var pageLines = []
21 | 			
22 | 			function makePage( ){
23 | 				var pageFile= pack.buildFile( 'index.page=' + page, vary, 'css' )
24 | 				pageFile.content( pageLines.join( '\n' ) )
25 | 				targets.push( pageFile )
26 | 				lines.push( '@import url( "' + pageFile.uri( target.parent() ) + '" );' )
27 | 				++page
28 | 				pageLines = []
29 | 			}
30 | 			
31 | 			sources.forEach( function( src ){
32 | 				pageLines.push( '@import url( "' + src.uri( target.parent() ) + '" );' )
33 | 				if( pageLines.length > 30 ) makePage()
34 | 			})
35 | 			
36 | 			if( pageLines.length ) makePage()
37 | 			
38 | 		} else {
39 | 			var lines = sources.map( function( src ){
40 | 				return '@import url("' + src.uri( target.parent() ) + '");'
41 | 			} )
42 | 		}
43 | 		
44 | 		target.content( lines.join( '\n' ) )
45 | 		
46 | 		$jin.log( target.relate() )
47 | 		
48 | 		return targets
49 | 	}
50 | }})
51 | 


--------------------------------------------------------------------------------
/build/jin-build_jsCompiled.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.build#jsCompiled
 3 |  * @method jsCompiled
 4 |  * @member $jin.build
 5 |  */
 6 | $jin.atom1.prop({ '$jin.build..jsCompiled': {
 7 | 	pull: function( prev ){
 8 | 		
 9 | 		var target = this.pack().buildFile( 'index', this.vary(), 'js' )
10 | 		var targetMap = target.parent().resolve( target.name() + '.map' )
11 | 
12 | 		var concater = new $node[ 'concat-with-sourcemaps' ]( true, target.relate(), '\n;\n' )
13 | 		this.jsSources().forEach( function( src ){
14 | 			var srcMap = src.parent().resolve( src.name() + '.map' )
15 | 			var content = src.content().toString().replace( /^#\ssourceMappingURL=/g , '' )
16 | 			if( srcMap.exists() ) {
17 | 				var json = JSON.parse( srcMap.content() )
18 | 				json.sources = json.sources.map( function( source ){
19 | 					return src.parent().resolve( source ).relate( target.parent() )
20 | 				})
21 | 				concater.add( src.relate(), content, JSON.stringify( json ) )
22 | 			} else {
23 | 				concater.add( src.relate( target.parent() ), content )
24 | 			}
25 | 		} )
26 | 
27 | 		target.content( concater.content + '\n//# sourceMappingURL=' + targetMap.relate( target.parent() ) )
28 | 		targetMap.content( concater.sourceMap )
29 | 
30 | 		$jin.log( target.relate() )
31 | 		
32 | 		return [ target , targetMap ]
33 | 	},
34 | 	merge: function( next, prev ){
35 | 		return ( String( next ) == String( prev ) ) ? prev : next
36 | 	}
37 | }})
38 | 


--------------------------------------------------------------------------------
/build/jin-build_jsIndexNode.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.build#jsIndexNode
 3 |  * @method jsIndexNode
 4 |  * @member $jin.build
 5 |  */
 6 | $jin.atom1.prop.list({ '$jin.build..jsIndexNode': {
 7 | 	pull: function( prev ){
 8 | 		
 9 | 		var target = this.pack().buildFile( 'index', this.vary(), 'js' )
10 | 		
11 | 		var lines = this.jsSources().map( function( src ){
12 | 			return '("' + $jin.file( src ).relate( target.parent() ) + '")'
13 | 		} )
14 | 		
15 | 		lines.unshift( "\
16 | void function( path ){                                   \n\
17 |     path = require( 'path' ).resolve( __dirname, path )  \n\
18 |     var fs = require( 'fs' )                             \n\
19 |     var source= fs.readFileSync( path )                  \n\
20 |     source= 'with(this){' + source + '\\n}'              \n\
21 |     module._compile( source, path )                      \n\
22 |     return arguments.callee                              \n\
23 | }                                                        \n\
24 | 		" )
25 | 		
26 | 		target.content( lines.join( '\n' ) )
27 | 		
28 | 		$jin.log( target.relate() )
29 | 		
30 | 		return [ target ].concat( this.jsSources() )
31 | 	}
32 | }})
33 | 


--------------------------------------------------------------------------------
/cache/cache.ts:
--------------------------------------------------------------------------------
 1 | module $jin {
 2 | 
 3 |     export class cache {
 4 | 
 5 |         static prefix = '$jin.cache:'
 6 |         static name = '$jin.cache'
 7 |         static stripSize = 10
 8 | 
 9 |         static Storage() {
10 |             return new $jin.prop.vary<any,any>({
11 |                 owner : $jin.cache,
12 |                 name : 'storage',
13 |                 pull : prop => {
14 |                     try {
15 |                         localStorage[''] = null
16 |                         return window.localStorage
17 |                     } catch( error ) {
18 |                         return { clear : () => {
19 |                            prop.pull()
20 |                         } }
21 |                     }
22 |                 }
23 |             })
24 |         }
25 | 
26 |         static Item( param : string ) {
27 |             var key = this.prefix + param
28 |             return new $jin.prop.proxy<any>({
29 |                 pull : () => {
30 |                     try {
31 |                         var cache = this.Storage().get()[key]
32 |                         if (!cache) return null
33 |                         return JSON.parse(cache)
34 |                     } catch( error ) {
35 |                         $jin.log.error( error )
36 |                         return null
37 |                     }
38 |                 },
39 |                 put : next => {
40 |                     var value = JSON.stringify(next)
41 |                     var storage = this.Storage().get()
42 |                     for( var i = 0 ; i < this.stripSize ; ++i ) {
43 |                         try {
44 |                             storage[key] = value
45 |                             return
46 |                         } catch (error) {
47 |                             this.strip()
48 |                         }
49 |                     }
50 |                 }
51 |             })
52 |         }
53 | 
54 |         static strip() {
55 |             var storage = this.Storage().get()
56 |             var keys = Object.keys( storage )
57 |             var cacheKeys = keys.filter( key => !key.indexOf( this.prefix ) )
58 |             var stripKeys = cacheKeys.sort( () => Math.random() - .5 ).slice( 0, cacheKeys.length / this.stripSize )
59 |             stripKeys.forEach( key => {
60 |                 delete storage[ key ]
61 |             } )
62 |         }
63 | 
64 |     }
65 | 
66 | }


--------------------------------------------------------------------------------
/chat/jin-chat.demo.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <head>
 3 | 	<meta charset="utf-8" />
 4 | 	
 5 | 	<link href="-mix/index.stage=dev.css" rel="stylesheet" />
 6 | 	
 7 | 	<style>
 8 | 		html, body {
 9 | 			padding: 0;
10 | 			margin: 0;
11 | 			width: 100%;
12 | 			height: 100%;
13 | 		}
14 | 		label {
15 | 			display: inline-block;
16 | 		}
17 | 	</style>
18 | 	
19 | </head>
20 | <body>
21 | 	
22 | 	<script src="-mix/index.env=web.stage=dev.js"></script>
23 | 	
24 | 	<script>
25 | 		$jin.chat.streamer()
26 | 		$jin.chat.logger()
27 | 	</script>
28 | 	
29 | </body>
30 | 


--------------------------------------------------------------------------------
/chat/jin-chat.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.chat.streamer
 3 |  * @method streamer
 4 |  * @static
 5 |  * @member $jin.chat
 6 |  */
 7 | $jin.atom1.prop({ '$jin.chat.streamer': {
 8 | 	pull: function(){
 9 | 		return $jin.audio.input()
10 | 	},
11 | 	push: function( next ){
12 | 		if( !next ) return
13 | 		$jin.audio.output( next )
14 | 	}
15 | }})
16 | 
17 | /**
18 |  * @name $jin.chat.logger
19 |  * @method logger
20 |  * @static
21 |  * @member $jin.chat
22 |  */
23 | $jin.atom1.prop({ '$jin.chat.logger': {
24 | 	pull: function(){
25 | 		return $jin.audio.inputText()
26 | 	},
27 | 	push: function( next ){
28 | 		if( !next ) return
29 | 		document.body.innerHTML = next.join( '<br/>' )
30 | 	}
31 | }})
32 | 


--------------------------------------------------------------------------------
/concater/jin-concater.ts:
--------------------------------------------------------------------------------
 1 | module $jin {
 2 | 	export function concater( funcs : ( string | { ( val? : any ) : string } )[] ) : ( val? : any ) => string {
 3 | 		switch( funcs.length ) {
 4 | 			case 0:
 5 | 				return value => value
 6 | 			case 1:
 7 | 				return <{ ( val? : any ) : string }>funcs[ 0 ]
 8 | 			default:
 9 | 				var mid = Math.ceil( funcs.length / 2 )
10 | 				var first = $jin.concater( funcs.slice( 0 , mid ) )
11 | 				var second = $jin.concater( funcs.slice( mid ) )
12 | 				return function( value ){
13 | 					return first( value ) + second( value )
14 | 				}
15 | 		}
16 | 	}
17 | }
18 | 


--------------------------------------------------------------------------------
/confirm/jin_confirm.env=node.jam.js:
--------------------------------------------------------------------------------
1 | this.$jin.confirm= $jin.async2sync( function( question, done ){
2 |     $node.promptly.confirm( question, done )
3 | } )
4 | 


--------------------------------------------------------------------------------
/cookie/jin-cookie.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.cookie
 3 |  * @method cookie
 4 |  * @member $jin
 5 |  * @static
 6 |  */
 7 | $jin.method({ '$jin.cookie': function( name, config ){
 8 | 	if( arguments.length > 1 ){
 9 | 		var query = {}
10 | 		query[ name ] = config.birthDay
11 | 		document.cookie = $jin.uri({ query : query }).toString().substring( 1 )
12 | 		return config.birthDay
13 | 	}
14 | 	var cookies = $jin.uri.parse( '?' + document.cookie.replace( /; /g, '&' ) ).query()
15 | 	if( arguments.length < 1 ) return cookies
16 | 	return cookies[ name ]
17 | }})
18 | 


--------------------------------------------------------------------------------
/coverage/jin_coverage.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.coverage
 3 |  * @method coverage
 4 |  * @static
 5 |  * @member $jin
 6 |  */
 7 | $jin.method({ '$jin.coverage': function( pack ){
 8 |     pack= $jin.pack( pack )
 9 |     from= pack.mod( '-mix' )
10 |     to= pack.mod( '-cov' )
11 |     
12 |     $jin.execute( 'jscoverage', [ '' + from, '' + to ] )
13 |     
14 |     return to
15 | }})
16 | 


--------------------------------------------------------------------------------
/crier/jin_crier.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.crier
 3 |  * @class $jin.crier
 4 |  * @returns $jin.crier
 5 |  * @mixins $jin.klass
 6 |  */
 7 | $jin.klass({ '$jin.crier': [] })
 8 | 
 9 | /**
10 |  * @name $jin.crier#listenerMap
11 |  * @method listenerMap
12 |  * @member $jin.crier
13 |  */
14 | $jin.property({ '$jin.crier..listenerMap': Object })
15 | 
16 | /**
17 |  * @name $jin.crier#listen
18 |  * @method listen
19 |  * @member $jin.crier
20 |  */
21 | $jin.method({ '$jin.crier..listen': function( eventName, handler ){
22 |     var map = this.listenerMap()
23 |     var handlerList = map[ eventName ] = map[ eventName ] || []
24 |     
25 |     if( !~handlerList.indexOf( handler ) ){
26 |         handlerList.push( handler )
27 |     }
28 |     
29 |     return $jin.listener().crier( this ).eventName( eventName ).handler( handler )
30 | }})
31 | 
32 | /**
33 |  * @name $jin.crier#forget
34 |  * @method forget
35 |  * @member $jin.crier
36 |  */
37 | $jin.method({ '$jin.crier..forget': function( eventName, handler ){
38 |     var map = this.listenerMap()
39 |     var handlerList = map[ eventName ] = map[ eventName ] || []
40 |     
41 |     var index = handlerList.indexOf( handler )
42 |     if( !index ) handlerList.splice( index, 1 )
43 |     
44 |     return this
45 | }})
46 | 
47 | /**
48 |  * @name $jin.crier#scream
49 |  * @method scream
50 |  * @member $jin.crier
51 |  */
52 | $jin.method({ '$jin.crier..scream': function( event ){
53 |     var map = this.listenerMap()
54 |     var eventName = event.type()
55 |     
56 |     var handlerList = map[ eventName ]
57 |     if( !handlerList ) return this
58 |     
59 |     if( !event.target() ) event.target( this )
60 |     
61 |     handlerList.forEach( function( handler ){
62 |         handler( event )
63 |     })
64 |     
65 |     return this
66 | }})
67 | 


--------------------------------------------------------------------------------
/crier/jin_crier.env=node.stage=dev.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.test( function( test ){
 2 |     test.timeout(1)
 3 |     var crier = $jin.crier()
 4 |     crier.listen( 'xxx', handler )
 5 |     var event = $jin.event({ type: 'xxx' })
 6 |     crier.scream( event )
 7 |     function handler( e ){
 8 |         test.equal( e, event )
 9 |         test.done( true )
10 |     }
11 | } )
12 | 
13 | $jin.test( function( test ){
14 |     var crier = $jin.crier()
15 |     crier.listen( 'xxx', handler )
16 |     crier.forget( 'xxx', handler )
17 |     var event = $jin.event({ type: 'xxx' })
18 |     crier.scream( event )
19 |     function handler( e ){
20 |         test.fail()
21 |     }
22 | } )
23 | 
24 | $jin.test( function( test ){
25 |     var crier = $jin.crier()
26 |     crier.listen( 'xxx', handler ).destroy()
27 |     var event = $jin.event({ type: 'xxx' })
28 |     crier.scream( event )
29 |     function handler( e ){
30 |         test.fail()
31 |     }
32 | } )
33 | 
34 | $jin.test( function( test ){
35 |     var crier = $jin.crier()
36 |     crier.listen( 'xxx', handler1 )
37 |     crier.listen( 'xxx', handler2 )
38 |     var event = $jin.event({ type: 'xxx' })
39 |     var result = ''
40 |     crier.scream( event )
41 |     function handler1( e ){
42 |         result += 'foo'
43 |     }
44 |     function handler2( e ){
45 |         result += 'bar'
46 |     }
47 |     test.equal( result, 'foobar' )
48 | } )
49 | 


--------------------------------------------------------------------------------
/crypt/crypt.env=node.ts:
--------------------------------------------------------------------------------
 1 | module $jin.crypt {
 2 | 
 3 |     export function hash( value : string ) {
 4 |         var hash = $node.crypto.createHash( 'sha256' )
 5 |         hash.update( value )
 6 |         return $node.base32.encode( hash.digest() )
 7 |     }
 8 | 
 9 |     export function key( ) {
10 |         return $node.base32.encode( $node.crypto.randomBytes( 32 ) )
11 |     }
12 | 
13 | }


--------------------------------------------------------------------------------
/date/today/jin-date-today.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.date.today
 3 |  * @method today
 4 |  * @static
 5 |  */
 6 | $jin.atom1.prop({ '$jin.date.today':
 7 | {	put: function( val ){
 8 | 		if( val instanceof Date ) return val
 9 | 
10 | 		return new Date( val )
11 | 	},
12 | 	pull: function( ){
13 | 		var now = new Date
14 | 
15 | 		var nowMS = ( ( ( now.getHours() * 60 ) + now.getMinutes() ) * 60 + now.getSeconds() ) * 1000
16 | 		var dailyMS = 24 * 60 * 60 * 1000
17 | 		var delay = dailyMS - nowMS
18 | 
19 | 		new $jin.schedule( delay, function( ){
20 | 			$jin.date.today_atom().pull()
21 | 		} )
22 | 
23 | 		return now
24 | 	}
25 | 
26 | }})
27 | 


--------------------------------------------------------------------------------
/debuild/debuild.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.klass({ '$jin.debuild' : [] })
 2 | 
 3 | $jin.atom1.prop({ '$jin.debuild..vary' : {
 4 |     pull : function(){
 5 |         var vary = Object.create( $jin.param.hash() )
 6 |         vary.env = 'web'
 7 |         return vary
 8 |     }
 9 | }})
10 | 
11 | $jin.method({ '$jin.debuild..request' : function( request ){
12 |     var uri = $jin.uri.parse( request.url )
13 |     var target = $jin.file( '.' + uri.path() )
14 | 
15 |     if( /\.js$/.test( target.name() ) ){
16 |         this.js( target.relate() )
17 |     }
18 | 
19 |     if( /\.css$/.test( target.name() ) ){
20 |         this.css( target.relate() )
21 |     }
22 | 
23 | }})
24 | 
25 | $jin.atom1.prop.hash({ '$jin.debuild..js' : {
26 |     pull : function( path ) {
27 |         
28 |         var target = $jin.file( path )
29 |         var targetMap = target.parent().resolve( target.name() + '.map' )
30 |     
31 |         var pack = target.parent().parent()
32 | 
33 |         var vary = Object.create( this.vary() )
34 |         target.name().split( '.' ).forEach( function( chunk ) {
35 |             var names = chunk.split( '=' )
36 |             if( names.length < 2 ) return
37 |             vary[ names[0] ] = names[1]
38 |         })
39 | 
40 |         var build = $jin.build( $jin.uri({ path: pack.relate() , query: vary }) )
41 | 
42 |         return build.jsCompiled()[0].version()
43 |     }
44 | }})
45 | 
46 | $jin.atom1.prop.hash({ '$jin.debuild..css' : {
47 |     pull : function( path ) {
48 | 
49 |         var target = $jin.file( path )
50 |         var targetMap = target.parent().resolve( target.name() + '.map' )
51 | 
52 |         var pack = target.parent().parent()
53 |         var build = $jin.build( $jin.uri({ path : pack.relate(), query : this.vary() }) )
54 | 
55 |         return build.cssCompiled()[0].version()
56 |     }
57 | }})
58 | 
59 | $jin.server.resources( 'jin/debuild', $jin.debuild() )


--------------------------------------------------------------------------------
/defer/defer.ts:
--------------------------------------------------------------------------------
 1 | module $jin {
 2 |     export class defer {
 3 |         
 4 |         static _queue : $jin.defer[] = []
 5 |         static _schedule : $jin.schedule
 6 |         
 7 |         static schedule( ) {
 8 |             if( this._schedule ) return
 9 |             if( !this._queue.length ) return
10 |             
11 |             this._schedule = new $jin.schedule( 0, $jin.defer.run )
12 |         }
13 |         
14 |         static start( defer : $jin.defer ) {
15 |             this._queue.push( defer )
16 |             this.schedule()
17 |         }
18 |         
19 |         static stop( defer : $jin.defer ) {
20 |             var index = this._queue.indexOf( defer )
21 |             if( index >=0 ) this._queue.splice( index , 1 )
22 |         }
23 |         
24 |         static callback( func ) {
25 |             return function() {
26 |                 var result = func.apply( this, arguments )
27 |                 $jin.defer.run()
28 |                 return result
29 |             }
30 |         }
31 | 
32 |         static run() {
33 |             $jin.defer._schedule = undefined
34 |             $jin.defer.schedule()
35 |             var defer
36 |             while( defer = $jin.defer._queue.shift() ) {
37 |                 defer.run()
38 |             }
39 |         }
40 |         
41 |         _handler : () => void
42 |         
43 |         constructor( handler : () => void ) {
44 |             this._handler = handler
45 |             $jin.defer.start( this )
46 |         }
47 |         
48 |         destroy() {
49 |             $jin.defer.stop( this )
50 |         }
51 |         
52 |         run() {
53 |             this._handler()
54 |         }
55 |         
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/defer/jin_defer_test.stage=dev.jam.js:
--------------------------------------------------------------------------------
1 | $jin.test( function deffering( test ){
2 |     test.timeout( 0 )
3 |     new $jin.defer(function(){
4 |         test.equal( x, 1 )
5 |         test.done( true )
6 |     })
7 |     var x = 1
8 | } )
9 | 


--------------------------------------------------------------------------------
/definer/jin-definer.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Создаёт функцию, используемую для создания других сущностей.
 3 |  *
 4 |  * Все сущности создаются единообразно, через так называемые дефайнеры, которые реализуют две сигнатуры:
 5 |  *
 6 |  *     function( path : string, config : any ) - в случае статического path лучше использовать вторую форму
 7 |  *
 8 |  *     function({ path : any }) - этот варинт добавляет $jin.definer
 9 |  *
10 |  * Преимущества такого способа объявления сущностей в сравнении с традиционным присвоением:
11 |  *
12 |  *  * Автоматически создаются промежуточные пространства имён.
13 |  *  * Каждая определенная в config функция имееет отображаемое являющееся полным путём к ней (очень удобно при отладке).
14 |  *  * Возможно отслеживание затирания одной сущности другой (избавляет от проблем со случайным затиранием).
15 |  *  * Возможно создание не одной сущности, а целого семейства.
16 |  *  * Возможна регистрация одной сущности в более чем одном месте.
17 |  *  * Каждое определение сущности не зависит от окружения и содержит полную информацию о ней (что, например, используется для генерации jsdoc/jsduck коментариев).
18 |  *  * Легко найти сущность, по имени простым поиском.
19 |  *
20 |  * Недостатки:
21 |  *
22 |  *  * Чтобы IDE и генераторы документации понимали такие определения необходимы развесистые jsdoc/jsduck коментарии.
23 |  *  * В каждом определении указывается полный путь к сущности.
24 |  *
25 |  * @param {string} path
26 |  * @param {function( path: string, config : object )} definer
27 |  */
28 | $jin.definer = function( path, definer ){
29 | 	
30 | 	var wrapper = function( defines, arg ){
31 | 		if( arguments.length > 1 ){
32 | 			if( defines == null ) return function( path ){
33 | 				return definer( path, arg )
34 | 			}
35 | 			return definer.apply( null, arguments )
36 | 		} else {
37 | 			if( typeof defines === 'function' ) defines = new defines
38 | 			for( var path in defines ){
39 | 				definer( path, defines[ path ] )
40 | 			}
41 | 		}
42 | 	}
43 | 	
44 | 	return $jin.glob( path, wrapper )
45 | }
46 | 
47 | $jin.definer( '$jin.definer', $jin.definer )
48 | 


--------------------------------------------------------------------------------
/demo.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | 	<head>
 4 | 		<title>jin</title>
 5 | 		<meta charset="utf-8" />
 6 | 		<style>
 7 | 			html, body {
 8 | 				width: 100%;
 9 | 				height: 100%;
10 | 				padding: 0;
11 | 				margin: 0;
12 | 				background: #eee;
13 | 				text-align: center;
14 | 			}
15 | 		</style>
16 | 		<link href="-mix/index.css?jin&debuild" rel="stylesheet" />
17 | 	</head>
18 | 	<body>
19 | 		<button id="test_ts">TS</button>
20 | 		<h1 id="output"></h1>
21 | 		
22 | 		<script src="-mix/index.js?jin&debuild"></script>
23 | 		<script>
24 | 			$jin.test.start()
25 | 		</script>
26 | 	</body>
27 | </html>
28 | 


--------------------------------------------------------------------------------
/dnd/jin_dnd.demo.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | 	<head>
 4 | 		<script src="../../jin/-mix/index.env=web.locale=.stage=dev.js"></script>
 5 | 		<style>
 6 | 			.drag-block {
 7 | 				border: 1px solid steelblue;
 8 | 				width: 10em;
 9 | 				height: 10em;
10 | 				background: white;
11 | 				padding: 2em;
12 | 			}
13 | 			.drag-point {
14 | 				border: 1px solid lightsteelblue;
15 | 				background: snow;
16 | 				padding: .5em;
17 | 				max-width: 10em;
18 | 			}
19 | 			.drop-block {
20 | 				border: 1px solid red;
21 | 				width: 10em;
22 | 				height: 10em;
23 | 				background: white;
24 | 				padding: 2em;
25 | 			}
26 | 		</style>
27 | 	</head>
28 | 	<body>
29 | 		<div id="drag-block" class="drag-block">
30 | 			<b id="drag-point" class="drag-point"><i>drag</i> me with parent</b>
31 | 		</div>
32 | 		<div id="drag-self" class="drag-point">drag me self</div>
33 | 		<div id="drag-hidden" class="drag-point">drag me hidden</div>
34 | 		<div id="drop-self" class="drop-block">drop to <b>me</b> <iframe></iframe></div>
35 | 		<script>
36 | 			
37 | 			$jin.dnd.onStart.listen( $jin.doc().findById( 'drag-point' ), function( event ){
38 | 				event.data({ a: 1 })
39 | 				event.view( $jin.doc().findById( 'drag-block' ) )
40 | 			} )
41 | 			
42 | 			$jin.dnd.onStart.listen( $jin.doc().findById( 'drag-self' ), function( event ){
43 | 				event.data({ b: 2 })
44 | 			} )
45 | 			
46 | 			$jin.dnd.onStart.listen( $jin.doc().findById( 'drag-hidden' ), function( event ){
47 | 				event.data({ c: 3 })
48 | 				event.view( null )
49 | 			} )
50 | 			
51 | 			
52 | 			$jin.dnd.onDrag.listen( $jin.doc().findById( 'drag-hidden' ), function( event ){
53 | 				console.dir(event.nativeEvent())
54 | 				//event.catched( true )
55 | 			} )
56 | 			
57 | 			$jin.dnd.onOver.listen( $jin.doc().findById( 'drop-self' ), function( event ){
58 | 				//console.dir(event.nativeEvent())
59 | 				event.catched( true )
60 | 			} )
61 | 			
62 | 			$jin.doc().findById( 'drop-self' ).listen( 'mousemove', function( event ){
63 | 				//console.dir(event.nativeEvent())
64 | 				//event.catched( true )
65 | 			} )
66 | 			
67 | 			$jin.dnd.onDrop.listen( $jin.doc().findById( 'drop-self' ), function( event ){
68 | 				console.log( 'eated', event.data() )
69 | 				event.catched( true )
70 | 			} )
71 | 			
72 | 		</script>
73 | 	</body>
74 | </html>
75 | 


--------------------------------------------------------------------------------
/dnd/jin_dnd_event.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dnd.event
 3 |  * @class $jin.dnd.event
 4 |  * @returns $jin.dnd.event
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.dnd.event': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dnd.event#view
12 |  * @method view
13 |  * @member $jin.dnd.event
14 |  */
15 | $jin.method({ '$jin.dnd.event..view': function( dom, x, y ){
16 | 
17 | 	dom = $jin.dom( dom || '<div></div>' )
18 | 	dom.parent( document.body )
19 | 	dom.nativeNode().style.position = 'absolute'
20 | 	dom.nativeNode().style.zIndex = '-1'
21 | 	
22 | 	var transfer = this.transfer()
23 | 	var node = dom.nativeNode()
24 | 	try {
25 | 		transfer.setDragImage( node, x, y )
26 | 	} catch( e ){ }
27 | 	
28 | 	new $jin.schedule( 0, function(){
29 | 		dom.parent( null )
30 | 	})
31 | 
32 | 	return this
33 | }})
34 | 
35 | /**
36 |  * @name $jin.dnd.event#effect
37 |  * @method effect
38 |  * @member $jin.dnd.event
39 |  */
40 | $jin.method({ '$jin.dnd.event..effect': function( effect ){
41 | 	if( !arguments.length ) return this.transfer().dropEffect
42 | 
43 | 	if( !/^(none|copy|move|link)$/.test( effect ) ){
44 | 		throw new Error( 'Wrong dnd effect (' + effect + ')' )
45 | 	}
46 | 
47 | 	this.transfer().dropEffect = effect
48 | }})
49 | 
50 | /**
51 |  * @name $jin.dnd.event#effectAllowed
52 |  * @method effectAllowed
53 |  * @member $jin.dnd.event
54 |  */
55 | $jin.method({ '$jin.dnd.event..effectAllowed': function( effectAllowed ){
56 | 	if( !arguments.length ) return this.transfer().effectAllowed
57 | 
58 | 	if( !/^(none|copy|move|link|copyMove|copyLink|linkMove|all)$/.test( effectAllowed ) ){
59 | 		throw new Error( 'Wrong dnd effectAllowed (' + effectAllowed + ')' )
60 | 	}
61 | 
62 | 	this.transfer().effectAllowed = effectAllowed
63 | }})
64 | 


--------------------------------------------------------------------------------
/dnd/jin_dnd_onDrag.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dnd.onDrag
 3 |  * @class $jin.dnd.onDrag
 4 |  * @returns $jin.dnd.onDrag
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dnd.event
 7 |  */
 8 | $jin.klass({ '$jin.dnd.onDrag': [ '$jin.dnd.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dnd.onDrag.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dnd.onDrag
15 |  */
16 | $jin.method({ '$jin.dnd.onDrag.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'drag'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dnd/jin_dnd_onDrop.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dnd.onDrop
 3 |  * @class $jin.dnd.onDrop
 4 |  * @returns $jin.dnd.onDrop
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dnd.event
 7 |  */
 8 | $jin.klass({ '$jin.dnd.onDrop': [ '$jin.dnd.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dnd.onDrop.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dnd.onDrop
15 |  */
16 | $jin.method({ '$jin.dnd.onDrop.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'drop'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dnd/jin_dnd_onEnd.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dnd.onEnd
 3 |  * @class $jin.dnd.onEnd
 4 |  * @returns $jin.dnd.onEnd
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dnd.event
 7 |  */
 8 | $jin.klass({ '$jin.dnd.onEnd': [ '$jin.dnd.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dnd.onEnd.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dnd.onEnd
15 |  */
16 | $jin.method({ '$jin.dnd.onEnd.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'dragend'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dnd/jin_dnd_onEnter.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dnd.onEnter
 3 |  * @class $jin.dnd.onEnter
 4 |  * @returns $jin.dnd.onEnter
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dnd.event
 7 |  */
 8 | $jin.klass({ '$jin.dnd.onEnter': [ '$jin.dnd.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dnd.onEnter.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dnd.onEnter
15 |  */
16 | $jin.method({ '$jin.dnd.onEnter.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'dragenter'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dnd/jin_dnd_onLeave.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dnd.onLeave
 3 |  * @class $jin.dnd.onLeave
 4 |  * @returns $jin.dnd.onLeave
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dnd.event
 7 |  */
 8 | $jin.klass({ '$jin.dnd.onLeave': [ '$jin.dnd.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dnd.onLeave.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dnd.onLeave
15 |  */
16 | $jin.method({ '$jin.dnd.onLeave.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'dragleave'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dnd/jin_dnd_onOver.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dnd.onOver
 3 |  * @class $jin.dnd.onOver
 4 |  * @returns $jin.dnd.onOver
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dnd.event
 7 |  */
 8 | $jin.klass({ '$jin.dnd.onOver': [ '$jin.dnd.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dnd.onOver.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dnd.onOver
15 |  */
16 | $jin.method({ '$jin.dnd.onOver.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'dragover'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dnd/jin_dnd_onStart.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dnd.onStart
 3 |  * @class $jin.dnd.onStart
 4 |  * @returns $jin.dnd.onStart
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dnd.event
 7 |  */
 8 | $jin.klass({ '$jin.dnd.onStart': [ '$jin.dnd.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dnd.onStart.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dnd.onStart
15 |  */
16 | $jin.method({ '$jin.dnd.onStart.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'dragstart'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.dnd.onStart.listen
23 |  * @method listen
24 |  * @static
25 |  * @member $jin.dnd.onStart
26 |  */
27 | $jin.method({ '$jin.dnd.onStart.listen': function( crier, handler ){
28 |     this['$jin.dom.event.listen']
29 | 	var crier = $jin.dom( crier )
30 | 	
31 | 	crier.nativeNode().draggable = true
32 | 	
33 |     var onStart = crier.listen( 'dragstart', function( event ){
34 | 		return handler( $jin.dnd.onStart( event ) )
35 | 	} )
36 | 	
37 |     var onSelectStart = crier.listen( 'selectstart', function( event ){
38 | 		event = $jin.dom.event( event )
39 | 		
40 | 		var node = event.target().nativeNode()
41 | 		if( !node.dragDrop ) return
42 | 		
43 | 		node.dragDrop()
44 | 		
45 | 		event.catched( true )
46 | 	} )
47 | 	
48 |     var onEnd = $jin.dnd.onEnd( crier, function( event ){
49 | 		event.data( null )
50 | 	} )
51 | 	
52 | 	return { destroy: function(){
53 | 		onStart.destroy()
54 | 		onSelectStart.destroy()
55 | 		onEnd.destroy()
56 | 		crier.nativeNode().draggable = false
57 | 	}}
58 | }})
59 | 


--------------------------------------------------------------------------------
/doc/jin_doc.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.doc
 3 |  * @class $jin.doc
 4 |  * @returns $jin.doc
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom
 7 |  */
 8 | $jin.klass({ '$jin.doc': [ '$jin.dom' ] })
 9 | 
10 | /**
11 |  * @name $jin.doc.exec
12 |  * @method exec
13 |  * @static
14 |  * @member $jin.doc
15 |  */
16 | $jin.method({ '$jin.doc.exec': function( node ){
17 | 	if( !arguments.length ) node = window.document
18 | 	
19 | 	var doc = node[ '$jin.doc' ]
20 | 	if( doc ) return doc
21 | 	
22 | 	return node[ '$jin.doc' ] = this['$jin.wrapper.exec']( node )
23 | }})
24 | 
25 | /**
26 |  * @name $jin.doc#findById
27 |  * @method findById
28 |  * @member $jin.doc
29 |  */
30 | $jin.method({ '$jin.doc..findById': function( id ){
31 | 	return $jin.dom( this.nativeNode().getElementById( id ) )
32 | }})
33 | 
34 | /**
35 |  * @name $jin.doc#selection
36 |  * @method selection
37 |  * @member $jin.doc
38 |  */
39 | $jin.method({ '$jin.doc..selection': function( ){
40 | 	var doc = this.nativeNode()
41 | 	return $jin.dom.selection( doc.defaultView ? doc.defaultView.getSelection() : doc.selection )
42 | }})
43 | 
44 | /**
45 |  * @name $jin.doc#sizeListener
46 |  * @method sizeListener
47 |  * @member $jin.doc
48 |  */
49 | $jin.property({ '$jin.doc..sizeListener': function( ){
50 | 	return this.entangle( $jin.dom.event.onResize.listen( window, function( ){
51 | 		this.size( void 0 )
52 | 	}.bind( this ) ) )
53 | } } )
54 | 
55 | /**
56 |  * @name $jin.doc#size
57 |  * @method size
58 |  * @member $jin.doc
59 |  */
60 | $jin.atom1.prop({ '$jin.doc..size': {
61 | 	resolves: [ '$jin.dom..size' ],
62 | 	pull: function( ){
63 | 		this.sizeListener()
64 | 		var root = document.documentElement
65 | 		return $jin.vector([ root.clientWidth, root.clientHeight ])
66 | 	}
67 | } } )
68 | 


--------------------------------------------------------------------------------
/docs/jin-docs.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.docs.registry
 3 |  * @method registry
 4 |  * @static
 5 |  * @member $jin.docs
 6 |  */
 7 | $jin.property.hash({ '$jin.docs.registry': {
 8 | 	pull: function( ){
 9 | 		return []
10 | 	}
11 | } })
12 | 
13 | /**
14 |  * @name $jin.docs.collect
15 |  * @method collect
16 |  * @static
17 |  * @member $jin.docs
18 |  */
19 | $jin.method({ '$jin.docs.collect': function( source ){
20 | 	if( !source ) return $jin.definer.sources.map( $jin.docs.collect )
21 | 	
22 | 	function makeNS( path ){
23 | 		while( path ){
24 | 			var infos = $jin.docs.registry( path )
25 | 			if( !infos.length ) infos.push( {} )
26 | 			path = path.replace( /\.?[^.]*$/, '' )
27 | 		}
28 | 	}
29 | 	
30 | 	String( source ).replace( /\/\*\*([\s\S]+?)\*\//g, function( str, comment ){
31 | 		comment = comment.replace( /^\s*\*\s*/gm, '' )
32 | 		
33 | 		var info = {}
34 | 		
35 | 		comment.replace( /@class ([.$\w]+)?/g, function( str, path ){
36 | 			if( path ){
37 | 				$jin.docs.registry( path ).push( info )
38 | 				makeNS( path )
39 | 			}
40 | 			info.isClass = true
41 | 		})
42 | 		
43 | 		comment.replace( /@name ([.#$\w]+)/g, function( str, path ){
44 | 			path = path.replace( /#/g, '..' )
45 | 			$jin.docs.registry( path ).push( info )
46 | 			makeNS( path )
47 | 		})
48 | 		
49 | 		comment.replace( /@extends ([.#$\w]+)/g, function( str, path ){
50 | 			path = path.replace( /#/g, '..' )
51 | 			$jin.docs.registry( path ).push( info )
52 | 		})
53 | 		
54 | 		comment.replace( /@param ([{}.|$\w]+)? ([\[\].#$\w]+)/g, function( str, type, name ){
55 | 			var param = {}
56 | 			
57 | 			if( name[0] === '[' ) param.isOptional = true
58 | 			param.name = name.replace( /[\[\]]/g, '' )
59 | 			param.types = type.replace( /[{}]/g, '' ).split( '|' )
60 | 			
61 | 			info.params = info.params || []
62 | 			info.params.push( param )
63 | 		})
64 | 		
65 | 		comment.replace( /@returns ([{}.|$\w]+)?/g, function( str, type ){
66 | 			info.returns = type.replace( /[{}]/g, '' ).split( '|' )
67 | 		})
68 | 		
69 | 		info.descr = comment.replace( /@\w+( .*?)?[\r\n]+/g, '' ).trim()
70 | 	})
71 | 	
72 | }})
73 | 
74 | /**
75 |  * @name $jin.docs.show
76 |  * @method show
77 |  * @static
78 |  * @member $jin.docs
79 |  */
80 | $jin.method({ '$jin.docs.show': function( ){
81 | 	$jin.docs.view.root( 'docs' ).element().parent( document.body )
82 | }})
83 | 


--------------------------------------------------------------------------------
/dom/dom.ts:
--------------------------------------------------------------------------------
1 | module $jin {
2 | 
3 |     export declare var dom : any
4 |     
5 | }


--------------------------------------------------------------------------------
/dom/event/jin_dom_event_onBlur.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dom.event.onBlur
 3 |  * @class $jin.dom.event.onBlur
 4 |  * @returns $jin.dom.event.onBlur
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.dom.event.onBlur': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dom.event.onBlur.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dom.event.onBlur
15 |  */
16 | $jin.method({ '$jin.dom.event.onBlur.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'blur'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dom/event/jin_dom_event_onChange.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dom.event.onChange
 3 |  * @class $jin.dom.event.onChange
 4 |  * @returns $jin.dom.event.onChange
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.dom.event.onChange': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dom.event.onChange.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dom.event.onChange
15 |  */
16 | $jin.method({ '$jin.dom.event.onChange.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'change'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dom/event/jin_dom_event_onClick.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dom.event.onClick
 3 |  * @class $jin.dom.event.onClick
 4 |  * @returns $jin.dom.event.onClick
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.dom.event.onClick': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dom.event.onClick.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dom.event.onClick
15 |  */
16 | $jin.method({ '$jin.dom.event.onClick.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'click'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dom/event/jin_dom_event_onDoubleClick.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dom.event.onDoubleClick
 3 |  * @class $jin.dom.event.onDoubleClick
 4 |  * @returns $jin.dom.event.onDoubleClick
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.dom.event.onDoubleClick': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dom.event.onDoubleClick.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dom.event.onDoubleClick
15 |  */
16 | $jin.method({ '$jin.dom.event.onDoubleClick.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'dblclick'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dom/event/jin_dom_event_onInput.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dom.event.onInput
 3 |  * @class $jin.dom.event.onInput
 4 |  * @returns $jin.dom.event.onInput
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.dom.event.onInput': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dom.event.onInput.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dom.event.onInput
15 |  */
16 | $jin.method({ '$jin.dom.event.onInput.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'input'
19 | }})
20 | 
21 | //$jin.method( '$jin.dom.event.listen', '$jin.dom.event.onInput_listen', function( crier, handler ){
22 | //	var crier = $jin.dom( crier )
23 | //	
24 | //	crier.editable( true )
25 | //	
26 | //	return this.$jin.dom.event.listen( crier, handler )
27 | //} )
28 | 


--------------------------------------------------------------------------------
/dom/event/jin_dom_event_onPress.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dom.event.onPress
 3 |  * @class $jin.dom.event.onPress
 4 |  * @returns $jin.dom.event.onPress
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.dom.event.onPress': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dom.event.onPress.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dom.event.onPress
15 |  */
16 | $jin.method({ '$jin.dom.event.onPress.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'keydown'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dom/event/jin_dom_event_onResize.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dom.event.onResize
 3 |  * @class $jin.dom.event.onResize
 4 |  * @returns $jin.dom.event.onResize
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.dom.event.onResize': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dom.event.onResize.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dom.event.onResize
15 |  */
16 | $jin.method({ '$jin.dom.event.onResize.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'resize'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dom/event/jin_dom_event_onScroll.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dom.event.onScroll
 3 |  * @class $jin.dom.event.onScroll
 4 |  * @returns $jin.dom.event.onScroll
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.dom.event.onScroll': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dom.event.onScroll.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dom.event.onScroll
15 |  */
16 | $jin.method({ '$jin.dom.event.onScroll.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'scroll'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dom/event/jin_dom_event_onWheel.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dom.event.onWheel
 3 |  * @class $jin.dom.event.onWheel
 4 |  * @returns $jin.dom.event.onWheel
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.dom.event.onWheel': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.dom.event.onWheel.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.dom.event.onWheel
15 |  */
16 | $jin.method({ '$jin.dom.event.onWheel.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'wheel'
19 | }})
20 | 


--------------------------------------------------------------------------------
/dom/jin-dom-test.env=web.stage=dev.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.test( function hasRange_including( test ){
 2 | 	var root = $jin.dom( '<div> </div>' ).parent( document.body )
 3 | 	var text = root.childList()[0]
 4 | 	
 5 | 	test.ok( root.rangeContent().hasRange( text.rangeContent() ) )
 6 | 	
 7 | 	root.parent( null )
 8 | } )
 9 | 
10 | $jin.test( function hasRange_excluding( test ){
11 | 	var one = $jin.dom( '<div></div>' ).parent( document.body )
12 | 	var two = $jin.dom( '<div></div>' ).parent( document.body )
13 | 	
14 | 	test.not( one.rangeAround().hasRange( two.rangeAround() ) )
15 | 	
16 | 	one.parent( null )
17 | 	two.parent( null )
18 | } )
19 | 
20 | $jin.test( function hasRange_equal( test ){
21 | 	var root = $jin.dom( '<div></div>' ).parent( document.body )
22 | 	
23 | 	test.ok( root.rangeAround().hasRange( root.rangeAround() ) )
24 | 	test.ok( root.rangeContent().hasRange( root.rangeContent() ) )
25 | 	
26 | 	root.parent( null )
27 | } )
28 | 


--------------------------------------------------------------------------------
/dom/jin_dom.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.mixin({ '$jin.dom': [ '$jin.dom.nodejs' ] })
 2 |     
 3 | /**
 4 |  * @name $jin.dom.nodejs.env
 5 |  * @method env
 6 |  * @static
 7 |  * @member $jin.dom.nodejs
 8 |  */
 9 | $jin.method({ '$jin.dom.nodejs.env': function( ){
10 |     this['$jin.dom.env']
11 |     return $node.xmldom
12 | }})
13 | 


--------------------------------------------------------------------------------
/dom/selection/jin-dom-selection.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.dom.selection
 3 |  * @class $jin.dom.selection
 4 |  * @returns $jin.dom.selection
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.wrapper
 7 |  */
 8 | $jin.klass({ '$jin.dom.selection': [ '$jin.wrapper' ] })
 9 | 
10 | /**
11 |  * @name $jin.dom.selection#raw
12 |  * @method raw
13 |  * @member $jin.dom.selection
14 |  */
15 | $jin.method({ '$jin.dom.selection..raw': function(){
16 | 	this['$jin.wrapper..raw']
17 | 	return this.nativeSelection.apply( this, arguments )
18 | }})
19 | 
20 | /**
21 |  * @name $jin.dom.selection#nativeSelection
22 |  * @method nativeSelection
23 |  * @member $jin.dom.selection
24 |  */
25 | $jin.property({ '$jin.dom.selection..nativeSelection': null })
26 | 
27 | /**
28 |  * @name $jin.dom.selection#clear
29 |  * @method clear
30 |  * @member $jin.dom.selection
31 |  */
32 | $jin.method({ '$jin.dom.selection..clear': function( ){
33 | 	var sel = this.nativeSelection()
34 | 	if( sel.removeAllRanges ) sel.removeAllRanges()
35 | 	else if( sel.clear ) sel.clear()
36 | 	else throw new Error( 'Unsupported selection type' )
37 | 	
38 | 	return this
39 | }})
40 | 
41 | /**
42 |  * @name $jin.dom.selection#range
43 |  * @method range
44 |  * @member $jin.dom.selection
45 |  */
46 | $jin.method({ '$jin.dom.selection..range': function( ){
47 | 	var sel = this.nativeSelection()
48 | 	if( sel.rangeCount ) return $jin.dom.range( sel.getRangeAt( 0 ).cloneRange() )
49 | 	if( document.createRange ) return $jin.dom.range( document.createRange() )
50 | 	if( sel.createRange ) return $jin.dom.range( sel.createRange() )
51 | 	throw new Error( 'Unsupported selection type' )
52 | }})
53 | 


--------------------------------------------------------------------------------
/dom2/listener/dom2.ts:
--------------------------------------------------------------------------------
 1 | module $jin.dom2 {
 2 | 
 3 |     export class listener extends $jin.object<any> {
 4 | 
 5 |         node : Element
 6 |         events : string[]
 7 |         handler : ( Event ) => void
 8 | 
 9 |         constructor( config : {
10 |             node : Element
11 |             events : string[]
12 |             handler : ( Event ) => void
13 |         }) {
14 |             super( config )
15 | 
16 |             this.node = config.node
17 |             this.events = config.events
18 |             this.handler  = config.handler
19 | 
20 |             this.listen()
21 |         }
22 | 
23 |         destroy() {
24 |             this.forget()
25 |             super.destroy()
26 |         }
27 | 
28 |         listen() {
29 |             this.events.forEach( event => {
30 |                 this.node.addEventListener( event , this.handler , true )
31 |             } )
32 |         }
33 | 
34 |         forget() {
35 |             this.events.forEach( event => {
36 |                 this.node.removeEventListener( event , this.handler , true )
37 |             } )
38 |         }
39 |     }
40 | 
41 | }
42 | 


--------------------------------------------------------------------------------
/dumb/dumb.ts:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nin-jin/mam_jin_0/f67779377d4a7d451b9e02229a18292e8f4231b6/dumb/dumb.ts


--------------------------------------------------------------------------------
/editor/jin-editor.css:
--------------------------------------------------------------------------------
 1 | [jin-editor]{
 2 | 	padding: .25em .5em;
 3 | 	flex: 1;
 4 | }
 5 | 
 6 | [jin-editor] p {
 7 | 	margin: 0;
 8 | }
 9 | 
10 | [jin-editor]:empty:after {
11 | 	display: block;
12 | 	content: attr( jin-editor-placeholder ) ' ';
13 | 	color: #999;
14 | }
15 | 
16 | [jin-editor]:focus{
17 | 	outline: none;
18 | }
19 | 


--------------------------------------------------------------------------------
/editor/jin-editor.sample.html:
--------------------------------------------------------------------------------
 1 | <div jin-editor="{render}" id="{id}"
 2 | 	jin-editor-name="{name}"
 3 | 	jin-sample-props="
 4 | 		contentEditable=isEditable
 5 | 	"
 6 |     jin-sample-events="
 7 | 		oninput=onInput
 8 | 		onkeypress=onKeyPress
 9 | 		-onkeyup=onInput
10 | 		-onmouseup=onInput
11 | 		-onchange=onInput
12 | 		-onDOMSubtreeModified=onInput
13 | 		onfocus=onFocus
14 | 		onblur=onBlur
15 |     "
16 | 	>
17 | </div>
18 | 


--------------------------------------------------------------------------------
/editor/jin-editor.sample.html.rej:
--------------------------------------------------------------------------------
 1 | --- jin-editor.sample.html
 2 | +++ jin-editor.sample.html
 3 | @@ -1,6 +1,6 @@
 4 | -<div jin-editor="" id="{id}"
 5 | +<div jin-editor="{render}" id="{id}"
 6 |  	jin-sample-props="
 7 |  		contentEditable=isEditable
 8 |  	"
 9 |      jin-sample-events="
10 |  		oninput=onInput
11 | 


--------------------------------------------------------------------------------
/ensure/number.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.ensure.number.range
 3 |  * @method range
 4 |  * @member $jin.ensure.number
 5 |  * @static
 6 |  */
 7 | $jin.method({ '$jin.ensure.number.range': function( min, max ){
 8 | 	if( min == null ) min = Number.NEGATIVE_INFINITY
 9 | 	if( max == null ) max = Number.POSITIVE_INFINITY
10 | 	return function( value ){
11 | 		if( !arguments.length ) return
12 | 		var norm = Number( value )
13 | 		if( norm >= min && norm <= max ) return norm
14 | 		throw new Error( 'Value must be in range (' + min + '..' + max + ') but given (' + value + ')' )
15 | 	}
16 | } })
17 | 


--------------------------------------------------------------------------------
/ensure/string.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.ensure.string.paddedLeft
 3 |  * @method paddedLeft
 4 |  * @member $jin.ensure.string
 5 |  * @static
 6 |  */
 7 | $jin.method({ '$jin.ensure.string.paddedLeft': function( count, letter ){
 8 | 	if( !letter ) letter = ' '
 9 | 	return function( value ){
10 | 		value = String( value )
11 | 		while( value.length < count ) value = letter + value
12 | 		return value
13 | 	}
14 | }})
15 | 
16 | /**
17 |  * @name $jin.ensure.string.lowerCase
18 |  * @method lowerCase
19 |  * @member $jin.ensure.string
20 |  * @static
21 |  */
22 | $jin.method({ '$jin.ensure.string.lowerCase': function( ){
23 | 	return function( str ){
24 | 		return String( str ).toLowerCase()
25 | 	}
26 | }})
27 | 


--------------------------------------------------------------------------------
/enumeration/enumeration.ts:
--------------------------------------------------------------------------------
 1 | module $jin {
 2 |     export class enumeration {
 3 |         
 4 |         constructor( private _name : string ) {
 5 |         }
 6 | 
 7 |         toString() {
 8 |             return this._name
 9 |         }
10 |         
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/env/jin_env.jam.js:
--------------------------------------------------------------------------------
1 | this.$jin.env = $jin.value( function(){ return this }() )
2 | 


--------------------------------------------------------------------------------
/error/error.ts:
--------------------------------------------------------------------------------
 1 | module $jin {
 2 | 
 3 |     export class error {
 4 | 
 5 |         private _nativeError
 6 | 
 7 |         constructor(
 8 |             public message : string ,
 9 |             public info? : { [ index : string ] : any }
10 |         ) {
11 |             this._nativeError = new Error( message )
12 |             console.assert( false , this.toString() )
13 |         }
14 | 
15 |         get stack() {
16 |             return this._nativeError.stack
17 |         }
18 | 
19 |         toString() {
20 |             return this.message + '\n' + JSON.stringify( this.info )
21 |         }
22 | 
23 |     }
24 | 
25 | }


--------------------------------------------------------------------------------
/event/jin_event.doc.xml:
--------------------------------------------------------------------------------
 1 | <?xml-stylesheet href="../-mix/doc.stage=dev.xsl" type="text/xsl"?>
 2 | <doc_root
 3 |     doc_title="$jin_event"
 4 |     >
 5 | 
 6 |     <p>Примесь, позволяющая классу выступать в качестве события. </p>
 7 |     <p>
 8 |         <script type="wc_test">
 9 |             test.ok( $jin_event )
10 |         </script>
11 |         <script type="wc_test">
12 |             $jin_event_test= $jin_class( function( onTest1, event ){
13 |                 $jin_event.scheme( onTest1 )
14 |                 onTest1.type= '$jin_event_test'
15 |                 onTest1.bubbles= true
16 |             } )
17 |             
18 |             test.ok( $jin_event_test )
19 |         </script>
20 |         <script type="wc_test">
21 |             var done= false
22 |             var listener= $jin_event_test.listen( document, function( event ){
23 |                 done= true
24 |             })
25 |             
26 |             $jin_event_test().scream( document )
27 |             
28 |             listener.destroy()
29 |             
30 |             test.ok( done )
31 |         </script>
32 |         <script type="wc_test">
33 |             var body= document.getElementsByTagName( 'body' )[ 0 ]
34 |             
35 |             var listener= $jin_event_test.listen( document, function( event ){
36 |                 test.ok( event.target(), body )
37 |             })
38 |             
39 |             $jin_event_test().scream( body )
40 |             
41 |             listener.destroy()
42 |         </script>
43 |     </p>
44 |     
45 | </doc_root>
46 | 


--------------------------------------------------------------------------------
/event/jin_event.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.event
 3 |  * @class $jin.event
 4 |  * @returns $jin.event
 5 |  * @mixins $jin.klass
 6 |  */
 7 | $jin.klass({ '$jin.event': [] })
 8 | 
 9 | /**
10 |  * @name $jin.event_type
11 |  * @method event_type
12 |  * @static
13 |  * @member $jin
14 |  */
15 | $jin.property({ '$jin.event_type': function( ){
16 |     return String( this )
17 | }})
18 | 
19 | /**
20 |  * @name $jin.event.listen
21 |  * @method listen
22 |  * @static
23 |  * @member $jin.event
24 |  */
25 | $jin.method({ '$jin.event.listen': function( crier, handler ){
26 | 	var ctor = this
27 | 	var wrapper = function( event ){
28 | 		return handler( ctor( event ) )
29 | 	}
30 |     return crier.listen( this.type(), wrapper )
31 | }})
32 | 
33 | 
34 | /**
35 |  * @name $jin.event#target
36 |  * @method target
37 |  * @member $jin.event
38 |  */
39 | $jin.property({ '$jin.event..target': null })
40 | /**
41 |  * @name $jin.event#catched
42 |  * @method catched
43 |  * @member $jin.event
44 |  */
45 | $jin.property({ '$jin.event..catched': Boolean })
46 |     
47 | /**
48 |  * @name $jin.event#type
49 |  * @method type
50 |  * @member $jin.event
51 |  */
52 | $jin.property({ '$jin.event..type': function( type ){
53 |     if( arguments.length ) return String( type )
54 |     return String( this.constructor )
55 | }})
56 | 
57 | /**
58 |  * @name $jin.event#scream
59 |  * @method scream
60 |  * @member $jin.event
61 |  */
62 | $jin.method({ '$jin.event..scream': function( crier ){
63 |     crier.scream( this )
64 |     return this
65 | }})
66 | 


--------------------------------------------------------------------------------
/eventProof/jin_eventProof.doc.xml:
--------------------------------------------------------------------------------
 1 | <?xml-stylesheet href="../-mix/doc.stage=dev.xsl" type="text/xsl"?>
 2 | <doc_root
 3 |     doc_title="$jin_eventProof"
 4 |     >
 5 | 
 6 |     <p>Примесь события кидающего исключени в качестве поведения по умолчанию. Используется, когда нужно гарантировать, что запущенное событие будет обработано.</p>
 7 |     <p>
 8 |         <script type="wc_test">
 9 |             test.ok( $jin_eventProof )
10 |         </script>
11 |         <script type="wc_test">
12 |             var onTest1= $jin_class( function( onTest1, event ){
13 |                 $jin_eventProof.scheme( onTest1 )
14 |                 onTest1.type= '$jin_event_test_1'
15 |             } )
16 |             
17 |             try {
18 |                 onTest1().scream( document )
19 |             } catch( error ){
20 |                 test.ok( error )
21 |             }
22 |         </script>
23 |         <script type="wc_test">
24 |             var onTest2= $jin_class( function( onTest2, event ){
25 |                 $jin_eventProof.scheme( onTest2 )
26 |                 onTest2.type= '$jin_event_test_2'
27 |             } )
28 |             
29 |             var listener= onTest2.listen( document, function( event ){
30 |                 event.catched( true )
31 |             })
32 |             
33 |             onTest2().scream( document )
34 |             
35 |             listener.destroy()
36 |             
37 |             test.ok()
38 |         </script>
39 |         <script type="wc_test">
40 |             var onTest3= $jin_class( function( onTest3, event ){
41 |                 $jin_eventProof.scheme( onTest3 )
42 |                 onTest3.type= '$jin_event_test_3'
43 |             } )
44 |             
45 |             var listener= onTest3.listen( document, function( event ){
46 |                 event.catched( true )
47 |             })
48 |             
49 |             listener.destroy()
50 |             
51 |             try {
52 |                 onTest3().scream( document )
53 |             } catch( error ){
54 |                 test.ok( error )
55 |             }
56 |         </script>
57 |     </p>
58 |     
59 | </doc_root>
60 | 


--------------------------------------------------------------------------------
/eventProof/jin_eventProof.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.eventProof
 3 |  * @class $jin.eventProof
 4 |  * @returns $jin.eventProof
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.event
 7 |  */
 8 | $jin.klass({ '$jin.eventProof': [ '$jin.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.eventProof#scream
12 |  * @method scream
13 |  * @member $jin.eventProof
14 |  */
15 | $jin.method({ '$jin.eventProof..scream': function( crier ){
16 |     this['$jin.event..scream']( crier )
17 |     
18 |     if( !this.catched() ){
19 |         throw new Error( '[' + this + '] is not catched' )
20 |     }
21 |     
22 |     return this
23 | }})
24 | 


--------------------------------------------------------------------------------
/execute/jin_execute.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | this.$jin.execute=
 2 | $jin.async2sync( function( command, args, done ){
 3 |     var proc= $node.child_process.spawn( command, args, { stdio: 'inherit' } )
 4 |     proc.on( 'exit', function( code ){
 5 |         if( !code || code == '0') {
 6 | 			done( code );
 7 | 			return;
 8 | 		}
 9 | 		
10 | 		command = command + ' ' + args.join( ' ' )
11 | 		if( command.length > 256 ) command = command.substring( 0, 256 ) + '...'
12 | 		
13 | 		throw new Error( 'Execution of [' + command + '] ends with code ' + code )
14 |     })
15 | } )
16 | 


--------------------------------------------------------------------------------
/fiberize/jin_fiberize.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | this.$jin.fiberize=
 2 | $jin.proxy( { get: function( base, name ){
 3 |     if( !$node.fibers.current )
 4 |         return base[ name ]
 5 |     
 6 |     if( name === 'valueOf' ) return function( ){ return base.valueOf() }
 7 |     if( name === 'inspect' ) return function( ){ return base.inspect() }
 8 |     
 9 |     var chunks= /^(.+?)(Sync|Async|Defer)$/.exec( name )
10 |     if( !chunks ) return base[ name ]
11 |     
12 |     name = chunks[ 1 ]
13 |     if( typeof base[ name ] !== 'function' ) return base[ name ]
14 |     
15 |     var mod = chunks[ 2 ]
16 |     
17 |     if( mod === 'Sync' ) return $jin.async2sync( base[ name ] )
18 |     if( mod === 'Defer' ) return $jin.async2defer( base[ name ] )
19 |     if( mod === 'Async' ) return $jin.sync2async( base[ name ] )
20 |     
21 |     throw new Error( 'Something wrong!' )
22 | } } )
23 | 


--------------------------------------------------------------------------------
/field/jin-field.css:
--------------------------------------------------------------------------------
 1 | [jin-field] {
 2 | 	display: flex;
 3 | 	flex: 1;
 4 | 	background: white;
 5 | 	outline: 1px solid rgba( 0, 0, 0, .1 );
 6 | 	text-align: left;
 7 | 	position: relative;
 8 | }
 9 | 
10 | [jin-field-label]:before {
11 | 	display: none;
12 | 	content: attr( jin-field-label );
13 | 	position: absolute;
14 | 	right: -1px;
15 | 	top: -1px;
16 | 	background: #eee;
17 | 	z-index: -1;
18 | 	/*font: 11px/1 sans-serif;*/
19 | 	border: 1px solid #ccc;
20 | 	padding: .1em .5em;
21 | 	opacity: 0.85;
22 | 	/*transition: top .1s .1s ease-in-out;*/
23 | 	border-radius: 2px 2px  0 0;
24 | 	white-space: nowrap;
25 | 	margin-top: -2px;
26 | }
27 | 
28 | [jin-field-label][jin-view2-focused]:before,
29 | [jin-field-label]:hover:before {
30 | 	top: -1.7em;
31 | 	opacity: 1;
32 | 	z-index: 1;
33 | 	display: block;
34 | }
35 | 
36 | [jin-field][jin-view2-focused] {
37 | 	outline: 1px solid steelblue;
38 | }
39 | 
40 | [jin-field][jin-view2-focused]:before {
41 | 	border: 1px solid steelblue;
42 | 	border-bottom: 1px solid #ccc;
43 | }
44 | 


--------------------------------------------------------------------------------
/field/jin-field.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.field
 3 |  * @class $jin.field
 4 |  * @mixins $jin.klass
 5 |  * @mixins $jin.view1
 6 |  * @returns $jin.field
 7 |  */
 8 | $jin.klass({ '$jin.field': [ '$jin.view1' ] })
 9 | 
10 | /**
11 |  * @name $jin.field#label
12 |  * @method label
13 |  * @member $jin.field
14 |  */
15 | $jin.atom1.prop({ '$jin.field..label': {} })
16 | 
17 | /**
18 |  * @name $jin.field#valueProp
19 |  * @method valueProp
20 |  * @member $jin.field
21 |  */
22 | $jin.atom1.prop({ '$jin.field..valueProp': {} })
23 | 
24 | /**
25 |  * @name $jin.field#editor
26 |  * @method editor
27 |  * @member $jin.field
28 |  */
29 | $jin.atom1.prop({ '$jin.field..editor': {
30 | 	pull: function( ){
31 | 		return [ this.child( 'editor', $jin.editor ).valueProp( this.valueProp() ) ]
32 | 	}
33 | }})
34 | 
35 | /**
36 |  * @name $jin.field#focus
37 |  * @method focus
38 |  * @member $jin.field
39 |  */
40 | $jin.method({ '$jin.field..focus': function( ){
41 | 	this.child( 'editor' ).focus()
42 | }})
43 | 
44 | 


--------------------------------------------------------------------------------
/field/jin-field.sample.html:
--------------------------------------------------------------------------------
1 | <div jin-field="{id}"
2 | 	jin-field-label="{label}"
3 | 	jin-view2-focused="{focused}"
4 | 	>
5 | 	{editor}
6 | </div>
7 | 


--------------------------------------------------------------------------------
/file/file.ts:
--------------------------------------------------------------------------------
1 | declare module $jin {
2 |     export var file : any
3 | }


--------------------------------------------------------------------------------
/file/jin-file-type-css.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.file.type.css
 3 |  * @class $jin.file.type.css
 4 |  * @returns $jin.file.type.css
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.file.type.text
 7 |  */
 8 | $jin.klass({ '$jin.file.type.css': [ '$jin.file.type.text' ] })
 9 | 
10 | /**
11 |  * @name $jin.file.type.css.ext
12 |  * @method ext
13 |  * @static
14 |  * @member $jin.file.type.css
15 |  */
16 | $jin.method({ '$jin.file.type.css.ext': function( ){
17 | 	this['$jin.file.type.text.ext']
18 | 	return '.css'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.file.type.css.mime
23 |  * @method mime
24 |  * @static
25 |  * @member $jin.file.type.css
26 |  */
27 | $jin.method({ '$jin.file.type.css.mime': function( ){
28 | 	this['$jin.file.type.text.mime']
29 | 	return 'text/css'
30 | }})
31 | 
32 | /**
33 |  * @name $jin.file.type.css#cssFiles
34 |  * @method cssFiles
35 |  * @member $jin.file.type.css
36 |  */
37 | $jin.atom1.prop({ '$jin.file.type.css..cssFiles': {
38 | 	resolves: [ '$jin.file.base..cssFiles' ],
39 | 	pull: function( ){
40 | 		return [ this ]
41 | 	}
42 | }})
43 | 
44 | $jin.atom1.prop({ '$jin.file.type.css..dependList': {
45 | 	resolves: [ '$jin.file.base..dependList' ],
46 | 	pull: function( ){
47 | 		var depends = {}
48 | 
49 | 		String( this.content() )
50 | 		.replace( /\/\*[\s\S]*?\*\//g, '' )
51 | 		.replace
52 | 		(   /(?:\[|\$|\.| _|--)([a-z][a-z0-9]+(?:[-_][a-z0-9]+)+)/ig
53 | 			,   function( str, path ){
54 | 				depends[ path.replace( /[._-]/g, '/' ) ] = 1
55 | 			}
56 | 		)
57 | 
58 | 		return depends
59 | 	}
60 | }})
61 | 


--------------------------------------------------------------------------------
/file/jin-file-type-demoTree.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.file.type.demoTree
 3 |  * @class $jin.file.type.demoTree
 4 |  * @returns $jin.file.type.demoTree
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.file.type.tree
 7 |  */
 8 | $jin.klass({ '$jin.file.type.demoTree': [ '$jin.file.type.tree' ] })
 9 | 
10 | /**
11 |  * @name $jin.file.type.demoTree.ext
12 |  * @method ext
13 |  * @static
14 |  * @member $jin.file.type.demoTree
15 |  */
16 | $jin.method({ '$jin.file.type.demoTree.ext': function( ){
17 | 	this['$jin.file.type.tree.ext']
18 | 	return '.demo.tree'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.file.type.demoTree#dependList
23 |  * @method dependList
24 |  * @member $jin.file.type.demoTree
25 |  */
26 | $jin.atom1.prop({ '$jin.file.type.demoTree..dependList': {
27 | 	resolves: [ '$jin.file.base..dependList' ],
28 | 	pull: function( ){
29 | 		var depends = {}
30 | 		
31 | 		String( this.content() )
32 | 		.replace
33 | 		(   /([a-z][a-z0-9]+(?:-[a-z0-9]+)+)/ig
34 | 		,   function( str, path ){
35 | 				depends[ path.replace( /[._-]/g, '/' ) ] = 0
36 | 			}
37 | 		)
38 | 		
39 | 		return depends
40 | 	}
41 | }})
42 | 
43 | /**
44 |  * @name $jin.file.type.demoTree#jsFiles
45 |  * @method jsFiles
46 |  * @member $jin.file.type.demoTree
47 |  */
48 | $jin.atom1.prop.list({ '$jin.file.type.demoTree..jsFiles': {
49 | 	resolves: [ '$jin.file.base..jsFiles' ],
50 | 	pull: function( prev ){
51 | 		var target = this.parent().buildFile( this.name(), {}, 'js' )
52 | 		
53 | 		var content = '$jin.sample.demo.strings( ' + JSON.stringify( String( this.content() ) ) + ' )'
54 | 		
55 | 		target.content( content )
56 | 		
57 | 		if( prev ) $jin.log( target.relate() )
58 | 		
59 | 		return [ target ]
60 | 	}
61 | }}) 
62 | 


--------------------------------------------------------------------------------
/file/jin-file-type-html.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.file.type.html
 3 |  * @class $jin.file.type.html
 4 |  * @returns $jin.file.type.html
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.file.type.text
 7 |  */
 8 | $jin.klass({ '$jin.file.type.html': [ '$jin.file.type.text' ] })
 9 | 
10 | /**
11 |  * @name $jin.file.type.html.ext
12 |  * @method ext
13 |  * @static
14 |  * @member $jin.file.type.html
15 |  */
16 | $jin.method({ '$jin.file.type.html.ext': function( ){
17 | 	this['$jin.file.type.text.ext']
18 | 	return '.html'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.file.type.html.mime
23 |  * @method mime
24 |  * @static
25 |  * @member $jin.file.type.html
26 |  */
27 | $jin.method({ '$jin.file.type.html.mime': function( ){
28 | 	this['$jin.file.type.text.mime']
29 | 	return 'text/html'
30 | }})
31 | 


--------------------------------------------------------------------------------
/file/jin-file-type-js.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.file.type.js
 3 |  * @class $jin.file.type.js
 4 |  * @returns $jin.file.type.js
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.file.type.text
 7 |  */
 8 | $jin.klass({ '$jin.file.type.js': [ '$jin.file.type.text' ] })
 9 | 
10 | /**
11 |  * @name $jin.file.type.js.ext
12 |  * @method ext
13 |  * @static
14 |  * @member $jin.file.type.js
15 |  */
16 | $jin.method({ '$jin.file.type.js.ext': function( ){
17 | 	this['$jin.file.type.text.ext']
18 | 	return '.js'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.file.type.js.mime
23 |  * @method mime
24 |  * @static
25 |  * @member $jin.file.type.js
26 |  */
27 | $jin.method({ '$jin.file.type.js.mime': function( ){
28 | 	this['$jin.file.type.text.mime']
29 | 	return 'text/javascript'
30 | }})
31 | 
32 | /**
33 |  * @name $jin.file.type.js#jsFiles
34 |  * @method jsFiles
35 |  * @member $jin.file.type.js
36 |  */
37 | $jin.atom1.prop({ '$jin.file.type.js..jsFiles': {
38 | 	resolves: [ '$jin.file.base..jsFiles' ],
39 | 	pull: function( ){
40 | 		return [ this ]
41 | 	}
42 | }})
43 | 


--------------------------------------------------------------------------------
/file/jin-file-type-metaTree.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.file.type.metaTree
 3 |  * @class $jin.file.type.metaTree
 4 |  * @returns $jin.file.type.metaTree
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.file.type.tree
 7 |  */
 8 | $jin.klass({ '$jin.file.type.metaTree': [ '$jin.file.type.tree' ] })
 9 | 
10 | /**
11 |  * @name $jin.file.type.metaTree.ext
12 |  * @method ext
13 |  * @static
14 |  * @member $jin.file.type.metaTree
15 |  */
16 | $jin.method({ '$jin.file.type.metaTree.ext': function( ){
17 | 	this['$jin.file.type.tree.ext']
18 | 	return '.meta.tree'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.file.type.metaTree#dependList
23 |  * @method dependList
24 |  * @member $jin.file.type.metaTree
25 |  */
26 | $jin.atom1.prop({ '$jin.file.type.metaTree..dependList': {
27 | 	resolves: [ '$jin.file.base..dependList' ],
28 | 	pull: function( ){
29 | 		var depends = {}
30 | 		
31 | 		var meta= $jin.tree.parse( this.content() )
32 | 		meta.select(' include / ').values().forEach( function( path ){
33 | 			depends[ path.trim() ] = 0
34 | 		} )
35 | 		
36 | 		return depends
37 | 	}
38 | }})
39 | 


--------------------------------------------------------------------------------
/file/jin-file-type-ngHtml.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.klass({ '$jin.file.type.ngHtml': [ '$jin.file.type.html' ] })
 2 | 
 3 | $jin.method({ '$jin.file.type.ngHtml.ext': function( ){
 4 | 	this['$jin.file.type.html.ext']
 5 | 	return '.ng.html'
 6 | }})
 7 | 
 8 | $jin.atom1.prop({ '$jin.file.type.ngHtml..dependList': {
 9 | 	resolves: [ '$jin.file.base..dependList' ],
10 | 	pull: function( ){
11 | 		var depends = {
12 | 			'ng' : true
13 | 		}
14 | 
15 | 		var content = String( this.content() )
16 | 
17 | 		content
18 | 		.replace
19 | 		(   /<([a-z][a-z0-9]+(?:[-_][a-z0-9]+)+)/ig
20 | 			,   function( str, path ){
21 | 				depends[ path.replace( /[._-]/g, '/' ) ] = 1
22 | 			}
23 | 		)
24 | 
25 | 		content
26 | 		.replace
27 | 		(   /[ \t\n]([a-z0-9]{2,}(?:[_-][a-z0-9]{2,})+)="/gi
28 | 			,   function( str, path ){
29 | 				depends[ path.replace( /[_-]/g, '/' ) ] = 1
30 | 			}
31 | 		)
32 | 
33 | 		return depends
34 | 	}
35 | }})
36 | 
37 | $jin.atom1.prop.list({ '$jin.file.type.ngHtml..jsFiles': {
38 | 	resolves: [ '$jin.file.base..jsFiles' ],
39 | 	pull: function( prev ){
40 | 		var target = this.parent().buildFile( this.name(), {}, 'js' )
41 | 		var template = String( this.content() )
42 | 		var id = this.parent().relate().replace( /\//g , '_' )
43 | 		var mod = id.split( '_' )[0]
44 | 
45 | 		var content =
46 | 			'angular.module("' + mod + '").run( function( $'+'templateCache ) {' +
47 | 				'$'+'templateCache.put("' + id + '", ' + JSON.stringify( template ) + ')' +
48 | 			'} )'
49 | 
50 | 		target.content( content )
51 | 		
52 | 		if( prev ) $jin.log( target.relate() )
53 | 		
54 | 		return [ target ]
55 | 	}
56 | }})
57 | 


--------------------------------------------------------------------------------
/file/jin-file-type-png.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.file.type.png
 3 |  * @class $jin.file.type.png
 4 |  * @returns $jin.file.type.png
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.file.base
 7 |  */
 8 | $jin.klass({ '$jin.file.type.png': [ '$jin.file.base' ] })
 9 | 
10 | /**
11 |  * @name $jin.file.type.png.ext
12 |  * @method ext
13 |  * @static
14 |  * @member $jin.file.type.png
15 |  */
16 | $jin.method({ '$jin.file.type.png.ext': function( ){
17 | 	this['$jin.file.base.ext']
18 | 	return '.png'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.file.type.png.mime
23 |  * @method mime
24 |  * @static
25 |  * @member $jin.file.type.png
26 |  */
27 | $jin.method({ '$jin.file.type.png.mime': function( ){
28 | 	this['$jin.file.base.mime']
29 | 	return 'image/png'
30 | }})
31 | 
32 | /**
33 |  * @name $jin.file.type.png#image
34 |  * @method image
35 |  * @member $jin.file.type.png
36 |  */
37 | $jin.atom1.prop({ '$jin.file.type.png..image': {
38 | 	pull: function( ){
39 | 		var png = new $node.pngjs.PNG
40 | 		var atom = this.image_atom()
41 | 		
42 | 		$node.fs.createReadStream( this.path() )
43 | 		.pipe( png )
44 | 		.on( 'parsed', function( ){
45 | 			atom.put( png )
46 | 		} )
47 | 		.on( 'error', function( error ){
48 | 			atom.fail( error )
49 | 		} )
50 | 		
51 | 		//throw $jin.atom1.wait( 'Loading image from file system...' )
52 | 	}
53 | }})
54 | 


--------------------------------------------------------------------------------
/file/jin-file-type-sampleHTML.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.file.type.sampleHTML
 3 |  * @class $jin.file.type.sampleHTML
 4 |  * @returns $jin.file.type.sampleHTML
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.file.type.html
 7 |  */
 8 | $jin.klass({ '$jin.file.type.sampleHTML': [ '$jin.file.type.html' ] })
 9 | 
10 | /**
11 |  * @name $jin.file.type.sampleHTML.ext
12 |  * @method ext
13 |  * @static
14 |  * @member $jin.file.type.sampleHTML
15 |  */
16 | $jin.method({ '$jin.file.type.sampleHTML.ext': function( ){
17 | 	this['$jin.file.type.html.ext']
18 | 	return '.sample.html'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.file.type.sampleHTML#dependList
23 |  * @method dependList
24 |  * @member $jin.file.type.sampleHTML
25 |  */
26 | $jin.atom1.prop.list({ '$jin.file.type.sampleHTML..dependList': {
27 | 	resolves: [ '$jin.file.base..dependList' ],
28 | 	pull: function( ){
29 | 		var depends = { 'jin/sample' : true }
30 | 		
31 | 		var content = String( this.content() )
32 | 		
33 | 		content
34 | 		.replace
35 | 		(   /<([a-z0-9]{2,}(?:[_-][a-z0-9]{2,})+)/gi
36 | 		,   function( str, path ){
37 | 				depends[ path.replace( /[_-]/g, '/' ) ] = 1
38 | 			}
39 | 		)
40 | 		
41 | 		content
42 | 		.replace
43 | 		(   /[ \t\n]([a-z0-9]{2,}(?:[_-][a-z0-9]{2,})+)="/gi
44 | 		,   function( str, path ){
45 | 				depends[ path.replace( /[_-]/g, '/' ) ] = 1
46 | 			}
47 | 		)
48 | 		
49 | 		return depends
50 | 	}
51 | }})
52 | 
53 | /**
54 |  * @name $jin.file.type.sampleHTML#jsFiles
55 |  * @method jsFiles
56 |  * @member $jin.file.type.sampleHTML
57 |  */
58 | $jin.atom1.prop.list({ '$jin.file.type.sampleHTML..jsFiles': {
59 | 	resolves: [ '$jin.file.base..jsFiles' ],
60 | 	pull: function( prev ){
61 | 		var target = this.parent().buildFile( this.name(), {}, 'js' )
62 | 		var content = '$jin.sample.strings( ' + JSON.stringify( String( this.content() ) ) + ' )'
63 | 		target.content( content )
64 | 		
65 | 		if( prev ) $jin.log( target.relate() )
66 | 		
67 | 		return [ target ]
68 | 	}
69 | }})
70 | 


--------------------------------------------------------------------------------
/file/jin-file-type-text.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.file.type.text
 3 |  * @class $jin.file.type.text
 4 |  * @returns $jin.file.type.text
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.file.base
 7 |  */
 8 | $jin.klass({ '$jin.file.type.text': [ '$jin.file.base' ] })
 9 | 
10 | /**
11 |  * @name $jin.file.type.text.ext
12 |  * @method ext
13 |  * @static
14 |  * @member $jin.file.type.text
15 |  */
16 | $jin.method({ '$jin.file.type.text.ext': function( ){
17 | 	this['$jin.file.base.ext']
18 | 	return '.txt'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.file.type.text.mime
23 |  * @method mime
24 |  * @static
25 |  * @member $jin.file.type.text
26 |  */
27 | $jin.method({ '$jin.file.type.text.mime': function( ){
28 | 	this['$jin.file.base.mime']
29 | 	return 'text/plain'
30 | }})
31 | 


--------------------------------------------------------------------------------
/file/jin-file-type-tree.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.file.type.tree
 3 |  * @class $jin.file.type.tree
 4 |  * @returns $jin.file.type.tree
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.file.type.text
 7 |  */
 8 | $jin.klass({ '$jin.file.type.tree': [ '$jin.file.type.text' ] })
 9 | 
10 | /**
11 |  * @name $jin.file.type.tree.ext
12 |  * @method ext
13 |  * @static
14 |  * @member $jin.file.type.tree
15 |  */
16 | $jin.method({ '$jin.file.type.tree.ext': function( ){
17 | 	this['$jin.file.type.text.ext']
18 | 	return '.tree'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.file.type.tree.mime
23 |  * @method mime
24 |  * @static
25 |  * @member $jin.file.type.tree
26 |  */
27 | $jin.method({ '$jin.file.type.tree.mime': function( ){
28 | 	this['$jin.file.type.text.mime']
29 | 	return 'text/x-jin-tree'
30 | }})
31 | 


--------------------------------------------------------------------------------
/file/jin-file-type-ts.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.file.type.ts
 3 |  * @class $jin.file.type.ts
 4 |  * @returns $jin.file.type.ts
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.file.type.text
 7 |  */
 8 | $jin.klass({ '$jin.file.type.ts': [ '$jin.file.type.text' ] })
 9 | 
10 | /**
11 |  * @name $jin.file.type.ts.ext
12 |  * @method ext
13 |  * @static
14 |  * @member $jin.file.type.ts
15 |  */
16 | $jin.method({ '$jin.file.type.ts.ext': function( ){
17 | 	this['$jin.file.type.text.ext']
18 | 	return '.ts'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.file.type.ts#dependList
23 |  * @method dependList
24 |  * @member $jin.file.type.ts
25 |  */
26 | $jin.atom1.prop.list({ '$jin.file.type.ts..dependList': {
27 | 	resolves: [ '$jin.file.base..dependList' ],
28 | 	pull: function( ){
29 | 		var depends = {}
30 | 		
31 | 		var lines = String( this.content()).replace( /\/\*[\s\S]*?\*\//g, '' ).split( '\n' )
32 | 
33 | 		lines.forEach( function( line ){
34 | 			line = line.replace( /\/\/.*/ , '' )
35 | 			var indent = /^((?:    )+|\t+)*/.exec( line )
36 | 			var priority = indent[0].length
37 | 			if( indent[0][0] === ' ' ) priority /= 4
38 | 			line.replace
39 | 			(   /\$([a-z][a-z0-9]+(?:[._][a-z0-9]+)*)/ig
40 | 				,   function( str, path ){
41 | 					var name = path.replace( /[._-]/g, '/' )
42 | 					if( typeof depends[ name ] === 'number' ) {
43 | 						depends[ name ] = Math.min( depends[ name ] , priority )
44 | 					} else {
45 | 						depends[ name ] = priority
46 | 					}
47 | 				}
48 | 			)
49 | 		})
50 | 
51 | 		return depends
52 | 	}
53 | }})
54 | 
55 | $jin.atom1.prop({ '$jin.file.type.ts..jsFiles': {
56 | 	resolves: [ '$jin.file.base..jsFiles' ],
57 | 	pull: function( ){
58 | 		return [ this ]
59 | 	}
60 | }})
61 | 


--------------------------------------------------------------------------------
/file/jin-file-type-viewTree.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.klass({ '$jin.file.type.viewTree': [ '$jin.file.type.tree' ] })
 2 | 
 3 | $jin.method({ '$jin.file.type.viewTree.ext': function( ){
 4 | 	this['$jin.file.type.tree.ext']
 5 | 	return '.view.tree'
 6 | }})
 7 | 
 8 | $jin.atom1.prop({ '$jin.file.type.viewTree..dependList': {
 9 | 	resolves: [ '$jin.file.base..dependList' ],
10 | 	pull: function( ){
11 | 		var depends = {
12 | 			//'jin2/prop' : 0,
13 | 		}
14 | 		
15 | 		String( this.content() )
16 | 		.replace
17 | 		(   /[@$]([a-z][a-z0-9]+(?:_[a-z0-9]+)+)/ig
18 | 		,   function( str, path ){
19 | 				depends[ path.replace( /[_]/g, '/' ) ] = 0
20 | 			}
21 | 		)
22 | 		
23 | 		return depends
24 | 	}
25 | }})
26 | 
27 | $jin.atom1.prop.list({ '$jin.file.type.viewTree..jsFiles': {
28 | 	resolves: [ '$jin.file.base..jsFiles' ],
29 | 	pull: function( prev ){
30 | 		var target = this.parent().buildFile( this.name(), {}, 'ts' )
31 | 		var tree = $jin_tree2.fromString( String( this.content() ) , this.relate() )
32 | 
33 | 		var content = $mol_viewer_tree2ts( tree )
34 | 
35 | 		target.content( content )
36 | 
37 | 		if( prev ) $jin.log( target.relate() )
38 | 
39 | 		return [ target ]
40 | 	}
41 | }}) 
42 | 


--------------------------------------------------------------------------------
/file/jin-file.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.file
 3 |  * @method file
 4 |  * @static
 5 |  * @member $jin
 6 |  */
 7 | $jin.method({ '$jin.file': function( path ){
 8 | 	if( typeof path !== 'string' ) return path
 9 | 	
10 | 	var bestType = $jin.file.base
11 | 	
12 | 	var types = bestType.descendantClasses()
13 | 	.filter( function( type ){
14 | 		return type.match( path )
15 | 	})
16 | 	
17 | 	bestType = types[ types.length - 1 ] || bestType
18 | 	
19 | 	return bestType( path )
20 | }})
21 | 


--------------------------------------------------------------------------------
/func/collector/collector.ts:
--------------------------------------------------------------------------------
 1 | module $jin.func {
 2 |     
 3 |     export function collector( ) {
 4 |         return function( next ){
 5 |             var res = []
 6 |             var val
 7 |             while( true ){
 8 |                 val = next()
 9 |                 if( val === void 0 ) break
10 |                 res.push( val )
11 |             }
12 |             return res
13 |         }
14 |     }
15 |     
16 | }
17 | 


--------------------------------------------------------------------------------
/func/filter/filter.ts:
--------------------------------------------------------------------------------
 1 | module $jin.func {
 2 |     
 3 |     export function filter ( check ){
 4 |         return function( next ) {
 5 |             return function( ) {
 6 |                 while( true ) {
 7 |                     var val = next()
 8 |                     if( val === void 0 ) return
 9 |                     if( check( val ) ) return val
10 |                 }
11 |             }
12 |         }
13 |     }
14 |     
15 | }
16 | 


--------------------------------------------------------------------------------
/func/iterator/iterator.ts:
--------------------------------------------------------------------------------
 1 | module $jin.func {
 2 | 
 3 |     export function iterator( ){
 4 |         return function( list ){
 5 |             var index = 0
 6 |             return function( ){
 7 |                 return list[ index++ ]
 8 |             }
 9 |         }
10 |     }
11 |     
12 | }
13 | 


--------------------------------------------------------------------------------
/func/jin_func.jam.js:
--------------------------------------------------------------------------------
1 | this.$jin.func = {}
2 | 


--------------------------------------------------------------------------------
/func/limiter/limiter.ts:
--------------------------------------------------------------------------------
 1 | module $jin.func {
 2 |     
 3 |     export function limiter ( count : number ){
 4 |         return function( next ) {
 5 |             var index = 0
 6 |             return function( ){
 7 |                 if( index++ < count ) return next()
 8 |             }
 9 |         }
10 |     }
11 |     
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/func/make/make.jam.js:
--------------------------------------------------------------------------------
1 | this.$jin.func.make = function( name ){
2 |     var func = function( ){
3 |         return func.execute( this, arguments )
4 |     }
5 |     return func
6 | }
7 | 


--------------------------------------------------------------------------------
/func/mapper/mapper.ts:
--------------------------------------------------------------------------------
 1 | module $jin.func {
 2 |     
 3 |     export function mapper ( transform ) {
 4 |         return function( next ) {
 5 |             return function( ){
 6 |                 var val = next()
 7 |                 if( val !== void 0 ) val = transform( val )
 8 |                 return val
 9 |             }
10 |         }
11 |     }
12 |     
13 | }
14 | 
15 | 


--------------------------------------------------------------------------------
/func/name/name.jam.js:
--------------------------------------------------------------------------------
1 | this.$jin.func.name = function( func, name ){
2 |     if( arguments.length > 1 ) return func.$jin_func_name = name
3 |     return func.name
4 |     || func.$jin_func_name
5 |     || func.toString().match( /^\s*function\s*([$\w]*)\s*\(/ )[ 1 ]
6 | }
7 | 


--------------------------------------------------------------------------------
/func/pipe/pipe.ts:
--------------------------------------------------------------------------------
1 | module $jin.func {
2 |     
3 |     export interface pipe < ValueType > {
4 |         ( val : ValueType ) : ValueType
5 |     }
6 |     
7 | }


--------------------------------------------------------------------------------
/func/pipeline/pipeline.ts:
--------------------------------------------------------------------------------
 1 | module $jin.func {
 2 |     
 3 |     export function pipeline ( procs ){
 4 |         return function( input ) {
 5 |             for( var i = 0 ; i < procs.length ; ++i ) {
 6 |                 input = procs[ i ]( input )
 7 |             }
 8 |             return input
 9 |         }
10 |     }
11 |     
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/func/usages/usages.jam.js:
--------------------------------------------------------------------------------
1 | this.$jin.func.usages = function( func ){
2 | 	if( func.jin_func_usages ) return func.jin_func_usages
3 | 	var found = {}
4 | 	Object.toString.call( func ).replace( /\$[a-z][a-z0-9]+(\.[a-z][a-z0-9]*)+/g, function( token ){
5 | 		found[ token ] = true
6 | 	})
7 | 	return func.jin_func_usages = Object.keys( found )
8 | }
9 | 


--------------------------------------------------------------------------------
/git-init.cmd:
--------------------------------------------------------------------------------
1 | git init && git config remote.origin.url https://github.com/nin-jin/pms-jin.git && git pull & git add .
2 | 


--------------------------------------------------------------------------------
/glob/jin_glob.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.glob = function $jin_glob( name, value ){
 2 |     var keyList = name.split( '.' )
 3 |     var current = $jin.root()
 4 |     var currentName = ''
 5 |     
 6 |     for( var i = 0; i < keyList.length - 1; ++i ){
 7 |         var key = keyList[i] || 'prototype'
 8 |         
 9 |         if(!( key in current )){
10 |             current[ key ] = $jin.trait.make( keyList.slice( 0, i + 1 ).join( '.' ) )
11 |         }
12 |         
13 |         current = current[ key ]
14 |     }
15 |     
16 |     var key = keyList[ keyList.length - 1 ] || 'prototype'
17 |     
18 |     if( arguments.length > 1 ){
19 |         current[ key ] = value
20 |     } else {
21 |         value = current[ key ]
22 |     }
23 |     
24 |     return value
25 | }
26 | 


--------------------------------------------------------------------------------
/handler/handler.ts:
--------------------------------------------------------------------------------
 1 | module $jin {
 2 |     
 3 |     export function handler < HandlerType extends Function > ( handler : HandlerType ) {
 4 |         var wrappers = $jin.handler.wrappers
 5 |         for( var i = wrappers.length - 1 ; i >= 0 ; --i ){
 6 |             handler = wrappers[i]( handler )
 7 |         }
 8 |         return handler
 9 |     }
10 |     
11 |     module handler {
12 |         export var wrappers = []
13 |     }
14 |     
15 | }
16 | 


--------------------------------------------------------------------------------
/html/html.ts:
--------------------------------------------------------------------------------
 1 | module $jin.html {
 2 | 
 3 |     export function escape( text ) {
 4 |         return String( text )
 5 |             .replace( /&/g, '&amp;' )
 6 |             .replace( /</g, '&lt;' )
 7 |             .replace( />/g, '&gt;' )
 8 |             .replace( /"/g, '&quot;' )
 9 |             .replace( /'/g, '&apos;' )
10 |     }
11 | 
12 |     export function decode( text ) {
13 |         var decoder = document.createElement( 'textarea' )
14 |         decoder.innerHTML = text
15 |         return decoder.value
16 |     }
17 | 
18 |     export function text( html ) {
19 |         return $jin.html.decode(
20 |             String( html )
21 |             .replace( /<br[^>]*>/gi, '\n' )
22 |             .replace( /<[^<>]+>/g, '' )
23 |         )
24 |     }
25 | 
26 | }
27 | 


--------------------------------------------------------------------------------
/identical/jin_identical.jam.js:
--------------------------------------------------------------------------------
1 | $jin.identical = function( a, b ){
2 |     if(( typeof a === 'number' )&&( typeof b === 'number' )){
3 |         return String( a ) === String( b )
4 |     }
5 |     
6 |     return ( a === b )
7 | }
8 | 


--------------------------------------------------------------------------------
/jin.env=node.jam.js:
--------------------------------------------------------------------------------
1 | require( 'source-map-support' ).install();
2 | 


--------------------------------------------------------------------------------
/jin.jam.js:
--------------------------------------------------------------------------------
1 | var $jin = this.$jin = {}
2 | 


--------------------------------------------------------------------------------
/jsonp/jsonp.env=web.ts:
--------------------------------------------------------------------------------
 1 | module $jin.jsonp {
 2 |     export function fetch( uri ) {
 3 |         var promise = new $jin.atom.prop({})
 4 |         var id = '_jin_jsonp_' + Math.random().toString( 32 ).substring( 2 ).toUpperCase()
 5 |         window[ id ] = function( data ) {
 6 |             if( script.parentNode ) script.parentNode.removeChild( script )
 7 |             delete window[ id ]
 8 |             promise.push( data )
 9 |         }
10 |         var script = document.createElement( 'script' )
11 |         script.src = uri + id
12 |         document.head.appendChild( script )
13 |         return promise
14 |     }
15 | }


--------------------------------------------------------------------------------
/konst/jin-konst.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.konst
 3 |  * @method konst
 4 |  * @static
 5 |  * @member $jin
 6 |  */
 7 | $jin.definer({ '$jin.konst': function( path, gen ){
 8 | 	$jin.method( path, function jin_konst_wrapper(){
 9 | 		var key = '_' + path
10 | 		return this[ key ] || ( this[ key ] = gen.call( this ) )
11 | 	})
12 | }})
13 | 


--------------------------------------------------------------------------------
/l10n/jin-l10n.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.l10n
 3 |  * @method l10n
 4 |  * @member $jin
 5 |  * @static
 6 |  */
 7 | $jin.method({ '$jin.l10n': function( scope, text ){
 8 | 	return text
 9 | }})
10 | 


--------------------------------------------------------------------------------
/lazyProxy/jin_lazyProxy.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.lazyProxy = function( make ){
 2 |     var value
 3 |     var maked= false
 4 |     
 5 |     var get= function( ){
 6 |         if( maked ) return value
 7 |         value= make()
 8 |         maked= true
 9 |         return value
10 |     }
11 |     
12 |     return $jin.proxy
13 |     (   {   valueOf: function( target ){
14 |                 return target()
15 |             }
16 |         }
17 |     )
18 |     ( get )
19 | }
20 | 


--------------------------------------------------------------------------------
/list/jin-list-proto.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.list.cast
 3 |  * @method cast
 4 |  * @member $jin.list
 5 |  * @static
 6 |  */
 7 | $jin.method({ '$jin.list.cast': function( list ){
 8 | 	if( list instanceof this ) return list
 9 | 	return this.apply( null, list )
10 | }})
11 | 
12 | /**
13 |  * @name $jin.list.generate
14 |  * @method generate
15 |  * @member $jin.list
16 |  * @static
17 |  */
18 | $jin.method({ '$jin.list.generate': function( count, make ){
19 | 	var list = this( count )
20 | 	for( var i = 0; i < count; ++i ) list[ i ] = make( i )
21 | 	return list
22 | }})
23 | 
24 | /**
25 |  * @name $jin.list.isEqual
26 |  * @method isEqual
27 |  * @member $jin.list
28 |  * @static
29 |  */
30 | $jin.method({ '$jin.list.isEqual': function( left, right ){
31 | 	if( left.length !== right.length ) return false
32 | 	
33 | 	for( var i = 0; i < left.length; ++i ){
34 | 		if( left[ i ] !== right[ i ] ) return false
35 | 	}
36 | 	
37 | 	return true
38 | }})
39 | 
40 | 
41 | /**
42 |  * @name $jin.list#bisect
43 |  * @method bisect
44 |  * @member $jin.list
45 |  */
46 | $jin.method({ '$jin.list..bisect': function( check ){
47 |     var lo = 0
48 |     var hi = this.length
49 |     
50 |     if( !this.length ) return -1
51 |     
52 |     while( lo < hi ){
53 |         var mid = ( lo + hi ) >> 1
54 |         var val = this[ mid ]
55 |         if( check( val ) ) hi = mid
56 |         else lo = mid + 1
57 |     }
58 |     
59 |     return lo
60 | }})
61 | 
62 | /**
63 |  * @name $jin.list#head
64 |  * @method head
65 |  * @member $jin.list
66 |  */
67 | $jin.method({ '$jin.list..head': function( value ){
68 | 	if( !arguments.length ) return this[ 0 ]
69 | 	
70 | 	this.unshift( value )
71 | 	return this
72 | }})
73 | 
74 | /**
75 |  * @name $jin.list#tail
76 |  * @method tail
77 |  * @member $jin.list
78 |  */
79 | $jin.method({ '$jin.list..tail': function( value ){
80 | 	if( !arguments.length ) return this[ this.length - 1 ]
81 | 	
82 | 	this.push( value )
83 | 	return this
84 | }})
85 | 
86 | /**
87 |  * @name $jin.list#has
88 |  * @method has
89 |  * @member $jin.list
90 |  */
91 | $jin.method({ '$jin.list..has': function( value ){
92 | 	return this.indexOf( value ) >= 0
93 | }})
94 | 
95 | 


--------------------------------------------------------------------------------
/list/jin-list-test.stage=dev.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.test( function bisect_general( test ){
 2 | 	var list = $jin.list( 0,1,2,3,4,5,6,7,8,9 )
 3 | 	var index = list.bisect( function( item ){
 4 | 		return item > 3
 5 | 	} )
 6 | 	test.equal( index, 4 )
 7 | } )
 8 | 
 9 | $jin.test( function bisect_empty( test ){
10 | 	var list = $jin.list()
11 | 	var index = list.bisect( function( item ){
12 | 		return item > 3
13 | 	} )
14 | 	test.equal( index, -1 )
15 | } )
16 | 
17 | $jin.test( function bisect_all_matches( test ){
18 | 	var list = $jin.list( 0,1,2,3,4,5,6,7,8,9 )
19 | 	var index = list.bisect( function( item ){
20 | 		return item >= 0
21 | 	} )
22 | 	test.equal( index, 0 )
23 | } )
24 | 
25 | $jin.test( function bisect_no_matches( test ){
26 | 	var list = $jin.list( 0,1,2,3,4,5,6,7,8,9 )
27 | 	var index = list.bisect( function( item ){
28 | 		return item > 10
29 | 	} )
30 | 	test.equal( index, 10 )
31 | } )
32 | 


--------------------------------------------------------------------------------
/list/jin-list.css:
--------------------------------------------------------------------------------
1 | #jin-list {
2 | 	display: none;
3 | }
4 | 


--------------------------------------------------------------------------------
/list/jin-list.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.list
 3 |  * @class $jin.list
 4 |  * @returns $jin.list
 5 |  * @method list
 6 |  * @member $jin
 7 |  * @static
 8 |  */
 9 | $jin.method({ '$jin.list': function( ){
10 | 	var list = Array.apply( null, arguments )
11 | 	list.__proto__ = arguments.callee.prototype
12 | 	return list
13 | }})
14 | 
15 | $jin.glob( '$jin.list.', [] )
16 | 
17 | //$jin.mixin({ '$jin.list': [ 'Array' ] })
18 | 


--------------------------------------------------------------------------------
/list/jin-list.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.list
 3 |  * @class $jin.list
 4 |  * @returns $jin.list
 5 |  */
 6 | $jin.glob( '$jin.list', function( ){
 7 | 	var iframe = document.createElement( 'iframe' )
 8 | 	iframe.id = 'jin-list'
 9 | 	document.body.appendChild( iframe )
10 | 	var Array = iframe.contentWindow.Array
11 | 	//document.body.removeChild( iframe )
12 | 	return Array
13 | }() )
14 | 
15 | $jin.mixin({ '$jin.list': [ 'Array' ] })
16 | 


--------------------------------------------------------------------------------
/listener/jin_listener.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.listener
 3 |  * @class $jin.listener
 4 |  * @returns $jin.listener
 5 |  * @mixins $jin.klass
 6 |  */
 7 | $jin.klass({ '$jin.listener': [] })
 8 | 
 9 | /**
10 |  * @name $jin.listener#crier
11 |  * @method crier
12 |  * @member $jin.listener
13 |  */
14 | $jin.property({ '$jin.listener..crier': null })
15 | 
16 | /**
17 |  * @name $jin.listener#eventName
18 |  * @method eventName
19 |  * @member $jin.listener
20 |  */
21 | $jin.property({ '$jin.listener..eventName': String })
22 | 
23 | /**
24 |  * @name $jin.listener#handler
25 |  * @method handler
26 |  * @member $jin.listener
27 |  */
28 | $jin.property({ '$jin.listener..handler': null })
29 | 
30 | /**
31 |  * @name $jin.listener#forget
32 |  * @method forget
33 |  * @member $jin.listener
34 |  */
35 | $jin.method({ '$jin.listener..forget': function( ){
36 |     this.crier().forget( this.eventName(), this.handler() )
37 |     return this
38 | }})
39 | 
40 | /**
41 |  * @name $jin.listener#destroy
42 |  * @method destroy
43 |  * @member $jin.listener
44 |  */
45 | $jin.method({ '$jin.listener..destroy': function( ){
46 |     this.forget()
47 |     this['$jin.klass..destroy']()
48 | }})
49 | 


--------------------------------------------------------------------------------
/log/jin-log.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | this.$jin.log = function( ){
 2 | 	if( typeof console === 'undefined' ) return
 3 | 	
 4 | 	console.log.apply( console, arguments )
 5 | 
 6 | 	return arguments[0]
 7 | }
 8 | 
 9 | this.$jin.log.info = function( ){
10 | 	if( typeof console === 'undefined' ) return
11 | 	
12 | 	return console.info.apply( console, arguments )
13 | }
14 | 
15 | this.$jin.log.warn = function( ){
16 | 	if( typeof console === 'undefined' ) return
17 | 	
18 | 	return console.warn.apply( console, arguments )
19 | }
20 | 
21 | this.$jin.log.error = function( error ){
22 | 	if( typeof console === 'undefined' ) return
23 | 	
24 | 	if( error.jin_log_isLogged ) return
25 | 	
26 | 	var message = error.stack || error
27 | 	
28 | 	if( console.exception ) console.exception( error )
29 | 	else if( console.error ) console.error( message )
30 | 	else if( console.log ) console.log( message )
31 | 	
32 | 	error.jin_log_isLogged = true
33 | }
34 | 
35 | this.$jin.log.error.ignore = function( error ){
36 | 	error.jin_log_isLogged = true
37 | 	return error
38 | }
39 | 


--------------------------------------------------------------------------------
/log/log.env=web.ts:
--------------------------------------------------------------------------------
 1 | function $jin_log( ...values : any[] ) {
 2 |     if( typeof console === 'undefined' ) return
 3 | 
 4 |     console.log( console, arguments )
 5 | 
 6 |     return arguments[0]
 7 | }
 8 | 
 9 | function $jin_log_info( message : string , ...values : any[] ) {
10 |     if( typeof console === 'undefined' ) return
11 |     if( !$jin_log_filter.test( message ) ) return
12 | 
13 |     return console.info.apply( console, arguments )
14 | }
15 | 
16 | function $jin_log_warn( message : string , ...values : any[] ) {
17 |     if( typeof console === 'undefined' ) return
18 |     if( !$jin_log_filter.test( message ) ) return
19 | 
20 |     return console.warn.apply( console, arguments )
21 | }
22 | 
23 | function $jin_log_error( error ) {
24 |     if( typeof console === 'undefined' ) return
25 | 
26 |     if( error.jin_log_isLogged ) return
27 | 
28 |     var message = error.stack || error
29 | 
30 |     if( console['exception'] ) console['exception']( error )
31 |     else if( console.error ) console.error( message )
32 |     else if( console.log ) console.log( message )
33 | 
34 |     error.jin_log_isLogged = true
35 | }
36 | 
37 | function $jin_log_error_ignore( error ){
38 |     error.jin_log_isLogged = true
39 |     return error
40 | }
41 | 
42 | var $jin_log_filter = /^$/


--------------------------------------------------------------------------------
/log/log.ts:
--------------------------------------------------------------------------------
1 | declare module $jin {
2 |     export var log : any
3 | }


--------------------------------------------------------------------------------
/mailer/mailer.ts:
--------------------------------------------------------------------------------
 1 | module $jin {
 2 |     export class mailer extends $jin.object<any> {
 3 |         
 4 |         uri : any
 5 |         
 6 |         constructor( uri ) {
 7 |             this.uri = $jin.uri.parse( uri )
 8 |             super({})
 9 |         }
10 | 
11 |         Driver( ) {
12 |             return new $jin.prop.vary<any,$jin.mailer>({
13 |                 owner : this,
14 |                 name : 'driver',
15 |                 pull : prop => {
16 |                     var scheme = this.uri.scheme()
17 |                     var auth = {
18 |                         user: this.uri.login(),
19 |                         pass: this.uri.password()
20 |                     }
21 |                     var config : any
22 |                     if( scheme === 'smtp' ) {
23 |                         config = $node['nodemailer-smtp-transport']({
24 |                             host: this.uri.host(),
25 |                             tls: {
26 |                                 rejectUnauthorized: false
27 |                             },
28 |                             auth: auth
29 |                         })
30 |                     } else {
31 |                         config = {
32 |                             service: scheme,
33 |                             auth: auth,
34 |                         }
35 |                     }
36 |                     $jin.log.info( 'mail config' , config )
37 |                     return $node.nodemailer.createTransport( config )
38 |                 }
39 |             })
40 |         }
41 | 
42 |         send( config : {
43 |             from? : string
44 |             to : string
45 |             subject : string
46 |             html? : string
47 |             text? : string
48 | 			then? : ( any ) => any
49 |         } ) {
50 |             if( !config.from ) config.from = this.uri.login()
51 |             var driver = this.Driver().get()
52 |             var send = $jin.async2sync( driver.sendMail )
53 |             if ($jin.param('verbose')) $jin.log.info('Send mail', config)
54 | 			return config.then
55 | 				? $jin.sync2async( send ).call( driver , config , config.then )
56 | 				: send.call( driver , config )
57 |         }
58 |         
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/makeId/jin_makeId.doc.xml:
--------------------------------------------------------------------------------
 1 | <?xml-stylesheet href="../-mix/doc.stage=dev.xsl" type="text/xsl"?>
 2 | <doc_root
 3 |     doc_title="$jin_makeId"
 4 |     >
 5 | 
 6 |     <p>Функция генерирующая уникльный идентификатор на основе переданного ей префикса. </p>
 7 |     <p>
 8 |         <script type="wc_test">
 9 |             test.ok( $jin_makeId )
10 |         </script>
11 |         <script type="wc_test">
12 |             test.not( $jin_makeId(), $jin_makeId() )
13 |         </script>
14 |     </p>
15 |     
16 | </doc_root>
17 | 


--------------------------------------------------------------------------------
/makeId/jin_makeId.jam.js:
--------------------------------------------------------------------------------
1 | $jin.makeId = function( prefix ){
2 | 	var seeds = $jin.makeId.seeds 
3 |     return seeds[ prefix ] = ( seeds[ prefix ] + 1 ) || 1
4 | }
5 | 
6 | $jin.makeId.seeds = {}
7 | 


--------------------------------------------------------------------------------
/merge/jin-merge.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.merge.first
 3 |  * @method first
 4 |  * @member $jin.merge
 5 |  * @static
 6 |  */
 7 | $jin.method({ '$jin.merge.first': function( a, b ){
 8 | 	return a
 9 | }})
10 | 
11 | /**
12 |  * @name $jin.merge.last
13 |  * @method last
14 |  * @member $jin.merge
15 |  * @static
16 |  */
17 | $jin.method({ '$jin.merge.last': function( a, b ){
18 | 	return b
19 | }})
20 | 
21 | /**
22 |  * @name $jin.merge.summ
23 |  * @method summ
24 |  * @member $jin.merge
25 |  * @static
26 |  */
27 | $jin.method({ '$jin.merge.summ': function( a, b ){
28 | 	return a + b
29 | }})
30 | 
31 | /**
32 |  * @name $jin.merge.sub
33 |  * @method sub
34 |  * @member $jin.merge
35 |  * @static
36 |  */
37 | $jin.method({ '$jin.merge.sub': function( a, b ){
38 | 	return a - b
39 | }})
40 | 
41 | /**
42 |  * @name $jin.merge.mult
43 |  * @method mult
44 |  * @member $jin.merge
45 |  * @static
46 |  */
47 | $jin.method({ '$jin.merge.mult': function( a, b ){
48 | 	return a * b
49 | }})
50 | 
51 | /**
52 |  * @name $jin.merge.div
53 |  * @method div
54 |  * @member $jin.merge
55 |  * @static
56 |  */
57 | $jin.method({ '$jin.merge.div': function( a, b ){
58 | 	return a * b
59 | }})
60 | 


--------------------------------------------------------------------------------
/method/jin-method.doc.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nin-jin/mam_jin_0/f67779377d4a7d451b9e02229a18292e8f4231b6/method/jin-method.doc.md


--------------------------------------------------------------------------------
/method/naming/jin_method_naming.jam.js:
--------------------------------------------------------------------------------
 1 | this.$jin.method.naming = function $jin_method_naming( name, owner ){
 2 |     if( arguments.length < 2 ){
 3 |         owner = $jin.glob( name )
 4 |     }
 5 |     
 6 |     for( var key in owner ){
 7 |         if( !owner.hasOwnProperty( key ) ) continue
 8 |         
 9 |         var value = owner[ key ]
10 |         if( Object( value ) !== value ) continue
11 |         
12 |         $jin.method.naming( name + '.' + key, value )
13 |     }
14 |     
15 |     if( typeof owner === 'function' && !owner.displayName ){
16 |         $jin.method.naming( name + '.', owner.prototype )
17 |         if( !owner.displayName ) owner.displayName = name
18 |         owner.jin_method_resolves = [ '$' + 'jin.klass..constructor' ]
19 |     }    
20 | }
21 | 


--------------------------------------------------------------------------------
/middle4pack/jin_middle4pack.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | this.$jin.middle4pack=
 2 | function( pack ){
 3 |     pack = $jin.file( pack )
 4 |     
 5 |     return $jin.sync2middle( function( req, res ){
 6 |         var uri = $jin.uri( req.originalUrl.substring( 1 ) )
 7 |         
 8 |         var prefix = '$' + pack.name() + '_'
 9 |         var keys = Object.keys( uri.query() )
10 |         
11 |         while( keys.length ){
12 |             var resource= $jin.glob( prefix + keys.join( '_' ) )
13 |             
14 |             if( !resource ){
15 |                 keys.pop()
16 |                 continue
17 |             }
18 |             
19 |             return resource( uri ).resource_act( req.method.toLowerCase(), req )
20 |         }
21 |         
22 |         return null
23 |     } )
24 | }
25 | 


--------------------------------------------------------------------------------
/middle4static/jin_middle4static.env=node.jam.js:
--------------------------------------------------------------------------------
1 | this.$jin.middle4static =
2 | function( ){
3 |     return $node.express.static
4 |     (   $node.path.resolve()
5 |     ,   { maxAge: 1000 * 60 * 60 * 24 * 365 * 1000 }
6 |     )
7 | }


--------------------------------------------------------------------------------
/minify/jin_minify_js.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.minify.js
 3 |  * @method js
 4 |  * @static
 5 |  * @member $jin.minify
 6 |  */
 7 | $jin.method({ '$jin.minify.js': function( file ){
 8 |     var config = {}
 9 |     //config.output = { semicolons: false, indent_level: 0, beautify: true, space_colon: true }
10 |     var text = $node[ 'uglify-js' ].minify( [ file.path() ], config ).code
11 |     
12 |     file.content( text )
13 |     return file
14 | }})
15 | 


--------------------------------------------------------------------------------
/mixin/jin_mixin.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.mixin
 3 |  * @method mixin
 4 |  * @static
 5 |  * @member $jin
 6 |  */
 7 | $jin.definer({ '$jin.mixin': function( targetPath, sourcePathList ){
 8 |     var trait = $jin.mixin.object( targetPath, sourcePathList )
 9 |     
10 | 	sourcePathList = sourcePathList.map( function( sourcePath ){
11 | 		return sourcePath + '.'
12 | 	})
13 | 	
14 |     $jin.mixin.object( targetPath + '.', sourcePathList )
15 |     
16 |     return trait
17 | }})
18 | 
19 | /**
20 |  * @name $jin.mixin.object
21 |  * @method object
22 |  * @static
23 |  * @member $jin.mixin
24 |  */
25 | $jin.definer({ '$jin.mixin.object': function( targetPath, sourcePathList ){
26 | 	targetPath = String( targetPath )
27 |     var target = $jin.trait( targetPath )
28 |     
29 |     sourcePathList.forEach( function( sourcePath ){
30 |         var source = $jin.trait( sourcePath )
31 | 		
32 |         if( !source.jin_mixin_slaveList ) source.jin_mixin_slaveList = []
33 |         if( source.jin_mixin_slaveList.indexOf( targetPath ) >= 0 ) return
34 |         
35 |         for( var key in source ){
36 |             var func = source[ key ]
37 | 			if( key.charAt(0) === '_' ) continue
38 | 			if( typeof func === 'function' ){
39 | 				if( !func.displayName ) func.displayName = sourcePath + '.' + key
40 | 			} else {
41 |                 if(!( key in target )) target[ key ] = void 0
42 |                 continue
43 |             }
44 |             
45 |             var methodName = func.displayName.replace( /^([$\w]*\.)+/, '' )
46 | 			$jin.method( targetPath + '.' + methodName, func )
47 |         }
48 | 		
49 |         source.jin_mixin_slaveList.push( targetPath )
50 |     })
51 |     
52 |     return target
53 | }})
54 | 


--------------------------------------------------------------------------------
/mock/jin_mock.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.mock
 3 |  * @class $jin.mock
 4 |  * @returns $jin.mock
 5 |  * @mixins $jin.klass
 6 |  */
 7 | $jin.klass({ '$jin.mock': [] })
 8 | 
 9 | /**
10 |  * @name $jin.mock#path
11 |  * @method path
12 |  * @member $jin.mock
13 |  */
14 | $jin.property({ '$jin.mock..path': String })
15 | 
16 | /**
17 |  * @name $jin.mock#ownerPath
18 |  * @method ownerPath
19 |  * @member $jin.mock
20 |  */
21 | $jin.property({ '$jin.mock..ownerPath': function( ){
22 | 	return this.path().replace( /\.[^.]*$/, '' )
23 | }})
24 | 
25 | /**
26 |  * @name $jin.mock#fieldName
27 |  * @method fieldName
28 |  * @member $jin.mock
29 |  */
30 | $jin.property({ '$jin.mock..fieldName': function(){
31 | 	return this.path().replace( /^.*\./, '' )
32 | }})
33 | 
34 | /**
35 |  * @name $jin.mock#value
36 |  * @method value
37 |  * @member $jin.mock
38 |  */
39 | $jin.property({ '$jin.mock..value': null })
40 | 
41 | /**
42 |  * @name $jin.mock#backupValue
43 |  * @method backupValue
44 |  * @member $jin.mock
45 |  */
46 | $jin.property({ '$jin.mock..backupValue': null })
47 | 
48 | /**
49 |  * @name $jin.mock#backupOwner
50 |  * @method backupOwner
51 |  * @member $jin.mock
52 |  */
53 | $jin.property({ '$jin.mock..backupOwner': null })
54 | 
55 | /**
56 |  * @name $jin.mock#mocking
57 |  * @method mocking
58 |  * @member $jin.mock
59 |  */
60 | $jin.property({ '$jin.mock..mocking': function( mocking ){
61 |     var fieldName = this.fieldName()
62 |     if( mocking ){
63 | 		var owner =  $jin.trait( this.ownerPath() )
64 | 		this.backupOwner( owner )
65 |         this.backupValue( owner[ fieldName ] )
66 |         owner[ fieldName ] = this.value()
67 |     } else {
68 | 		var owner = this.backupOwner()
69 |         owner[ fieldName ] = this.backupValue()
70 |         this.backupOwner( null )
71 |         this.backupValue( null )
72 |     }
73 |     return mocking
74 | }})
75 | 
76 | /**
77 |  * @name $jin.mock#destroy
78 |  * @method destroy
79 |  * @member $jin.mock
80 |  */
81 | $jin.method({ '$jin.mock..destroy': function( ){
82 |     this.mocking( false )
83 |     this['$jin.klass..destroy']()
84 | }})
85 | 


--------------------------------------------------------------------------------
/model/model.stage=dev.ts:
--------------------------------------------------------------------------------
 1 | class User extends $jin.model<any> {
 2 |     static objectId = $jin.model.classRegister( 'User' )
 3 | 
 4 |     get login() {
 5 |         return new $jin.atom.prop<string,User>({
 6 |             pull : prev => 'anonimous'
 7 |         })
 8 |     }
 9 | 
10 | }
11 | 
12 | var newUserName = new $jin.atom.prop({
13 |     pull : () => {
14 |         var user1 = new User({ })
15 |         return user1.login.get()
16 |     },
17 |     reap: () => null
18 | }).get()
19 | 
20 | class UserNext extends $jin.model<any> {
21 |     static objectId = $jin.model.classRegister( 'User' )
22 | 
23 |     get login() {
24 |         return new $jin.atom.prop<string,UserNext>({
25 |             pull : prev => 'user_' + this.objectId
26 |         })
27 |     }
28 | 
29 | }
30 | 
31 | eval('User = UserNext')
32 | 


--------------------------------------------------------------------------------
/model/model.ts:
--------------------------------------------------------------------------------
 1 | module $jin {
 2 |     
 3 |     export class model < OwnerType extends $jin.object.iface > extends $jin.object < OwnerType > {
 4 | 
 5 |         static objectId = '$jin.model'
 6 | 
 7 |         static classRegister( classId : string , superId? : string ) {
 8 |             var classAtom = $jin.model.classAtom( classId )
 9 |             classAtom.notify()
10 |             if( superId ) {
11 |                 var superAtom = $jin.model.classAtom(superId)
12 |                 classAtom.obey(superAtom)
13 |                 superAtom.lead(classAtom)
14 |             }
15 |             return classId
16 |         }
17 | 
18 |         static classAtom( key : string ){
19 |             return new $jin.atom.prop<string,typeof $jin.model>( {
20 |                 owner : $jin.model,
21 |                 name : key
22 |             } )
23 |         }
24 | 
25 |         constructor( config ) {
26 |             super( config )
27 |             $jin.model.classAtom( (<any>this.constructor).objectId ).touch()
28 |         }
29 | 
30 |         toString() {
31 |             return this.objectId
32 |         }
33 | 
34 |     }
35 |     
36 |     module model {
37 | 
38 |     }
39 | }


--------------------------------------------------------------------------------
/module/jin-module.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.module
 3 |  * @method module
 4 |  * @static
 5 |  * @member $jin
 6 |  */
 7 | $jin.definer({ '$jin.module': function( prefix, map ){
 8 | 	if( typeof map === 'function' ) map = new map
 9 | 	
10 | 	for( var suffix in map ){
11 | 		var arg = map[ suffix ]
12 | 		if( arg[0] ){
13 | 			var definer = arg[0]
14 | 			definer.apply( null, [ prefix + '.' + suffix ].concat( arg.slice( 1 ) ) )
15 | 		} else {
16 | 			map[ suffix ]( prefix + '.' + suffix  )
17 | 		}
18 | 	}
19 | 	
20 | }})
21 | 


--------------------------------------------------------------------------------
/object/object.stage=dev.ts:
--------------------------------------------------------------------------------
 1 | //module $jin.object.test {
 2 | 
 3 | $jin.test({ 'auto_generated_id' : test =>{
 4 |     var one = new $jin.object({ })
 5 |     var two = new $jin.object({ })
 6 |     test.unique( one.objectId , two.objectId )
 7 | }})
 8 | 
 9 | $jin.test({ 'id_generation_from_names' : test =>{
10 |     var one = new $jin.object({
11 |         name : 'test1'
12 |     })
13 |     var two = new $jin.object({
14 |         owner : one,
15 |         name : 'test2'
16 |     })
17 |     test.equal( two.objectId , '$jin.object.test1.test2' )
18 | }})
19 | 
20 | $jin.test({ 'double_destroying' : test =>{
21 |     var one = new $jin.object({ })
22 |     one.destroy()
23 |     one.destroy()
24 | }})
25 | 
26 | $jin.test({ 'cascade_destroying' : test =>{
27 |     var one = new $jin.object({
28 |         name : 'test1'
29 |     })
30 |     var two = new $jin.object({
31 |         owner : one,
32 |         name : 'test2'
33 |     })
34 |     var three = new $jin.object({
35 |         owner : two,
36 |         name : 'test3'
37 |     })
38 |     test.equal( three.owner , two )
39 |     one.destroy()
40 |     test.equal( three.owner , null )
41 | }})
42 | 
43 | //}


--------------------------------------------------------------------------------
/onDomReady/jin_onDomReady.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.onDomReady
 3 |  * @class $jin.onDomReady
 4 |  * @returns $jin.onDomReady
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.onDomReady': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.onDomReady.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.onDomReady
15 |  */
16 | $jin.method({ '$jin.onDomReady.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'DOMContentLoaded'
19 | }})
20 | 


--------------------------------------------------------------------------------
/onElemAdd/jin_onElemAdd.doc.xml:
--------------------------------------------------------------------------------
 1 | <?xml-stylesheet href="../-mix/doc.stage=dev.xsl" type="text/xsl"?>
 2 | <doc_root
 3 |     doc_title="$jin_onElemAdd"
 4 |     >
 5 | 
 6 |     <p>Событие возникающее, когда в поддерево заданного элемента добавляются новые элементы. </p>
 7 |     <p>
 8 |         <script type="wc_test">
 9 |             test.ok( $jin_onElemAdd )
10 |         </script>
11 |     </p>
12 |     <p>
13 |         <script type="wc_test">
14 |         <![CDATA[
15 |             var node= document.createElement( 'jin_onElemAdd_test' )
16 |             document.getElementsByTagName( 'body' )[0].appendChild( node )
17 |             
18 |             var result= []
19 |             var listener=
20 |             $jin_onElemAdd.listen( node, test.callback( function( event ){
21 |                 result.push( event.target().localName )
22 |             } ) )
23 |             
24 |             node.innerHTML+= 'foo'
25 |             node.innerHTML+= '<?jin_onElemAdd_test0?>'
26 |             node.innerHTML+= '<!--hello-->'
27 |             node.innerHTML+= '<jin_onElemAdd_test1>world</jin_onElemAdd_test1>'
28 |             node.innerHTML+= '<jin_onElemAdd_test2><jin_onElemAdd_test3></jin_onElemAdd_test3></jin_onElemAdd_test2>'
29 |             
30 |             listener.destroy()
31 |             node.parentNode.removeChild( node )
32 |             
33 |             test.ok( result.join( ',' ), 'jin_onelemadd_test1,jin_onelemadd_test1,jin_onelemadd_test2,jin_onelemadd_test3' )
34 |         ]]>
35 |         </script>
36 |     </p>
37 |     
38 | </doc_root>
39 | 


--------------------------------------------------------------------------------
/onElemAdd/jin_onElemAdd.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.onElemAdd
 3 |  * @class $jin.onElemAdd
 4 |  * @returns $jin.onElemAdd
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.onElemAdd': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.onElemAdd.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.onElemAdd
15 |  */
16 | $jin.method({ '$jin.onElemAdd.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'DOMNodeInserted'
19 | }})
20 | 


--------------------------------------------------------------------------------
/onElemDrop/jin_onElemDrop.doc.xml:
--------------------------------------------------------------------------------
 1 | <?xml-stylesheet href="../-mix/doc.stage=dev.xsl" type="text/xsl"?>
 2 | <doc_root
 3 |     doc_title="$jin_onElemDrop"
 4 |     >
 5 | 
 6 |     <p>Событие возникающее, когда в поддерево заданного элемента добавляются новые элементы. </p>
 7 |     <p>
 8 |         <script type="wc_test">
 9 |             test.ok( $jin_onElemDrop )
10 |         </script>
11 |     </p>
12 |     <p>
13 |         <script type="wc_test">
14 |         <![CDATA[
15 |             test.timeout= 0
16 |             
17 |             var node= document.createElement( 'jin_onElemDrop_test' )
18 |             document.getElementsByTagName( 'body' )[0].appendChild( node )
19 |             
20 |             var listener=
21 |             $jin_onElemDrop.listen( node, test.callback( function( event ){
22 |                 test.ok( event.target().localName ).done()
23 |             } ) )
24 |             
25 |             node.innerHTML= '<jin_onElemDrop_test2><jin_onElemDrop_test3></jin_onElemDrop_test3></jin_onElemDrop_test2>'
26 |             node.parentNode.removeChild( node )
27 |             listener.destroy()
28 |             
29 |         ]]>
30 |         </script>
31 |     </p>
32 |     
33 | </doc_root>
34 | 


--------------------------------------------------------------------------------
/onElemDrop/jin_onElemDrop.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.onElemDrop
 3 |  * @class $jin.onElemDrop
 4 |  * @returns $jin.onElemDrop
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.onElemDrop': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.onElemDrop.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.onElemDrop
15 |  */
16 | $jin.method({ '$jin.onElemDrop.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'DOMNodeRemoved'
19 | }})
20 | 


--------------------------------------------------------------------------------
/pack/props/props.meta.tree:
--------------------------------------------------------------------------------
1 | include =jin/prop/vary
2 | include =jin/prop/proxy
3 | include =jin/atom/prop
4 | include =jin/atom/list
5 | include =jin/atom/numb
6 | include =jin/atom/flag
7 | include =jin/atom/str
8 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "pms-jin",
 3 |     "version": "1.0.2",
 4 |     "description": "PMS modules from Nin Jin",
 5 |     "homepage": "https://github.com/nin-jin/pms-jin",
 6 |     "main": "-mix/index.env=node.stage=release.js",
 7 |     "author": {
 8 |         "name": "Nin Jin",
 9 |         "email": "nin-jin@ya.ru"
10 |     },
11 |     "keywords": [
12 |         "javascript",
13 |         "framework",
14 |         "modules",
15 |         "assets"
16 |     ],
17 |     "bugs": {
18 |         "email": "nin-jin@ya.ru"
19 |     },
20 |     "dependencies": {
21 |         "pms": "*"
22 |     },
23 |     "engine": "node >= 0.4.1",
24 |     "readmeFilename": "README.md",
25 |     "repository": {
26 |         "type": "git",
27 |         "url": "https://github.com/nin-jin/pms-jin.git"
28 |     }
29 | }


--------------------------------------------------------------------------------
/param/jin_param.jam.js:
--------------------------------------------------------------------------------
1 | $jin.param = function( key ){
2 |     return $jin.param.hash()[ key ]
3 | }
4 | 


--------------------------------------------------------------------------------
/param/jin_param_hash.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.param.hash
 3 |  * @method hash
 4 |  * @static
 5 |  * @member $jin.param
 6 |  */
 7 | $jin.property({ '$jin.param.hash': function( ){
 8 |     var param = {}
 9 |     for( var index = 2; index < process.argv.length; ++index ){
10 |         var values = process.argv[ index ].split( '=' )
11 |         param[ values.shift() ] = values
12 |     }
13 |     return param
14 | }})
15 | 


--------------------------------------------------------------------------------
/param/jin_param_hash.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.param.hash
 3 |  * @method hash
 4 |  * @static
 5 |  * @member $jin.param
 6 |  */
 7 | $jin.property({ '$jin.param.hash': function( ){
 8 |     var param = {}
 9 |     var query = document.location.search + document.location.hash
10 |     var chunks = query.split( /[&;?#]/g )
11 |     chunks.forEach( function( chunk ){
12 |         var values = chunk.split( /[:=]/ )
13 |         values = values.map( decodeURIComponent )
14 |         param[ values.shift() ] = values
15 |     } )
16 |     return param
17 | }})
18 | 


--------------------------------------------------------------------------------
/param/param.ts:
--------------------------------------------------------------------------------
1 | declare module $jin {
2 |     export function param( name : string ) : string[]
3 | }


--------------------------------------------------------------------------------
/path/jin_path.jam.js:
--------------------------------------------------------------------------------
 1 | this.$jin.path=
 2 | function( axis ){
 3 | 
 4 |     var cache= {}
 5 |     
 6 |     var tokens= Object.keys( axis ).join( '' )
 7 |     
 8 |     var lexer= RegExp( '([' + tokens + ']?)\s*([^' + tokens + '\\s]*)', 'g' )
 9 |     
10 |     return function( path ){
11 |         var result= cache[ path ]
12 |         if( result ) return result
13 |         
14 |         var processors= []
15 |         path.replace
16 |         (   lexer
17 |         ,   function( str, type, name ){
18 |                 if( !str ) return
19 |                 processors.push( axis[ type || '' ]( name ) )
20 |             }
21 |         )
22 |         
23 |         return cache[ path ]= function( value ){
24 |             return processors.reduce( function( val, proc ){
25 |                 return proc( val )
26 |             }, value )
27 |         }
28 |     }
29 | 
30 | }
31 | 


--------------------------------------------------------------------------------
/persistent/jin_persistent.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.persistent = function( body, options ){
 2 |     
 3 |     $jin.application( process.env[ 'jin_persistent_body' ] ? body : supervisor )
 4 |     
 5 |     function supervisor( ){
 6 |         var app = null
 7 |         var allowRestart = false
 8 |         
 9 |         var start = function start_worker( ){
10 |             $jin.log.info( 'Starting application...' )
11 |             var env = Object.create( process.env )
12 |             env[ 'jin_persistent_body' ] = true
13 |             app= $node.child_process.fork( process.mainModule.filename, process.argv.slice(2), { env: env } )
14 |             
15 |             allowRestart = false
16 |             var isStopped = false
17 |             
18 |             app.on( 'exit', function handle_exit( code ){
19 |                 if( code ) $jin.log.error( 'Application halted (' + code + ')' )
20 |                 else $jin.log.info( 'Application stopped' )
21 |                 app = null
22 |                 if( allowRestart ) start()
23 |             } )
24 |             
25 |             var sleepTimer = setTimeout( function( ){
26 |                 allowRestart = true
27 |             }, 30000 )
28 |         }
29 |         
30 |         var restart = $jin.throttle( 250, function restart_wroker( ){
31 |             allowRestart = true
32 |             if( app ) app.kill()
33 |             else start()
34 |         } )
35 |         
36 |         start()
37 |         
38 |         $jin.file('.').listen( function handle_fs_changes( event ){
39 |             var file = event.target() 
40 |             
41 |             if( file.name() === 'node_modules' ) return
42 |             if( /(\\|\/)\W/i.test( file.path() ) ) return
43 |             
44 |             $jin.log.info( 'Changed [' + file.relate() + ']' )
45 |             restart()
46 |         } )
47 |         
48 |     }
49 |     
50 | }
51 | 


--------------------------------------------------------------------------------
/pipe/jin-pipe.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.pipe = function( funcs ){
 2 | 	switch( funcs.length ){
 3 | 		case 0: return $jin.pipe.nop
 4 | 		case 1: return funcs[0]
 5 | 		default:
 6 | 			var mid = Math.ceil( funcs.length / 2 )
 7 | 			var inner = $jin.pipe( funcs.slice( 0, mid ) )
 8 | 			var outer = $jin.pipe( funcs.slice( mid ) )
 9 | 			return function( value ){
10 | 				return outer( inner( value ) )
11 | 			}
12 | 	}
13 | }
14 | 
15 | $jin.pipe.nop = function( value ){
16 | 	return value
17 | }


--------------------------------------------------------------------------------
/pipe/pipe.ts:
--------------------------------------------------------------------------------
1 | declare module $jin {
2 |     export var pipe : any
3 | }
4 | 


--------------------------------------------------------------------------------
/plotter/jin-plotter.css:
--------------------------------------------------------------------------------
1 | [jin-plotter] {
2 | 	display: block;
3 | 	max-width: 100%;
4 | 	max-height: 100%;
5 | }
6 | 


--------------------------------------------------------------------------------
/plotter/jin-plotter.sample.html:
--------------------------------------------------------------------------------
1 | <canvas jin-plotter="{id}"
2 | 	width="{width}"
3 | 	height="{height}"
4 | 	jin-plotter-generation="{generation}"
5 | 	>
6 | </canvas>
7 | 


--------------------------------------------------------------------------------
/pool/jin-pool.jam.js:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nin-jin/mam_jin_0/f67779377d4a7d451b9e02229a18292e8f4231b6/pool/jin-pool.jam.js


--------------------------------------------------------------------------------
/press/jin-press-onEnter.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.press.onEnter
 3 |  * @class $jin.press.onEnter
 4 |  * @returns $jin.press.onEnter
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.press.onEnter': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.press.onEnter.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.press.onEnter
15 |  */
16 | $jin.method({ '$jin.press.onEnter.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'keydown'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.press.onEnter.listen
23 |  * @method listen
24 |  * @static
25 |  * @member $jin.press.onEnter
26 |  */
27 | $jin.method({ '$jin.press.onEnter.listen': function( crier, handler ){
28 | 	return this[ '$jin.dom.event.listen' ]( crier, function press_wrapper( event ){
29 | 		if( event.keyCode() != 13 ) return
30 | 		handler( event )
31 | 	} )
32 | }})
33 | 


--------------------------------------------------------------------------------
/press/jin-press-onEscape.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.press.onEscape
 3 |  * @class $jin.press.onEscape
 4 |  * @returns $jin.press.onEscape
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.press.onEscape': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.press.onEscape.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.press.onEscape
15 |  */
16 | $jin.method({ '$jin.press.onEscape.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'keydown'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.press.onEscape.listen
23 |  * @method listen
24 |  * @static
25 |  * @member $jin.press.onEscape
26 |  */
27 | $jin.method({ '$jin.press.onEscape.listen': function( crier, handler ){
28 | 	return this[ '$jin.dom.event.listen' ]( crier, function press_wrapper( event ){
29 | 		if( event.keyCode() != 27 ) return
30 | 		handler( event )
31 | 	} )
32 | }})
33 | 


--------------------------------------------------------------------------------
/press/jin-press-onGoDown.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.press.onGoDown
 3 |  * @class $jin.press.onGoDown
 4 |  * @returns $jin.press.onGoDown
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.press.onGoDown': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.press.onGoDown.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.press.onGoDown
15 |  */
16 | $jin.method({ '$jin.press.onGoDown.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'keydown'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.press.onGoDown.listen
23 |  * @method listen
24 |  * @static
25 |  * @member $jin.press.onGoDown
26 |  */
27 | $jin.method({ '$jin.press.onGoDown.listen': function( crier, handler ){
28 | 	return this[ '$jin.dom.event.listen' ]( crier, function press_wrapper( event ){
29 | 		if( event.keyCode() != 40 ) return
30 | 		handler( event )
31 | 	} )
32 | }})
33 | 


--------------------------------------------------------------------------------
/press/jin-press-onGoLeft.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.press.onGoLeft
 3 |  * @class $jin.press.onGoLeft
 4 |  * @returns $jin.press.onGoLeft
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.press.onGoLeft': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.press.onGoLeft.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.press.onGoLeft
15 |  */
16 | $jin.method({ '$jin.press.onGoLeft.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'keydown'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.press.onGoLeft.listen
23 |  * @method listen
24 |  * @static
25 |  * @member $jin.press.onGoLeft
26 |  */
27 | $jin.method({ '$jin.press.onGoLeft.listen': function( crier, handler ){
28 | 	return this[ '$jin.dom.event.listen' ]( crier, function press_wrapper( event ){
29 | 		if( event.keyCode() != 37 ) return
30 | 		handler( event )
31 | 	} )
32 | }})
33 | 


--------------------------------------------------------------------------------
/press/jin-press-onGoRight.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.press.onGoRight
 3 |  * @class $jin.press.onGoRight
 4 |  * @returns $jin.press.onGoRight
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.press.onGoRight': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.press.onGoRight.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.press.onGoRight
15 |  */
16 | $jin.method({ '$jin.press.onGoRight.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'keydown'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.press.onGoRight.listen
23 |  * @method listen
24 |  * @static
25 |  * @member $jin.press.onGoRight
26 |  */
27 | $jin.method({ '$jin.press.onGoRight.listen': function( crier, handler ){
28 | 	return this[ '$jin.dom.event.listen' ]( crier, function press_wrapper( event ){
29 | 		if( event.keyCode() != 39 ) return
30 | 		handler( event )
31 | 	} )
32 | }})
33 | 


--------------------------------------------------------------------------------
/press/jin-press-onGoUp.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.press.onGoUp
 3 |  * @class $jin.press.onGoUp
 4 |  * @returns $jin.press.onGoUp
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.dom.event
 7 |  */
 8 | $jin.klass({ '$jin.press.onGoUp': [ '$jin.dom.event' ] })
 9 | 
10 | /**
11 |  * @name $jin.press.onGoUp.type
12 |  * @method type
13 |  * @static
14 |  * @member $jin.press.onGoUp
15 |  */
16 | $jin.method({ '$jin.press.onGoUp.type': function( ){
17 |     this['$jin.event.type']
18 |     return 'keydown'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.press.onGoUp.listen
23 |  * @method listen
24 |  * @static
25 |  * @member $jin.press.onGoUp
26 |  */
27 | $jin.method({ '$jin.press.onGoUp.listen': function( crier, handler ){
28 | 	return this[ '$jin.dom.event.listen' ]( crier, function press_wrapper( event ){
29 | 		if( event.keyCode() != 38 ) return
30 | 		handler( event )
31 | 	} )
32 | }})
33 | 


--------------------------------------------------------------------------------
/prop/proxy/proxy.ts:
--------------------------------------------------------------------------------
 1 | module $jin.prop {
 2 | 
 3 |     export class proxy<ValueType> {
 4 | 
 5 |         constructor( config : {
 6 |             pull? : () => ValueType
 7 |             put? : ( next? : ValueType ) => void
 8 |         } ){
 9 |             if( config.pull ) this.get = config.pull
10 |             if( config.put ) this.set = config.put
11 |             return this
12 |         }
13 | 
14 |         get() : ValueType {
15 |             return undefined
16 |         }
17 | 
18 |         set( next? : ValueType ){
19 |         }
20 | 
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/property/jin_property.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.property
 3 |  * @method property
 4 |  * @static
 5 |  * @member $jin
 6 |  */
 7 | $jin.definer({ '$jin.property': function( name, filter ){
 8 |     var fieldName = '_' + name
 9 | 	
10 | 	if( filter ){
11 | 		var resolveList = filter.jin_method_resolves
12 | 		if( !resolveList ){
13 | 			resolveList = filter.jin_method_resolves = []
14 | 			Object.toString.call( filter ).replace( /['"](\$[.\w]+)['"]/g, function( str, token ){
15 | 				if( resolveList.indexOf( token ) >= 0 ) return str
16 | 				resolveList.push( token )
17 | 			})
18 | 		}
19 | 		
20 | 		var property = function( next ){
21 | 			var prev = this[ fieldName ]
22 | 			if( arguments.length ){
23 | 				if( next === prev ) return this
24 | 				if( next === void 0 ){
25 | 					this[ fieldName ] = next
26 | 				} else {
27 | 					this[ fieldName ] = filter.call( this, next )
28 | 				}
29 | 				return this
30 | 			} else {
31 | 				if( prev === void 0 ){
32 | 					return this[ fieldName ] = filter.call( this )
33 | 				} else {
34 | 					return prev
35 | 				}
36 | 			}
37 | 		}
38 | 	} else {
39 | 		var property = function( value ){
40 | 			if( arguments.length ){
41 | 				this[ fieldName ] = value
42 | 				return this
43 | 			} else {
44 | 				return this[ fieldName ]
45 | 			}
46 | 		}
47 | 	}
48 |     
49 |     property.jin_method_resolves = resolveList
50 |     
51 |     return $jin.method( name, property )
52 | }})
53 | 
54 | /**
55 |  * @name $jin.property.hash
56 |  * @method hash
57 |  * @static
58 |  * @member $jin.property
59 |  */
60 | $jin.definer({ '$jin.property.hash': function( path, config ){
61 | 	var fieldName = '_' + path
62 | 	var pull = config.pull || config.sync
63 | 	var put = config.put || config.sync
64 | 	var push = config.push
65 | 	
66 | 	var propHash = function( key, value ){
67 | 		var storage = this[ fieldName ]
68 | 		if( !storage ) storage = this[ fieldName ] = {}
69 | 		if( arguments.length > 1 ){
70 | 			var value2 = put ? put.call( this, key, value ) : value
71 | 			if( value2 === void 0 ) delete storage[ key ]
72 | 			else storage[ key ] = value2
73 | 			return this
74 | 		} else if( arguments.length ) {
75 | 			if( typeof key === 'object' ){
76 | 				for( var k in key ){
77 | 					propHash.call( this, k, key[ k ] )
78 | 				}
79 | 				return this
80 | 			}
81 | 			var value2 = storage[ key ]
82 | 			if( pull && value2 === void 0 ) value2 = storage[ key ] = pull.call( this, key )
83 | 			return value2
84 | 		} else {
85 | 			return storage
86 | 		}
87 | 	}
88 | 	
89 | 	return $jin.method( path, propHash )
90 | }})
91 | 


--------------------------------------------------------------------------------
/registry/jin_registry.doc.xml:
--------------------------------------------------------------------------------
 1 | <?xml-stylesheet href="../-mix/doc.stage=dev.xsl" type="text/xsl"?>
 2 | <doc_root
 3 |     doc_title="$jin_registry"
 4 |     >
 5 | 
 6 |     <p>Примесь, которая реализует кеширование экземпляров класса по первому переданному параметру. </p>
 7 |     <p>
 8 |         <script type="wc_test">
 9 |             test.ok( $jin_registry )
10 |         </script>
11 |         <script type="wc_test">
12 |             var Man= $jin_class( function( Man, man ){
13 |                 $jin_registry.scheme( Man )
14 |             } )
15 |             test.ok( Man( 1 ), Man( 1 ) )
16 |         </script>
17 |         <script type="wc_test">
18 |             var Man= $jin_class( function( Man, man ){
19 |                 $jin_registry.scheme( Man )
20 |             } )
21 |             test.not( Man( 1 ), Man( 2 ) )
22 |         </script>
23 |     </p>
24 |     
25 |     <p>Может быть использована вместо $jin_class при определении класса - тогда будет создан класс с уже примешанным $jin_registry.</p>
26 |     <p>
27 |         <script type="wc_test">
28 |             var Man= $jin_class( function( Man ){
29 |                 $jin_registry.scheme( Man )
30 |             } )
31 |             test.ok( Man( 1 ), Man( 1 ) )
32 |         </script>
33 |         <script type="wc_test">
34 |             var Man= $jin_class( function( Man ){
35 |                 $jin_registry.scheme( Man )
36 |             } )
37 |             test.not( Man( 1 ), Man( 2 ) )
38 |         </script>
39 |     </p>
40 |     
41 | </doc_root>
42 | 


--------------------------------------------------------------------------------
/registry/jin_registry.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Registry of singletons trait.
 3 |  * http://en.wikipedia.org/wiki/Multiton_pattern
 4 |  * Can be mixed with jin-pool trait.
 5 |  */
 6 | 
 7 | /**
 8 |  * Hash map of created instances.
 9 |  * @name $jin.registry.storage
10 |  * @method storage
11 |  * @static
12 |  * @member $jin.registry
13 |  */
14 | $jin.property.hash({ '$jin.registry.storage': {} })
15 | 
16 | /**
17 |  * Select instance from registry.
18 |  * Otherwise creats new one.
19 |  * @name $jin.registry.exec
20 |  * @method exec
21 |  * @static
22 |  * @member $jin.registry
23 |  */
24 | $jin.method({ '$jin.registry.exec': function( id ){
25 | 	if( !arguments.length ) return this['$jin.klass.exec']()
26 | 	
27 | 	if( id instanceof this ) return id
28 | 	id = String( id )
29 | 	
30 |     var obj = id; while( typeof obj === 'string' ) obj = this.storage( obj )
31 | 	
32 |     if( obj ) return obj
33 |     
34 | 	var make = this['$jin.pool.exec'] || this['$jin.klass.exec']
35 | 	
36 |     var newObj = make.call( this, { id: id } )
37 |     var id2 = String( newObj.id() )
38 |     
39 | 	if( id !== id2 ){
40 | 		var obj = this.storage( id2 )
41 | 		if( obj ) return obj
42 | 		this.storage( id, id2 )
43 | 	}
44 | 	
45 | 	this.storage( id2, newObj )
46 | 	
47 |     return newObj
48 | }})
49 | 
50 | /**
51 |  * Identifier of instance.
52 |  * @name $jin.registry#id
53 |  * @method id
54 |  * @member $jin.registry
55 |  */
56 | $jin.property({ '$jin.registry..id': String })
57 | 
58 | /**
59 |  * Removes from registry on destroy.
60 |  * @name $jin.registry#destroy
61 |  * @method destroy
62 |  * @member $jin.registry
63 |  */
64 | $jin.method({ '$jin.registry..destroy': function( ){
65 | 	this.constructor.storage( this.id(), null )
66 | 	var destroy = this['$jin.pool..destroy'] || this['$jin.klass..destroy']
67 | 	destroy.call( this )
68 | }})
69 | 
70 | /**
71 |  * Identifier as primitive representation.
72 |  * @name $jin.registry#toString
73 |  * @method toString
74 |  * @member $jin.registry
75 |  */
76 | $jin.method({ '$jin.registry..toString': function( ){
77 |     this['$jin.klass..toString']
78 |     return this.id()
79 | }})
80 | 


--------------------------------------------------------------------------------
/request/jin_request.env=node.jam.js:
--------------------------------------------------------------------------------
1 | $jin.request = function( options ){
2 |     return $jin.async2sync( function ( config , done ){
3 |         $node.request( config , function( error , resp , body ) {
4 |             if( resp ) resp.body = body
5 |             done( error , resp )
6 |         })
7 |     } )( options )
8 | }
9 | 


--------------------------------------------------------------------------------
/request/jin_request.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.request = function( options ){
 2 |     var xhr = new XMLHttpRequest
 3 | 	var body = options.body
 4 | 	if( $jin_type( body ) === 'Object' ){
 5 | 		var form = new FormData
 6 | 		for( var key in body ){
 7 | 			form.append( key, body[ key ] )
 8 | 		}
 9 | 		body = form
10 | 	}
11 | 	xhr.withCredentials = true
12 | 	if( options.responseType ) {
13 | 		xhr.responseType = options.responseType
14 | 	}
15 | 	xhr.open( options.method || 'GET', options.uri, !options.sync )
16 | 	if( options.headers ) {
17 | 		for( var name in options.headers ) {
18 | 			options.headers[ name].forEach( function( value ) {
19 | 				xhr.setRequestHeader( name , value )
20 | 			})
21 | 		}
22 | 	}
23 | 	if( options.sync ){
24 | 		if( options.type ) xhr.setRequestHeader( 'Content-Type', options.type )
25 | 		xhr.send( body )
26 | 		return xhr
27 | 	} else {
28 | 		var atom = new $jin.atom.prop({ name: '$jin.request:' + options.uri })
29 | 		if( options.type ) xhr.setRequestHeader( 'Content-Type', options.type )
30 | 		xhr.onload = function( ){
31 | 			atom.push( xhr )
32 | 		}
33 | 		xhr.onerror = function( ){
34 | 			atom.fail( xhr )
35 | 		}
36 | 		xhr.send( body )
37 | 		return atom
38 | 	}
39 | }
40 | 


--------------------------------------------------------------------------------
/request/request.ts:
--------------------------------------------------------------------------------
 1 | module $jin {
 2 |     export declare function request( options : {
 3 |         uri : string
 4 |         method? : string
 5 |         sync? : boolean
 6 |         type? : string
 7 |         headers? : { [index : string ] : string[] }
 8 |         body? : any
 9 |     }) : any
10 | }


--------------------------------------------------------------------------------
/root/jin_root.jam.js:
--------------------------------------------------------------------------------
1 | this.$jin.root = $jin.value( this )
2 | 


--------------------------------------------------------------------------------
/sample/demo/jin-sample-demo.css:
--------------------------------------------------------------------------------
 1 | [jin-sample-demo-list] {
 2 | 	width: 100%;
 3 | 	height: 100%;
 4 | 	box-sizing: border-box;
 5 | 	padding: 20px;
 6 | 	background: #fee;
 7 | 	line-height: 1;
 8 | 	overflow: auto;
 9 | }
10 | 
11 | [jin-sample-demo] {
12 | 	display: inline-block;
13 | 	box-sizing: border-box;
14 | 	border: 1px solid pink;
15 | 	background: #fee;
16 | 	vertical-align: top;
17 | 	margin-right: 2px;
18 | 	margin-bottom: 2px;
19 | }
20 | [jin-sample-demo]:last-child {
21 | 	margin-right: 0;
22 | 	margin-bottom: 0;
23 | }
24 | [jin-sample-demo]:hover {
25 | 	background-color: white;
26 | }
27 | [jin-sample-demo]:target {
28 | 	border-color: steelblue;
29 | }
30 | 
31 | [jin-sample-demo-size="wide"]{
32 | 	width: 50%;
33 | }
34 | 
35 | [jin-sample-demo-title] {
36 | 	display: block;
37 | 	border-bottom: 1px solid pink;
38 | 	padding: 0 .5em;
39 | 	font: bold 10px/1.5 sans-serif;
40 | }
41 | 
42 | [jin-sample-demo-content] {
43 | 	position: relative;
44 | 	z-index: 0;
45 | 	border: 20px solid #fee;
46 | 	background: white;
47 | }
48 | 
49 | [jin-sample-demo]:hover [jin-sample-demo-content] {
50 | 	border-color: white;
51 | }
52 | 
53 | [jin-sample-demo-size="fit"] > [jin-sample-demo-content] {
54 | 	display: inline-block;
55 | }
56 | 


--------------------------------------------------------------------------------
/sample/demo/jin-sample-demo.sample.html:
--------------------------------------------------------------------------------
 1 | <div jin-sample-demo-list="" id="{id}">
 2 | 	{items}
 3 | </div>
 4 | 
 5 | <div jin-sample-demo="" id="{title}"
 6 | 	jin-sample-demo-size="{size}"
 7 | 	>
 8 | 	<a jin-sample-demo-title="">
 9 | 		{title}
10 | 	</a>
11 | 	<div jin-sample-demo-content=""
12 | 		jin-sample-props="
13 | 			style.height=height
14 | 		"
15 | 		>
16 | 		{content}
17 | 	</div>
18 | </div>
19 | 


--------------------------------------------------------------------------------
/schedule/schedule.ts:
--------------------------------------------------------------------------------
 1 | module $jin {
 2 |     export class schedule {
 3 | 
 4 |         static _queue : $jin.defer[] = []
 5 | 
 6 |         _handler : () => void
 7 |         _timer : number
 8 | 
 9 |         constructor( timeout : number , handler : () => void ) {
10 |             this._handler = $jin.sync2async( handler )
11 |             this.start( timeout )
12 |         }
13 |         
14 |         isScheduled() {
15 |             return this._timer != null
16 |         }
17 |         
18 |         start( timeout : number ) {
19 |             if( this._timer ) return
20 |             this._timer = setTimeout( this._handler, timeout )
21 |         }
22 | 
23 |         stop( ) {
24 |             clearTimeout( this._timer )
25 |             this._timer = null
26 |         }
27 | 
28 |         destroy() {
29 |             this.stop()
30 |         }
31 |     }
32 | }


--------------------------------------------------------------------------------
/server/server.ts:
--------------------------------------------------------------------------------
1 | declare module $jin {
2 |     
3 |     export var server : any
4 |     
5 | }
6 | 


--------------------------------------------------------------------------------
/set/jin-set.css:
--------------------------------------------------------------------------------
1 | #jin-set {
2 | 	display: none;
3 | }
4 | 


--------------------------------------------------------------------------------
/set/jin-set.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.set
 3 |  * @class $jin.list
 4 |  * @returns $jin.list
 5 |  * @method set
 6 |  * @member $jin
 7 |  * @static
 8 |  */
 9 | $jin.method({ '$jin.set': function( ){
10 | 	var list = Array.apply( null, arguments )
11 | 	list.__proto__ = arguments.callee.prototype
12 | 	return list
13 | }})
14 | 
15 | $jin.glob( '$jin.set.', [] )
16 | 
17 | $jin.mixin({ '$jin.set': [ '$jin.list' ] })
18 | 


--------------------------------------------------------------------------------
/set/jin-set.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.list
 3 |  * @class $jin.list
 4 |  * @returns $jin.list
 5 |  */
 6 | $jin.glob( '$jin.set', function( ){
 7 | 	var iframe = document.createElement( 'iframe' )
 8 | 	iframe.id = 'jin-set'
 9 | 	document.body.appendChild( iframe )
10 | 	var Array = iframe.contentWindow.Array
11 | 	//document.body.removeChild( iframe )
12 | 	return Array
13 | }() )
14 | 
15 | $jin.mixin({ '$jin.set': [ '$jin.list' ] })
16 | 


--------------------------------------------------------------------------------
/set/set.ts:
--------------------------------------------------------------------------------
1 | declare module $jin {
2 |     
3 |     export function set() : any[]
4 |     
5 | }


--------------------------------------------------------------------------------
/sleep/jin_sleep.env=node.jam.js:
--------------------------------------------------------------------------------
1 | $jin.sleep = $jin.async2sync( function $jin_sleep( delay, done ){
2 |     setTimeout( done, delay )
3 | } )
4 | 


--------------------------------------------------------------------------------
/slide/jin-slide.css:
--------------------------------------------------------------------------------
  1 | [jin-slide] {
  2 |     font: 1em/1.25 'Cambria', serif;
  3 | 	color: black;
  4 | 	position: absolute;
  5 | 	left: 0;
  6 | 	top: 0;
  7 | 	right: 0;
  8 | 	bottom: 0;
  9 | 	overflow: auto;
 10 | 	display: flex;
 11 | 	justify-content: space-around;
 12 | 	align-items: center;
 13 | 	background: #ddd;
 14 | }
 15 | 
 16 | @-webkit-keyframes jin-slide-page
 17 | {
 18 | 	from {
 19 | 		-webkit-transform: translateY( -10% );
 20 | 	}
 21 | }
 22 | 
 23 | @keyframes jin-slide-page
 24 | {
 25 | 	from {
 26 | 		transform: translateY( -10% );
 27 | 	}
 28 | }
 29 | 
 30 | [jin-slide-page] {
 31 | 	background: white;
 32 | 	box-shadow: 0 0 6px rgba( 0, 0, 0, .5 );
 33 | 	padding: .5em 1em;
 34 | 	display: flex;
 35 | 	flex-flow: column;
 36 | 	justify-content: center;
 37 | 	-webkit-animation: jin-slide-page .25s;
 38 | 	animation: jin-slide-page .25s;
 39 | 	position: relative;
 40 | 	-webkit-transform: translateY( 1% );
 41 | 	transform: translateY( 1% );
 42 | }
 43 | 
 44 | [jin-slide-show-header] {
 45 | 	/*background: yellow;*/
 46 | 	display: flex;
 47 | 	justify-content: center;
 48 | 	flex-shrink: 0;
 49 | }
 50 | 
 51 | [jin-slide-show-content] {
 52 | 	/*background: pink;*/
 53 | 	display: flex;
 54 | 	justify-content: center;
 55 | }
 56 | 
 57 | [jin-slide-page] h {
 58 | 	/*background: lime;*/
 59 | 	text-align: center;
 60 | 	font-size: 2em;
 61 | 	display: inline-block;
 62 | 	overflow: hidden;
 63 | 	font-weight: normal;
 64 | 	padding: .25em;
 65 | 	margin: 0;
 66 | }
 67 | 
 68 | [jin-slide-page] pre {
 69 | 	margin: 0;
 70 | 	padding: .5em;
 71 | }
 72 | 
 73 | [jin-slide-page] p {
 74 | 	margin: 0;
 75 | 	padding: .5em;
 76 | }
 77 | 
 78 | [jin-slide-page] ol {
 79 | 	list-style-position: inside;
 80 | }
 81 | 
 82 | [jin-slide-page] ul {
 83 | 	list-style: none;
 84 | 	margin: 0;
 85 | 	padding: .5em;
 86 | }
 87 | 
 88 | [jin-slide-page] a {
 89 | 	text-decoration: none;
 90 | 	color: steelblue;
 91 | }
 92 | 
 93 | [jin-slide-page] a:hover {
 94 | 	text-decoration: underline;
 95 | }
 96 | 
 97 | [jin-slide-show-figure] {
 98 | 	margin: .5em;
 99 | }
100 | 
101 | [jin-slide-show-figure-descr] {
102 | 	text-align: center;
103 | }
104 | 
105 | [jin-slide-row] {
106 | 	display: flex;
107 | 	justify-content: center;
108 | 	flex-flow: row;
109 | 	padding: .5em;
110 | 	margin: 0;
111 | }
112 | 
113 | [jin-slide-col] {
114 | 	display: flex;
115 | 	justify-content: flex-start;
116 | 	flex-flow: column;
117 | 	padding: .5em;
118 | 	margin: 0;
119 | }
120 | 
121 | 


--------------------------------------------------------------------------------
/slide/jin-slide.sample.html:
--------------------------------------------------------------------------------
 1 | <div jin-slide="{id}"
 2 | 	jin-sample-props="
 3 | 		style.zoom=zoom
 4 | 	"
 5 | 	jin-sample-events="
 6 | 		onwheel=onWheel
 7 | 		onkeydown=onPress
 8 | 	"
 9 | 	tabindex="0"
10 | 	>
11 | 	{pageNodeCurrent}
12 | </div>
13 | 


--------------------------------------------------------------------------------
/socket/socket.ts:
--------------------------------------------------------------------------------
 1 | module $jin {
 2 |     export class socket extends $jin.model < $jin.object<any> > {
 3 | 
 4 |         NativeSocket() {
 5 |             return new $jin.prop.vary<WebSocket,$jin.socket>({
 6 |                 owner : this,
 7 |                 name : 'nativeSocket',
 8 |                 pull : atom => {
 9 | 
10 |                     var socket = new WebSocket( location.protocol.replace( 'http' , 'ws' ) + '//' + location.host, 'jin-server' )
11 | 
12 |                     socket.onopen = $jin.defer.callback( () => {
13 |                         atom.owner.IsOnLine().push( true )
14 |                     } )
15 |                     socket.onclose = $jin.defer.callback( () => {
16 | 						atom.owner.IsOnLine().clear()
17 | 						atom.owner.NativeSocket().pull()
18 |                     } )
19 |                     socket.onmessage = $jin.defer.callback( ( event ) => {
20 |                         var message = JSON.parse( event.data )
21 |                         if( message.requestId && atom.owner[ message.requestId ] ) {
22 | 							atom.owner[ message.requestId ].push( message )
23 |                         }
24 | 						atom.owner.LastMessage().push( message )
25 |                     } )
26 | 
27 |                     return socket
28 |                 }
29 |             })
30 |         }
31 | 
32 |         IsOnLine() {
33 |             return new $jin.atom.prop<boolean,$jin.socket>({
34 |                 owner: this,
35 |                 name: 'isOnLine',
36 |                 pull: atom => {
37 |                     return atom.owner.NativeSocket().get().readyState === WebSocket.OPEN ? true : undefined
38 |                 }
39 |             })
40 |         }
41 | 
42 |         LastMessage() {
43 |             return new $jin.atom.prop<any,$jin.socket>({
44 |                 owner: this,
45 |                 name: 'lastMessage',
46 |                 pull: atom => {
47 |                     atom.owner.NativeSocket().get()
48 |                     return null
49 |                 }
50 |             })
51 |         }
52 | 
53 |         send( message ) {
54 | 
55 |             var promise = new $jin.atom.prop({
56 |                 owner : this
57 |             })
58 | 
59 |             message.requestId = promise.name
60 | 
61 |             this.IsOnLine().then( () => {
62 |                 this.NativeSocket().get().send( JSON.stringify( message , null , '\t' ) )
63 |             })
64 | 
65 |             return promise
66 |         }
67 | 
68 |     }
69 | }


--------------------------------------------------------------------------------
/state/local/jin_state_local.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.state.local
 3 |  * @class $jin.state.local
 4 |  * @returns $jin.state.local
 5 |  * @mixins $jin.klass
 6 |  */
 7 | $jin.klass({ '$jin.state.local': [] })
 8 | 
 9 | $jin.atom1.prop( '$jin.state.local.storage',
10 | {   pull: function( ){
11 |         return window.localStorage || {}
12 |     }
13 | } )
14 | 
15 | $jin.atom1.prop( '$jin.state.local.listener',
16 | {   pull: function( ){
17 |         var context = this
18 |         return $jin.dom( window ).listen( 'storage', function( event ){
19 | 			event = $jin.dom.event( event )
20 |             var key = event.nativeEvent().key
21 |             if( key ){
22 |                 context.item.atom( context, key ).pull()
23 |             } else {
24 |                 var hash = context.item.atomHash( context )
25 |                 for( var key in hash ){
26 |                     hash[ key ].pull()
27 |                 }
28 |             }
29 |         } )
30 |     }
31 | } )
32 | 
33 | $jin.atom1.prop.hash( '$jin.state.local.item',
34 | {   pull: function( key ){
35 |         this.listener()
36 |         var val = this.storage()[ key ]
37 |         return ( val == null ) ? null : val
38 |     }
39 | ,   put: function( key, value ){
40 |         
41 |         if( value == null ){
42 |             delete this.storage()[ key ]
43 |         } else {
44 | 	        value = this.storage()[ key ] = String( value )
45 | 		}
46 |         
47 |         this.item.atom( this, key ).update()
48 |         
49 |         return value
50 |     }
51 | } )
52 | 


--------------------------------------------------------------------------------
/storage/jin_storage.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.storage
 3 |  * @class $jin.storage
 4 |  * @returns $jin.storage
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.registry
 7 |  * @mixins $jin.uri
 8 |  */
 9 | $jin.klass({ '$jin.storage': [ '$jin.registry', '$jin.uri' ] })
10 | 
11 | /**
12 |  * @name $jin.storage#toString
13 |  * @method toString
14 |  * @member $jin.storage
15 |  */
16 | $jin.method({ '$jin.storage..toString': function( ){
17 |     this['$jin.registry..toString']
18 |     return this['$jin.uri..toString']()
19 | }})
20 | 


--------------------------------------------------------------------------------
/storage/mongo/jin_storage_mongo.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.storage.mongo
 3 |  * @class $jin.storage.mongo
 4 |  * @returns $jin.storage.mongo
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.storage
 7 |  */
 8 | $jin.klass({ '$jin.storage.mongo': [ '$jin.storage' ] })
 9 | 
10 | /**
11 |  * @name $jin.storage.mongo#driver
12 |  * @method driver
13 |  * @member $jin.storage.mongo
14 |  */
15 | $jin.property({ '$jin.storage.mongo..driver': function( ){
16 |     return $jin.async2sync( $node.mongodb.MongoClient.connect )( this + '' )
17 | }})
18 | 
19 | /**
20 |  * @name $jin.storage.mongo#collection
21 |  * @method collection
22 |  * @member $jin.storage.mongo
23 |  */
24 | $jin.method({ '$jin.storage.mongo..collection': function( name ){
25 |     return $jin.storage.mongo.collection( this.driver.collection( name ) )
26 | }})
27 | 


--------------------------------------------------------------------------------
/support/jin_support.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.support.xmlModel
 3 |  * @method xmlModel
 4 |  * @static
 5 |  * @member $jin.support
 6 |  */
 7 | $jin.property({ '$jin.support.xmlModel': function( ){
 8 |     return ( window.DOMParser && window.XMLSerializer && window.XSLTProcessor ) ? 'w3c' : 'ms'
 9 | }})
10 | 
11 | /**
12 |  * @name $jin.support.htmlModel
13 |  * @method htmlModel
14 |  * @static
15 |  * @member $jin.support
16 |  */
17 | $jin.property({ '$jin.support.htmlModel': function( ){
18 |     return document.createElement( 'html:div' ).namespaceURI !== void 0 ? 'w3c' : 'ms'
19 | }})
20 | 
21 | /**
22 |  * @name $jin.support.eventModel
23 |  * @method eventModel
24 |  * @static
25 |  * @member $jin.support
26 |  */
27 | $jin.property({ '$jin.support.eventModel': function( ){
28 |     return ( 'addEventListener' in document.createElement( 'div' ) ) ? 'w3c' : 'ms'
29 | }})
30 | 
31 | /**
32 |  * @name $jin.support.textModel
33 |  * @method textModel
34 |  * @static
35 |  * @member $jin.support
36 |  */
37 | $jin.property({ '$jin.support.textModel': function( ){
38 |     return ( 'createRange' in document ) ? 'w3c' : 'ms'
39 | }})
40 | 


--------------------------------------------------------------------------------
/sync/sync.ts:
--------------------------------------------------------------------------------
1 | module $jin.sync {
2 |     export var promise = $jin.async2sync( ( promise , done ) => {
3 |         promise.then( result => done( null ,result ) , done )
4 |     } )
5 | }
6 | 


--------------------------------------------------------------------------------
/sync2async/jin_sync2async.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | this.$jin.sync2async= function( func ){
 2 | 	return function( ) {
 3 | 		var self = this
 4 | 		var args = arguments
 5 | 		
 6 | 		if( args.length > func.length ){
 7 | 			var callback= [].pop.call( args )
 8 | 		}
 9 | 
10 | 		if( !callback ) callback = function( error ){
11 | 			if( !error ) return
12 | 			$jin.log.error( error )
13 | 			process.exit( 1 )
14 | 		}
15 | 
16 | 		var proc= function( ){
17 | 			try {
18 | 				var result= func.apply( self, args )
19 | 			} catch( err ){
20 | 				var error= err
21 | 			}
22 | 			callback( error, result )
23 | 		}
24 | 
25 | 		var fibers= $node.fibers
26 | 
27 | 		//if( fibers.current ) proc()
28 | 		//else
29 | 		fibers( proc ).run()
30 | 	}
31 | }
32 | 
33 | //$jin.proxy( { apply: function( func, self, args ){
34 | //    if( args.length > func.length ){
35 | //        var callback= [].pop.call( args )
36 | //    }
37 | //    
38 | //    if( !callback ) callback = function( error ){
39 | //        if( !error ) return
40 | //        $jin.log.error( error )
41 | //        process.exit( 1 )
42 | //    }
43 | //    
44 | //    var proc= function( ){
45 | //        try {
46 | //            var result= func.apply( self, args )
47 | //        } catch( err ){
48 | //            var error= err
49 | //        }
50 | //        callback( error, result )
51 | //    }
52 | //    
53 | //    var fibers= $node.fibers
54 | //    
55 | //    if( fibers.current ) proc()
56 | //    else fibers( proc ).run()
57 | //} } )
58 | 


--------------------------------------------------------------------------------
/sync2async/jin_sync2async.env=web.jam.js:
--------------------------------------------------------------------------------
1 | this.$jin.sync2async= function( func ){
2 | 	return func
3 | }
4 | 


--------------------------------------------------------------------------------
/sync2async/sync2async.ts:
--------------------------------------------------------------------------------
1 | declare module $jin {
2 |     export function sync2async( handler )
3 | }


--------------------------------------------------------------------------------
/sync2middle/jin_sync2middle.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | this.$jin.sync2middle = function( func ){
 2 | 
 3 |     return function( req, res, next ) {
 4 | 
 5 |         var thread = $jin.sync2async( func )
 6 | 
 7 |         thread( req, res, function jin_sync2middle_thread( error, result ){
 8 | 			
 9 |             if( error ){
10 |                 next( error )
11 |             } else if( result == null ){
12 |                 next()
13 |             } else {
14 |                 res.setHeader( 'Cache-Control', result.cache || 'no-cache,no-store' )
15 |                 if( result.location ) {
16 |                     res.setHeader( 'Location', result.location )
17 |                 }
18 |                 res.type( result.type || '.txt' )
19 | 	            if( result.cookies ) {
20 | 		            result.cookies.forEach( function( cookie ){
21 | 			            res.cookie( cookie.name, cookie.value, cookie )
22 | 		            } )
23 | 	            }
24 |                 res.status({
25 |                     ok : 200,
26 |                     go : 301,
27 |                     see : 303,
28 |                     wrong : 400,
29 |                     forbidden : 403,
30 |                     absent : 404,
31 |                     exception : 500
32 |                 }[ result.status || 'ok' ])
33 |                 res.send( String( result.content ) )
34 |             }
35 |             
36 |         } )
37 |         
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/sync2middle/sync2middle.ts:
--------------------------------------------------------------------------------
1 | declare module $jin {
2 | 
3 |     export var sync2middle : any
4 | 
5 | }


--------------------------------------------------------------------------------
/test/jin-mixin-tests.stage=dev.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.test( function mixin_anonymous( test ){
 2 | 	var root = {
 3 | 		foo: {
 4 | 			bar: function(){ }
 5 | 		}
 6 | 	}
 7 | 	
 8 | 	var mock = test.mock( '$jin.root', $jin.value( root ) )
 9 | 	
10 | 	$jin.mixin.object({ 'bom': [ 'foo' ] })
11 | 	
12 | 	test.equal( root.bom.bar, root.foo.bar ) 
13 | })
14 | 
15 | 


--------------------------------------------------------------------------------
/test/test.ts:
--------------------------------------------------------------------------------
 1 | declare module $jin {
 2 |     interface testClass {
 3 |         timeout( period : number );
 4 |         done( value : boolean );
 5 |         fail( );
 6 |         ok<Type>( value : Type );
 7 |         not<Type>( value : Type );
 8 |         equal<Type>( left : Type , right : Type );
 9 |         unique<Type>( left : Type , right : Type );
10 |         callback( handler : () => void );
11 |         mock<Type>( path : string , value : Type );
12 |     }
13 |     export function test ( script : ( test : testClass ) => void ) : void
14 |     export function test ( config : { [ index: string ] : ( test : testClass ) => void } ) : void
15 | }
16 | 


--------------------------------------------------------------------------------
/test2/test.stage=dev.ts:
--------------------------------------------------------------------------------
1 | new $jin_test2( test => {
2 | 	test.ok( 1 )
3 | })


--------------------------------------------------------------------------------
/test2/test.ts:
--------------------------------------------------------------------------------
 1 | class $jin_test2 {
 2 | 	
 3 | 	static all = []
 4 | 	
 5 | 	static run() {
 6 | 		for( var test of this.all ) {
 7 | 			test.run()
 8 | 		}
 9 | 	}
10 | 	
11 | 	code : { ( test : $jin_test2 ) : void }
12 | 	status = 'wait'
13 | 	
14 | 	constructor( code : string | { ( test : $jin_test2 ) : void } ) {
15 | 		if( typeof code === 'string' ) {
16 | 			this.code = <any> new Function( 'test' , code )
17 | 		} else {
18 | 			this.code = code
19 | 		}
20 | 		$jin_test2.all.push( this )
21 | 	}
22 | 	
23 | 	run() {
24 | 		this.code.call( null , this )
25 | 	}
26 | 	
27 | 	done() {
28 | 		
29 | 	}
30 | 	
31 | 	ok( value ) {
32 | 		if( value ) return
33 | 		throw new Error( `Not true (${value})` )
34 | 	}
35 | 	
36 | 	not( value ) {
37 | 		if( !value ) return
38 | 		throw new Error( `Not false (${value})` )
39 | 	}
40 | 	
41 | 	fail( message ) {
42 | 		throw new Error( message )
43 | 	}
44 | 	
45 | 	equal( a , b ) {
46 | 		if( a === b ) return 
47 | 		throw new Error( `Not equal (${a},${b})` )
48 | 	}
49 | 	
50 | 	unique( a , b ) {
51 | 		if( a !== b ) return
52 | 		throw new Error( `Not unique (${a},${b})` )
53 | 	}
54 | 	
55 | }
56 | 


--------------------------------------------------------------------------------
/thread/jin_thread.doc.xml:
--------------------------------------------------------------------------------
 1 | <?xml-stylesheet href="../-mix/doc.stage=dev.xsl" type="text/xsl"?>
 2 | <doc_root
 3 |     doc_title="$jin_thread"
 4 |     >
 5 | 
 6 |     <p>Создаёт обёртку вокруг функции, которая выполняет её в отдельном, но синхронном потоке.</p>
 7 | 
 8 |     <p>
 9 |         <script type="wc_test">
10 |             test.ok( $jin_thread )
11 |         </script>
12 |         <script type="wc_test">
13 |             var thread= $jin_thread(function(){
14 |                 return 123
15 |             })
16 |             test.ok( thread(), 123 )
17 |         </script>
18 |         <script type="wc_test">
19 |             var thread= $jin_thread(function(){
20 |                 throw new Error( 'sample error' )
21 |             })
22 |             test.ok( thread(), void 0 )
23 |         </script>
24 |         <script type="wc_test">
25 |             var fact= $jin_thread(function( n ){
26 |                 if (!( n > 1 )) return 1;
27 |                 return n * fact( n - 1 );
28 |             });
29 |             test.ok( fact(5), 120 )
30 |         </script>
31 |     </p>
32 | 
33 | </doc_root>
34 | 


--------------------------------------------------------------------------------
/thread/jin_thread.env=node.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.thread
 3 |  * @method thread
 4 |  * @static
 5 |  * @member $jin
 6 |  */
 7 | $jin.method({ '$jin.thread': function( proc ){
 8 |     return function $jin_thread_wrapper( ){
 9 |         try {
10 |             proc.apply( this, arguments )
11 |         } catch( error ){
12 |             $jin.log.error( error )
13 |         }
14 |     }
15 | }})
16 | 


--------------------------------------------------------------------------------
/thread/jin_thread.env=web.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.thread
 3 |  * @method thread
 4 |  * @static
 5 |  * @member $jin
 6 |  */
 7 | $jin.method({ '$jin.thread': function( proc ){
 8 |     return function $jin_thread_wrapper( ){
 9 |         var self= this
10 |         var args= arguments
11 |         var res
12 |         
13 |         var id= $jin.makeId( '$jin.thread' )
14 |         var launcher = function $jin_thread_launcher( event ){
15 |             res= proc.apply( self, args )
16 |         }
17 |         
18 | 		if( $jin.support.eventModel() === 'w3c' ){
19 | 			window.addEventListener( id, launcher, false )
20 | 				var event= document.createEvent( 'Event' )
21 | 				event.initEvent( id, false, false )
22 | 				window.dispatchEvent( event )
23 | 			window.removeEventListener( id, launcher, false )
24 | 		} else {
25 | 			try {
26 | 				launcher()
27 | 			} catch( error ){
28 | 				$jin.log.error( error )
29 | 			}
30 | 		}
31 |         
32 |         return res
33 |     }
34 | }})
35 | 
36 | 


--------------------------------------------------------------------------------
/throttle/jin_throttle.jam.js:
--------------------------------------------------------------------------------
 1 | this.$jin.throttle=
 2 | function( timeout, func ){
 3 |     var timer = null
 4 |     return function( ){
 5 |         if( timer ) timer = clearTimeout( timer )
 6 |         
 7 |         var self = this
 8 |         var args = arguments
 9 |         
10 |         timer = setTimeout( function( ){
11 |             func.apply( self, args )
12 |         }, timeout )
13 |     }
14 | }
15 | 
16 | 


--------------------------------------------------------------------------------
/time/base/base.ts:
--------------------------------------------------------------------------------
 1 | module $jin.time {
 2 | 
 3 | 	export class base_class {
 4 | 
 5 | 		static patterns : any = {}
 6 | 
 7 | 		static formatter( pattern : string ) {
 8 | 			if( this.patterns[ pattern ] ) return this.patterns[ pattern ]
 9 | 
10 | 			var tokens = Object.keys( this.patterns )
11 | 				.sort()
12 | 				.reverse()
13 | 				.map( ( token : string ) => token.replace( /([-+*.\[\]()\^])/g , '\\$1' ) )
14 | 			var lexer = RegExp( '(.*?)(' + tokens.join( '|' ) + '|$)', 'g' )
15 | 
16 | 			var funcs : any[] = []
17 | 
18 | 			pattern.replace( lexer, ( str : string , text : string , token : string ) => {
19 | 				if( text ) funcs.push( () => text )
20 | 				if( token ) funcs.push( this.patterns[ token ] )
21 | 				return str
22 | 			})
23 | 
24 | 			return this.patterns[ pattern ] = $jin.concater( funcs )
25 | 		}
26 | 
27 | 		toString( pattern : string ) {
28 | 			var Base = <typeof base_class>this.constructor
29 | 			var formatter = Base.formatter( pattern )
30 | 			return formatter.call( Base , this )
31 | 		}
32 | 
33 | 	}
34 | 
35 | }
36 | 


--------------------------------------------------------------------------------
/time/duration/duration_tests.stage=dev.ts:
--------------------------------------------------------------------------------
 1 | module $ {
 2 | 	$mol_test( {
 3 | 		
 4 | 		'parse and serial'() {
 5 | 			$mol_assert_equal( $jin.time.duration( 'P42.1Y' ).toString() , 'P42.1YT' )
 6 | 			$mol_assert_equal( $jin.time.duration( 'P42.1M' ).toString() , 'P42.1MT' )
 7 | 			$mol_assert_equal( $jin.time.duration( 'P42.1D' ).toString() , 'P42.1DT' )
 8 | 			$mol_assert_equal( $jin.time.duration( 'PT42.1h' ).toString() , 'PT42.1H' )
 9 | 			$mol_assert_equal( $jin.time.duration( 'PT42.1m' ).toString() , 'PT42.1M' )
10 | 			$mol_assert_equal( $jin.time.duration( 'PT42.1s' ).toString() , 'PT42.1S' )
11 | 			$mol_assert_equal( $jin.time.duration( 'P1Y2M3DT4h5m6.7s' ).toString() , 'P1Y2M3DT4H5M6.7S' )
12 | 		} ,
13 | 		
14 | 		'format typed'() {
15 | 			$mol_assert_equal(
16 | 				$jin.time.duration( 'P1Y2M3DT4h5m6s' ).toString( 'P#Y#M#DT#h#m#s' ) ,
17 | 				'P1Y2M3DT4H5M6S'
18 | 			)
19 | 		} ,
20 | 	
21 | 	} )
22 | }
23 | 


--------------------------------------------------------------------------------
/time/range/range_tests.stage=dev.ts:
--------------------------------------------------------------------------------
 1 | module $ {
 2 | 	$mol_test( {
 3 | 		
 4 | 		'triplets'() {
 5 | 			$mol_assert_equal(
 6 | 				$jin.time.range( '2015-01-01/P1M' ).end.toString() ,
 7 | 				'2015-02-01'
 8 | 			)
 9 | 			$mol_assert_equal(
10 | 				$jin.time.range( 'P1M/2015-02-01' ).start.toString() ,
11 | 				'2015-01-01'
12 | 			)
13 | 			$mol_assert_equal(
14 | 				$jin.time.range( '2015-01-01/2015-02-01' ).duration.toString() ,
15 | 				'PT2678400S'
16 | 			)
17 | 		}
18 | 		
19 | 	} )
20 | }
21 | 


--------------------------------------------------------------------------------
/time1/format/format.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Generator of date-formatters.
 3 |  * Date-formatter is a function that returns string representation of a date.
 4 |  *
 5 |  * 0 params: hash-table of all patterns
 6 |  * 1 param: return date-formatter by pattern
 7 |  * 2 params: assign date-formatter for pattern
 8 |  *
 9 |  * Mnemonics:
10 |  *
11 |  *  * single letter for numbers: M - month number, D - day of month.
12 |  *  * uppercase letters for dates, lowercase for times: M - month number , m - minutes number
13 |  *  * repeated letters for define register count: YYYY - full year, YY - shot year, MM - padded month number
14 |  *  * words, same letter case: Month - localized capitalized month name
15 |  *  * shortcuts: WD - short day of week, Mon - short month name.
16 |  *  * special identifiers: iso8601, stamp.
17 |  *
18 |  * Complex patterns splits by words and then substitute by date-formatters for short patterns
19 |  * For localize output override $jin.l10n( scope, text )
20 |  *
21 |  * Typical usage:
22 |  *     var formatTime = $jin.time1.format( 'Weekday, YYYY-MM-DD hh:mm' )
23 |  *     formatTime( $jin.time1.moment() )
24 |  *
25 |  * @name $jin.time1.format
26 |  * @method format
27 |  * @member $jin.time
28 |  * @param {string} [pattern]
29 |  * @param {function( $jin.date )} [formatter]
30 |  * @static
31 |  */
32 | $jin.property.hash({ '$jin.time1.format': { pull: function( pattern ) {
33 | 
34 | 	var lexems = $jin.time1.format()
35 | 	var patterns = Object.keys( lexems )
36 | 	patterns.sort()
37 | 	patterns.reverse()
38 | 
39 | 	var funcs = []
40 | 
41 | 	var lexer = RegExp( '(.*?)(' + patterns.join( '|' ) + '|$)', 'g' )
42 | 	pattern.replace( lexer, function( str, text, token ){
43 | 		if( text ) funcs.push( function(){ return text } )
44 | 		if( token ) funcs.push( lexems[ token ] )
45 | 	})
46 | 
47 | 	return $jin.concater( funcs )
48 | }}})
49 | 


--------------------------------------------------------------------------------
/time1/period/period_patterns.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.time1.format( '#Y', function( period ){
 2 | 	return period.years() + 'Y'
 3 | })
 4 | 
 5 | $jin.time1.format( '#M', function( period ){
 6 | 	return period.months() + 'M'
 7 | })
 8 | 
 9 | $jin.time1.format( '#D', function( period ){
10 | 	return period.days() + 'D'
11 | })
12 | 
13 | $jin.time1.format( '#h', function( period ){
14 | 	return period.hours() + 'H'
15 | })
16 | 
17 | $jin.time1.format( '#m', function( period ){
18 | 	return period.minutes() + 'M'
19 | })
20 | 
21 | $jin.time1.format( '#s', function( period ){
22 | 	return period.seconds() + 'S'
23 | })
24 | 
25 | 
26 | $jin.time1.format( '# years', function( count ){
27 | 	return $jin.l10n.plural( '$jin.time1.format:years', count )
28 | })
29 | 


--------------------------------------------------------------------------------
/time1/period/period_tests.stage=dev.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.test( function parse_n_serial( test ){
 2 | 	test.equal( $jin.time1.period( 'P42.1Y' ).toString(), 'P42.1Y' )
 3 | 	test.equal( $jin.time1.period( 'P42.1M' ).toString(), 'P42.1M' )
 4 | 	test.equal( $jin.time1.period( 'P42.1D' ).toString(), 'P42.1D' )
 5 | 	test.equal( $jin.time1.period( 'PT42.1h' ).toString(), 'PT42.1H' )
 6 | 	test.equal( $jin.time1.period( 'PT42.1m' ).toString(), 'PT42.1M' )
 7 | 	test.equal( $jin.time1.period( 'PT42.1s' ).toString(), 'PT42.1S' )
 8 | 	test.equal( $jin.time1.period( 'P1Y2M3DT4h5m6.7s' ).toString(), 'P1Y2M3DT4H5M6.7S' )
 9 | })
10 | 
11 | $jin.test( function format_typed( test ){
12 | 	var formatPeriod = $jin.time1.format( 'P#Y#M#DT#h#m#s' )
13 | 	var period = $jin.time1.period( 'P1Y2M3DT4h5m6s' )
14 | 	var str = formatPeriod( period )
15 | 	test.equal( str, 'P1Y2M3DT4H5M6S' )
16 | } )
17 | 


--------------------------------------------------------------------------------
/time1/range/time-range.jam.js:
--------------------------------------------------------------------------------
 1 | $jin.klass({ '$jin.time1.range': [] })
 2 | 
 3 | $jin.method({ '$jin.time1.range.exec': function( range ){
 4 |     switch( $jin_type( range ) ){
 5 |         case 'Object':
 6 |             if( range instanceof this ) return range;
 7 |             return this['$jin.klass.exec']([
 8 |                 range.from,
 9 |                 range.to
10 |             ])
11 |         case 'String':
12 |             range = range.split( '/' )
13 |         case 'Array':
14 |             return this['$jin.klass.exec']({ from : range[0] , to : range[1] })
15 |         default:
16 |             throw new Error( 'Wrong type of time range (' + $jin_type( range ) + ')' )
17 |     }
18 | }})
19 | 
20 | $jin.method({ '$jin.time1.range..toString': function(){
21 |     return this.from().toString() + '/' + this.to().toString()
22 | }})
23 | 
24 | $jin.method({ '$jin.time1.range..toJSON': function( ){
25 |     return this.toString()
26 | }})
27 | 
28 | $jin.property({ '$jin.time1.range..from': $jin.time1.moment })
29 | 
30 | $jin.property({ '$jin.time1.range..to': $jin.time1.moment })
31 | 


--------------------------------------------------------------------------------
/time1/time.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.time1.exec
 3 |  * @method exec
 4 |  * @member $jin.time
 5 |  * @static
 6 |  */
 7 | $jin.method({ '$jin.time1.exec': function( time ){
 8 | 	if( !arguments.length ) return $jin.time1.moment()
 9 | 	switch( $jin_type( time ) ){
10 | 		case 'Number':
11 | 		case 'Date':
12 | 			return $jin.time1.moment( time )
13 | 		case 'String':
14 | 			if( /^[P+-]/i.test( time ) ) return $jin.time1.period( time )
15 | 			return $jin.time1.moment( time )
16 | 		default:
17 | 			throw new Error( 'Wrong type of time (' + $jin_type( time ) + ')' )
18 | 	}
19 | }})
20 | 


--------------------------------------------------------------------------------
/time1/time.ts:
--------------------------------------------------------------------------------
1 | module $jin {
2 |     export declare var time1 : any
3 | }
4 | 


--------------------------------------------------------------------------------
/trade/jin-trade-legend-item.css:
--------------------------------------------------------------------------------
1 | [jin-trade-legend-item] {
2 | 	font: 20px/1.5 'Segoe UI', sans-serif;
3 | }
4 | 


--------------------------------------------------------------------------------
/trade/jin-trade-legend-item.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.trade.legend.item
 3 |  * @class $jin.trade.legend.item
 4 |  * @returns $jin.trade.legend.item
 5 |  * @mixins $jin.klass
 6 |  * @mixins $jin.view
 7 |  */
 8 | $jin.klass({ '$jin.trade.legend.item': [ '$jin.view' ] })
 9 | 
10 | /**
11 |  * @name $jin.trade.legend.item#name
12 |  * @method name
13 |  * @member $jin.trade.legend.item
14 |  */
15 | $jin.atom1.prop({ '$jin.trade.legend.item..name': {} })
16 | 
17 | /**
18 |  * @name $jin.trade.legend.item#color
19 |  * @method color
20 |  * @member $jin.trade.legend.item
21 |  */
22 | $jin.atom1.prop({ '$jin.trade.legend.item..color': {} })
23 | 
24 | /**
25 |  * @name $jin.trade.legend.item#isActive
26 |  * @method isActive
27 |  * @member $jin.trade.legend.item
28 |  */
29 | $jin.atom1.prop({ '$jin.trade.legend.item..isActive': {
30 | 	pull: function( ){
31 | 		return true
32 | 	}
33 | } })
34 | 


--------------------------------------------------------------------------------
/trade/jin-trade-legend-item.sample.html:
--------------------------------------------------------------------------------
 1 | <label jin-trade-legend-item="{id}">
 2 | 	<!--<input jin-trade-legend-item-activator=""
 3 | 		type="checkbox"
 4 | 		jin-sample-props="
 5 | 			checked=isActive
 6 | 		"
 7 | 	/>-->
 8 | 	<span jin-trade-legend-item-name=""
 9 | 		jin-sample-props="
10 | 			style.color=color
11 | 		"
12 | 		>
13 | 		{name}
14 | 	</span>
15 | </label>
16 | 


--------------------------------------------------------------------------------
/trade/jin-trade.css:
--------------------------------------------------------------------------------
 1 | [jin-trade] {
 2 | 	width: 100%;
 3 | 	height: 100%;
 4 | 	background: #eee;
 5 | 	box-sizing: border-box;
 6 | 	display: flex;
 7 | 	padding: 2%;
 8 | }
 9 | 
10 | [jin-trade-graph] {
11 | 	flex: 1 1 auto;
12 | 	background: white;
13 | 	box-shadow: 0 0 6px rgba( 0, 0, 0, .5 );
14 | 	display: flex;
15 | 	align-items: center;
16 | 	justify-content: center;
17 | 	font: 20px/1 'Segoe UI', sans-serif;
18 | }
19 | 
20 | [jin-trade-controls] {
21 | 	margin-left: 2%;
22 | 	flex: 0 0 auto;
23 | }
24 | 
25 | [jin-trade-field] {
26 | 	display: block;
27 | 	white-space: nowrap;
28 | 	font: 20px/1.5 'Segoe UI', sans-serif;
29 | 	text-align: right;
30 | }
31 | 
32 | [jin-trade-field]:before {
33 | 	content: attr( jin-trade-field ) ":";
34 | }
35 | 
36 | [jin-trade-legend] {
37 | 	display: flex;
38 | 	flex-direction: column;
39 | }
40 | 


--------------------------------------------------------------------------------
/trade/jin-trade.demo.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <head>
 3 | 	<meta charset="utf-8" />
 4 | 	
 5 | 	<style>
 6 | 		html, body {
 7 | 			padding: 0;
 8 | 			margin: 0;
 9 | 			width: 100%;
10 | 			height: 100%;
11 | 		}
12 | 	</style>
13 | 	
14 | 	<link href="-mix/index.env=web.stage=dev.css" rel="stylesheet" />
15 | 	
16 | </head>
17 | <body>
18 | 	
19 | 	<script src="-mix/index.env=web.stage=dev.js"></script>
20 | 	
21 | 	<script>
22 | 		$jin.trade( 'jin-trade-demo' ).element().parent( document.body )
23 | 	</script>
24 | 	
25 | </body>
26 | 


--------------------------------------------------------------------------------
/trade/jin-trade.sample.html:
--------------------------------------------------------------------------------
 1 | <div jin-trade="{id}">
 2 | 	<div jin-trade-graph="">{graph}</div>
 3 | 	<div jin-trade-controls="">
 4 | 		<label jin-trade-field="startBTC">
 5 | 			<input
 6 | 				type="number"
 7 | 				jin-sample-props="
 8 | 					value=startBTC
 9 | 				"
10 | 			/>
11 | 		</label>
12 | 		<label jin-trade-field="fees">
13 | 			<input
14 | 				type="number"
15 | 				jin-sample-props="
16 | 					value=fees
17 | 				"
18 | 			/>
19 | 		</label>
20 | 		<div jin-trade-legend="">{legend}</div>
21 | 	</div>
22 | </div>
23 | 


--------------------------------------------------------------------------------
/trait/jin_trait.jam.js:
--------------------------------------------------------------------------------
 1 | this.$jin.trait = function( name ){
 2 |     
 3 |     var trait = $jin.glob( name )
 4 |     if( trait ) return trait
 5 |     
 6 |     trait = $jin.trait.make( name )
 7 |     
 8 |     return $jin.glob( name, trait )
 9 | }
10 | 
11 | this.$jin.trait.make = function( name ){
12 |     
13 |     var trait = function jin_trait_instance( ){
14 | 		return trait.exec.apply( trait, arguments )
15 |     }
16 | 
17 |     trait.displayName = name
18 |     
19 |     return trait
20 | }
21 | 


--------------------------------------------------------------------------------
/tree/tree.ts:
--------------------------------------------------------------------------------
1 | declare module $jin {
2 |     export var tree : any
3 | }


--------------------------------------------------------------------------------
/tree2/tree.stage=dev.ts:
--------------------------------------------------------------------------------
 1 | new $jin_test2( test => {
 2 | 	test.equal( $jin_tree2.fromString( "foo\nbar\n" ).childs.length , 2 )
 3 | 	test.equal( $jin_tree2.fromString( "foo\nbar\n" ).childs[1].type , "bar" )
 4 | 	test.equal( $jin_tree2.fromString( "foo\n\n\n" ).childs.length , 1 )
 5 | 	
 6 | 	test.equal( $jin_tree2.fromString( "=foo\n=bar\n" ).childs.length , 2 )
 7 | 	test.equal( $jin_tree2.fromString( "=foo\n=bar\n" ).childs[1].data , "bar" )
 8 | 	
 9 | 	test.equal( $jin_tree2.fromString( "foo bar =pol" ).childs[0].childs[0].childs[0].data , "pol" )
10 | 	test.equal( $jin_tree2.fromString( "foo bar\n\t=pol\n\t=men" ).childs[0].childs[0].childs[1].data , "men" )
11 | 	
12 | 	test.equal( $jin_tree2.fromString( 'foo bar =text\n' ).toString() , 'foo bar =text\n' )
13 | })


--------------------------------------------------------------------------------
/type/type.ts:
--------------------------------------------------------------------------------
1 | function $jin_type( value : any ) {
2 | 	var str = {}.toString.apply( value )
3 | 	var type = str.substring( 8, str.length - 1 )
4 | 	if( [ 'Window', 'global' ].indexOf( type ) >= 0  ) type = 'Global'
5 | 	return type
6 | }
7 | 


--------------------------------------------------------------------------------
/type/type_tests.test.ts:
--------------------------------------------------------------------------------
 1 | module $ {
 2 | 	$mol_test({
 3 | 		
 4 | 		'scalars'() {
 5 | 			$mol_assert_equal( $jin_type( void 0 ) , 'Undefined' )
 6 | 			$mol_assert_equal( $jin_type( null ) , 'Null' )
 7 | 			$mol_assert_equal( $jin_type( 0 ) , 'Number' )
 8 | 			$mol_assert_equal( $jin_type( '' ) , 'String' )
 9 | 			$mol_assert_equal( $jin_type( false ) , 'Boolean' )
10 | 		} ,
11 | 		
12 | 		'common objects'() {
13 | 			$mol_assert_equal( $jin_type( {} ) , 'Object' )
14 | 			$mol_assert_equal( $jin_type( [] ) , 'Array' )
15 | 			$mol_assert_equal( $jin_type( arguments ) , 'Arguments' )
16 | 		} ,
17 | 		
18 | 		'special objects'() {
19 | 			//$mol_assert_equal( $jin_type( function() { return this }() ) , 'Global' )
20 | 			$mol_assert_equal( $jin_type( new Date ) , 'Date' )
21 | 			$mol_assert_equal( $jin_type( new RegExp( '' ) ) , 'RegExp' )
22 | 		} ,
23 | 		
24 | 	})
25 | 	
26 | }
27 | 


--------------------------------------------------------------------------------
/uri/jin-uri-query.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.uri.query
 3 |  * @class $jin.uri.query
 4 |  * @mixins $jin.klass
 5 |  * @mixins $jin.wrapper
 6 |  * @returns $jin.uri.query
 7 |  */
 8 | $jin.klass({ '$jin.uri.query': [ '$jin.wrapper' ] })
 9 | 
10 | /**
11 |  * @name $jin.uri.query.exec
12 |  * @method exec
13 |  * @member $jin.uri.query
14 |  * @static
15 |  */
16 | $jin.method({ '$jin.uri.query.exec': function( params ){
17 | 	if( typeof params === 'string' ){
18 |         var chunkList = params.split( /[;&\n]+/ )
19 |         params = {}
20 |         chunkList.forEach( function( chunk ){
21 |             var values = chunk.split( /[_:=]/ ).map( function( value ){
22 | 	            return decodeURIComponent( value.replace( /\+/g, ' ' ) )
23 |             } )
24 |             var key = values.shift()
25 |             params[ key ] = values
26 |         }.bind(this) )
27 | 	}
28 | 	
29 | 	return this['$jin.wrapper.exec']( params )
30 | }})
31 | 
32 | /**
33 |  * @name $jin.uri.query#toString
34 |  * @method toString
35 |  * @member $jin.uri.query
36 |  */
37 | $jin.method({ '$jin.uri.query..toString': function( syntax ){
38 | 	if( !syntax ) syntax = ';='
39 | 	
40 |     var chunks = []
41 | 	var params = this.raw()
42 |     
43 | 	for( var key in params ){
44 |         var chunk = [ key ].concat( params[ key ] )
45 | 		.map( function( val ){
46 | 			return $jin.uri.escape( val )
47 | 		})
48 | 		.join( syntax[1] )
49 |         chunks.push( chunk )
50 |     }
51 |     
52 |     return chunks.join( syntax[0] )
53 | }})
54 | 


--------------------------------------------------------------------------------
/uri/uri.ts:
--------------------------------------------------------------------------------
1 | declare module $jin {
2 |     export var uri : any
3 | }


--------------------------------------------------------------------------------
/value/jin-value.jam.js:
--------------------------------------------------------------------------------
 1 | this.$jin.value = function $jin_value( value ){
 2 |     
 3 |     var func = function $jin_value_instance( ){
 4 |         return value
 5 |     }
 6 | 	
 7 | 	func.valueOf = func
 8 | 	func.toString = func
 9 |     
10 |     func.$jin_value = value
11 |     
12 |     return func
13 | }
14 | 


--------------------------------------------------------------------------------
/value/value.ts:
--------------------------------------------------------------------------------
1 | declare module $jin {
2 |     export var value : any
3 | }
4 | 


--------------------------------------------------------------------------------
/vary2string/jin_vary2string.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.vary2string
 3 |  * @method vary2string
 4 |  * @static
 5 |  * @member $jin
 6 |  */
 7 | $jin.method({ '$jin.vary2string': function( prefix, vary, postfix ){
 8 |     if( !vary ) vary= {}
 9 |     
10 |     var chunks= []
11 |     for( var key in vary ){
12 | 		if( vary[ key ] == null ) continue
13 |         chunks.push( key + '=' + vary[ key ] )
14 |     }
15 |     chunks.sort()
16 |     
17 |     if( prefix ) chunks.unshift( prefix )
18 |     if( postfix ) chunks.push( postfix )
19 |     
20 |     return chunks.join( '.' )
21 | }})
22 | 


--------------------------------------------------------------------------------
/vector/jin-vector_tests.stage=dev.jam.js:
--------------------------------------------------------------------------------
1 | $jin.test( function( test ){
2 | 	var v = $jin.vector([ 1, 2, 3, 4 ])
3 | 	test.equal( v.x(), 1 )
4 | 	test.equal( v.y(), 2 )
5 | 	test.equal( v.z(), 3 )
6 | } )
7 | 


--------------------------------------------------------------------------------
/view/active.env=web.ts:
--------------------------------------------------------------------------------
 1 | module $jin.view {
 2 | 
 3 |     export class active extends $jin.object<any> {
 4 | 
 5 |         static objectId = '$jin.view.active'
 6 | 
 7 |         static ListenerFocus() {
 8 |             var listener = new $jin.atom.prop<any,typeof $jin.view.active>({
 9 |                 owner: this,
10 |                 name: 'listenerFocus',
11 |                 pull: atom => {
12 |                     window.addEventListener( 'focus', handler, true )
13 |                     return null
14 |                 },
15 |                 reap: atom => {
16 |                     window.removeEventListener( 'focus', handler, true )
17 |                     atom.destroy()
18 |                 }
19 |             })
20 |             var handler = (event) => this.Sample().push( event.target.jin_sample )
21 |             return listener
22 |         }
23 | 
24 |         static ListenerBlur() {
25 |             var listener = new $jin.atom.prop<any,typeof $jin.view.active>({
26 |                 owner: this,
27 |                 name: 'listenerBlur',
28 |                 pull: atom => {
29 |                     window.addEventListener( 'blur', handler, true )
30 |                     return null
31 |                 },
32 |                 reap: atom => {
33 |                     window.removeEventListener( 'blur', handler, true )
34 |                     atom.destroy()
35 |                 }
36 |             })
37 |             var handler = (event) => this.Sample().push( null )
38 |             return listener
39 |         }
40 | 
41 |         static Sample() {
42 |             return new $jin.atom.prop<$jin.view.sample<any>,typeof $jin.view.active>({
43 |                 owner: this,
44 |                 name: 'sample',
45 |                 pull: atom => {
46 |                     atom.owner.ListenerBlur().get()
47 |                     atom.owner.ListenerFocus().get()
48 |                     return null
49 |                 }
50 |             })
51 |         }
52 | 
53 |         static Model() {
54 |             return new $jin.atom.prop<$jin.view.model<any>,typeof $jin.view.active>({
55 |                 owner: this,
56 |                 name: 'model',
57 |                 pull: atom => {
58 |                     var sample = atom.owner.Sample().get()
59 |                     if( !sample ) return null
60 |                     return sample.view
61 |                 }
62 |             })
63 |         }
64 | 
65 |     }
66 | 
67 | }
68 | 


--------------------------------------------------------------------------------
/view/model.ts:
--------------------------------------------------------------------------------
 1 | module $jin.view {
 2 |     
 3 |     export class model < OwnerType extends $jin.object.iface > extends $jin.model < OwnerType > {
 4 |         static objectId = $jin.model.classRegister( '$jin.view.model' , '$jin.model' )
 5 |         // content : $jin.atom.prop< any[] , $jin.view.model >
 6 | 
 7 |         element( name , param ) {
 8 |             return new $jin.view[ this.constructor['objectId'] + '_' + name ]({
 9 |                 owner: this,
10 |                 view: this,
11 |                 name: name,
12 |                 param: param
13 |             })
14 |         }
15 | 
16 |     }
17 |     
18 | }
19 | 


--------------------------------------------------------------------------------
/when/when.ts:
--------------------------------------------------------------------------------
 1 | module $jin {
 2 | 	export function when( list : any ) {
 3 | 
 4 | 		var response = new $jin.atom.prop<any,any>({})
 5 | 		var values = []
 6 | 		var awaitCount = 0
 7 | 
 8 | 		function makeHandler(key) {
 9 | 			return function (value) {
10 | 				values[key] = value
11 | 				if (!--awaitCount) response.push(values)
12 | 			}
13 | 		}
14 | 
15 | 		for (var key in list) {
16 | 			++awaitCount
17 | 			var handle = makeHandler(key)
18 | 			list[key].then(handle, handle)
19 | 		}
20 | 
21 | 		return response
22 | 	}
23 | }


--------------------------------------------------------------------------------
/wrapper/jin_wrapper.jam.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @name $jin.wrapper
 3 |  * @class $jin.wrapper
 4 |  * @returns $jin.wrapper
 5 |  * @mixins $jin.klass
 6 |  */
 7 | $jin.klass({ '$jin.wrapper': [] })
 8 | 
 9 | /**
10 |  * @name $jin.wrapper#raw
11 |  * @method raw
12 |  * @member $jin.wrapper
13 |  */
14 | $jin.property({ '$jin.wrapper..raw': null })
15 | 
16 | /**
17 |  * @name $jin.wrapper.exec
18 |  * @method exec
19 |  * @static
20 |  * @member $jin.wrapper
21 |  */
22 | $jin.method({ '$jin.wrapper.exec': function( obj ){
23 |     if( obj instanceof this ) return obj
24 |     if( obj.raw ) obj = obj.raw()
25 |     return this['$jin.klass.exec']( obj )
26 | }})
27 | 
28 | /**
29 |  * @name $jin.wrapper#init
30 |  * @method init
31 |  * @member $jin.wrapper
32 |  */
33 | $jin.method({ '$jin.wrapper..init': function( obj ){
34 |     this['$jin.klass..init']
35 |     this.raw( obj )
36 |     return this
37 | }})
38 | 


--------------------------------------------------------------------------------