31 |
--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "blocks",
3 | "main": "dist/blocks.js",
4 | "license": "MIT",
5 | "author": {
6 | "name": "Antonio Stoilkov",
7 | "email": "antonio.stoilkov@gmail.com",
8 | "url": "http://jsblocks.com"
9 | },
10 | "ignore": [
11 | "build",
12 | "examples",
13 | "lib",
14 | "node_modules",
15 | "src",
16 | "test",
17 | "*.gitignore",
18 | "Gruntile.js",
19 | "package.json",
20 | "dist/npm"
21 | ],
22 | "keywords": []
23 | }
--------------------------------------------------------------------------------
/build/init.js:
--------------------------------------------------------------------------------
1 | module.exports = function (grunt) {
2 | 'use strict';
3 |
4 | grunt.loadNpmTasks('grunt-contrib-requirejs');
5 | grunt.loadNpmTasks('grunt-contrib-uglify');
6 | grunt.loadNpmTasks('grunt-contrib-jshint');
7 | grunt.loadNpmTasks('grunt-contrib-watch');
8 | grunt.loadNpmTasks('grunt-preprocess');
9 | grunt.loadNpmTasks('grunt-karma');
10 | grunt.loadNpmTasks('grunt-notify');
11 |
12 | var pkg = grunt.file.readJSON('package.json')
13 | grunt.initConfig({
14 | pkg: pkg,
15 |
16 | version: pkg.version,
17 |
18 | banner: '/*! jsblocks v<%= pkg.version %> | ' +
19 | '(c) 2014, <%= grunt.template.today("yyyy") %> |' +
20 | 'jsblocks.org/license */',
21 |
22 | watch: {
23 | compile: {
24 | files: ['src/**/*.js'],
25 | tasks: ['compile'],
26 | options: {
27 | interrupt: true
28 | }
29 | }
30 | },
31 |
32 | preprocess: {
33 | debug: {
34 | src: ['dist/blocks-source.js'],
35 | dest: 'dist/blocks.js',
36 | options: {
37 | context: {
38 | DEBUG: true,
39 | SERVER: false
40 | }
41 | }
42 | },
43 |
44 | client: {
45 | src: [
46 | 'dist/blocks-source.js',
47 | 'dist/mvc/blocks-mvc.js',
48 | 'dist/query/blocks-query.js',
49 | 'dist/query/blocks-query-data.js'
50 | ],
51 | options: {
52 | inline: true,
53 | context: {
54 | DEBUG: false,
55 | SERVER: false
56 | }
57 | }
58 | },
59 |
60 | server: {
61 | src: 'dist/node/blocks-node.js',
62 | options: {
63 | inline: true,
64 | context: {
65 | DEBUG: false,
66 | SERVER: true
67 | }
68 | }
69 | }
70 | },
71 |
72 | uglify: {
73 | build: {
74 | options: {
75 | sourceMap: true
76 | },
77 | files: {
78 | 'dist/blocks.min.js': ['dist/blocks-source.js'],
79 | 'dist/mvc/blocks-mvc.min.js': ['dist/mvc/blocks-mvc.js'],
80 | 'dist/query/blocks-query.min.js': ['dist/query/blocks-query.js'],
81 | 'dist/query/blocks-query-data.min.js': ['dist/query/blocks-query-data.js']
82 | }
83 | }
84 | },
85 |
86 | notify: {
87 | build: {
88 | options: {
89 | message: 'Build successful'
90 | }
91 | }
92 | },
93 |
94 | jshint: {
95 | options: {
96 | jshintrc: true
97 | },
98 |
99 | source: ['src/**/*.js']
100 | //test: ['test/spec/**/*.js'],
101 | //grunt: ['build/**/*.js']
102 | }
103 | });
104 |
105 | grunt.loadTasks('build/tasks');
106 |
107 | grunt.registerTask('compile', ['build', 'combine', 'preprocess', 'debug', 'build-tests-definitions']);
108 | grunt.registerTask('live-compile', ['compile', 'watch:compile']);
109 | grunt.registerTask('full-build', ['jshint', 'compile', 'uglify', 'test', 'npm', 'bower']);
110 | grunt.registerTask('build-only', ['jshint', 'compile', 'uglify', 'npm', 'bower']);
111 | grunt.registerTask('default', []);
112 | };
113 |
--------------------------------------------------------------------------------
/build/publish/GetClosedIssuesAndMergedPRs.graphql:
--------------------------------------------------------------------------------
1 | query ($owner: String!, $repo: String!, $afterIssues: String, $afterPRs: String, $includePRs: Boolean!, $includeIssues: Boolean!) {
2 | repository(owner: $owner, name: $repo) {
3 | ...issues @include(if: $includeIssues)
4 | ...prs @include(if: $includePRs)
5 | parent {
6 | ...issues @include(if: $includeIssues)
7 | ...prs @include(if: $includePRs)
8 | }
9 | }
10 | }
11 |
12 | fragment issues on Repository {
13 | issues(first: 100, after: $afterIssues, states: [CLOSED]) {
14 | pageInfo {
15 | hasNextPage
16 | endCursor
17 | }
18 | nodes {
19 | number
20 | url
21 | title
22 | timeline(first: 100) {
23 | nodes {
24 | ... on ReferencedEvent {
25 | commit {
26 | oid
27 | }
28 | }
29 | ... on ClosedEvent {
30 | closeCommit: commit {
31 | oid
32 | }
33 | }
34 | }
35 | }
36 | }
37 | }
38 | }
39 |
40 | fragment prs on Repository {
41 | pullRequests(first: 100, after: $afterPRs, states: [MERGED]) {
42 | pageInfo {
43 | hasNextPage
44 | endCursor
45 | }
46 | nodes {
47 | title
48 | url
49 | number
50 | timeline(first: 100) {
51 | nodes {
52 | ... on MergedEvent {
53 | commit {
54 | oid
55 | }
56 | }
57 | }
58 | }
59 | # unfortunatly seems to be buggy in the alpha of github graphql
60 | # sometime "MERGED" PRs have a mergeCommit and sometimes not
61 | # while they are having a "MergedEvent" timeline
62 | # mergeCommit {
63 | # oid
64 | # }
65 | }
66 | }
67 | }
--------------------------------------------------------------------------------
/build/publish/GetMasterCommits.graphql:
--------------------------------------------------------------------------------
1 | query ($owner: String!, $repo: String!, $after: String, $includeLastRelease: Boolean!) {
2 | repository(owner: $owner, name: $repo) {
3 | ...commits
4 | ...lastRelease @include(if:$includeLastRelease)
5 | # for some reason releases aren't queryable on forked repos if they weren't published on the fork first
6 | # so include the parent in case the repo doesn't have a last release
7 | parent @include(if: $includeLastRelease) {
8 | ...lastRelease
9 | }
10 | }
11 | }
12 |
13 | fragment commits on Repository {
14 | ref(qualifiedName: "refs/heads/master") {
15 | target {
16 | ... on Commit {
17 | history(first: 100, after: $after) {
18 | pageInfo {
19 | hasNextPage
20 | endCursor
21 | }
22 | nodes {
23 | url
24 | messageHeadline
25 | oid
26 | }
27 | }
28 | }
29 | }
30 | }
31 | }
32 |
33 | fragment lastRelease on Repository {
34 | releases(last: 1) {
35 | nodes {
36 | description
37 | tag {
38 | name
39 | target {
40 | oid
41 | }
42 | }
43 | }
44 | }
45 | }
--------------------------------------------------------------------------------
/build/publish/github-graphql.js:
--------------------------------------------------------------------------------
1 | var fetch = require('node-fetch');
2 | var fs = require('fs');
3 | var path = require('path');
4 |
5 | var files = {};
6 |
7 | function readFileForMethod(method) {
8 | return new Promise(function (resolve, reject) {
9 | if (files[method]) {
10 | return setTimeout(resolve.bind(null, files[method]));
11 | }
12 | fs.readFile(path.resolve(__dirname, method + '.graphql'), function (err, file) {
13 | if (err) {
14 | return reject(err);
15 | }
16 | files[method] = file.toString().replace('\n', '');
17 | resolve(files[method]);
18 | });
19 | });
20 | }
21 |
22 | function queryGraphQL (method, vars, key) {
23 | return readFileForMethod(method).then(function (query) {
24 | var body = JSON.stringify({query: query, variables: vars});
25 | return fetch('https://api.github.com/graphql', {
26 | method: 'POST',
27 | headers: {
28 | Authorization: 'bearer ' + key
29 | },
30 | body: body
31 | }).then(res => res.json()).then(function (result) {
32 | if (result.errors && result.errors.length > 0) {
33 | result.errors.forEach(console.error);
34 | throw new Error(result.error[0]);
35 | }
36 | return result;
37 | });
38 | });
39 | }
40 |
41 | function hasProperties(obj) {
42 | for (var key in obj) {
43 | return true;
44 | }
45 | return false;
46 | }
47 |
48 | function GithubGraphQLWrapper (key, owner, repo) {
49 | this._key = key;
50 | this._repo = repo;
51 | this._owner = owner;
52 | this._commits = [];
53 | this._issues = [];
54 | this._mergedPRs = [];
55 | this._closedIssues = [];
56 | this._lastRelease = null;
57 | this._commitAfterRef = null;
58 | this._reachedLastIssue = false;
59 | this._reachedLastPr = false;
60 | this._afterPRRef = null;
61 | this._afterIssueRef = null;
62 | }
63 |
64 | GithubGraphQLWrapper.prototype = {
65 | constructor: GithubGraphQLWrapper,
66 | fetchLastGithubRelease: function fetchLastGithubRelease () {
67 | return queryGraphQL('GetMasterCommits', {
68 | repo: this._repo,
69 | owner: this._owner,
70 | includeLastRelease: true,
71 | after: this._commitAfterRef
72 | }, this._key).then(result => {
73 | var data = result.data.repository;
74 | var parentRelease = data.parent && data.parent.releases.nodes.length && data.parent.releases.nodes[0];
75 | var lastRelease = data.releases.nodes.length > 0 ? data.releases.nodes[0] : parentRelease;
76 | var history = data.ref.target.history;
77 | this._lastRelease = lastRelease;
78 | this._commits = this._commits.concat(history.nodes);
79 | this._commitAfterRef = history.pageInfo.endCursor;
80 | return this;
81 | });
82 | },
83 | fetchCommitsToLastRelease: function () {
84 | return queryGraphQL('GetMasterCommits', {
85 | repo: this._repo,
86 | owner: this._owner,
87 | includeLastRelease: false,
88 | after: this._commitAfterRef
89 | }, this._key).then(result => {
90 | var data = result.data.repository;
91 | var history = data.ref.target.history;
92 | this._commitAfterRef = data.ref.target.history.pageInfo.endCursor;
93 | this._commits = this._commits.concat(data.ref.target.history.nodes);
94 | var commitOids = this._commits.map(c => c.oid);
95 | if (commitOids.indexOf(this._lastRelease.tag.target.oid) == -1 && history.pageInfo.hasNextPage) {
96 | return this.fetchCommitsToLastRelease();
97 | }
98 | this._commits.splice(commitOids.indexOf(this._lastRelease.tag.target.oid));
99 | return this;
100 | });
101 | },
102 | fetchPRsAndIssues: function () {
103 | return queryGraphQL('GetClosedIssuesAndMergedPRs', {
104 | repo: this._repo,
105 | owner: this._owner,
106 | includePRs: !this._reachedLastPr,
107 | includeIssues: !this._reachedLastIssue,
108 | afterIssues: this._afterIssueRef,
109 | afterPRs: this._afterPRRef,
110 | }, this._key).then(result => {
111 | var repository = result.data.repository;
112 | var parent = repository.parent;
113 | var parentIssues = parent && parent.issues && parent.issues.nodes.length && parent.issues;
114 | var localIssues = repository.issues && repository.issues.nodes.length && repository.issues;
115 | var issues = localIssues || parentIssues;
116 | var parentPRs = parent && parent.pullRequests && parent.pullRequests.nodes.length && parent.pullRequests;
117 | var localPRs = repository.pullRequests && repository.pullRequests.nodes.length && repository.pullRequests;
118 | var prs = localPRs || parentPRs;
119 | if (issues) {
120 | this._reachedLastIssue = !issues.pageInfo.hasNextPage;
121 | this._afterIssueRef = issues.pageInfo.endCursor;
122 | this._closedIssues = this._closedIssues.concat(issues.nodes);
123 | }
124 |
125 | if (prs) {
126 | this._reachedLastPr = !prs.pageInfo.hasNextPage;
127 | this._afterPRRef = prs.pageInfo.endCursor;
128 | this._mergedPRs = this._mergedPRs.concat(prs.nodes);
129 | }
130 | if (!this._reachedLastPr && !this._reachedLastIssue) {
131 | return this.fetchPRsAndIssues();
132 | }
133 | }).then(() => {
134 | this._closedIssues = this._closedIssues.map(issue => {
135 | issue.timeline = issue.timeline.nodes.filter(hasProperties);
136 | return issue;
137 | }).filter(issue => issue.timeline.length > 0);
138 | this._mergedPRs.map(pr => {
139 | pr.timeline = pr.timeline.nodes.filter(hasProperties);
140 | return pr;
141 | }).filter(pr => pr.timeline.length > 0);
142 | return this;
143 | });
144 | },
145 | getLastRelease: function () {
146 | return this._lastRelease;
147 | },
148 | getMergedPRs: function () {
149 | return this._mergedPRs;
150 | },
151 | getCommits: function () {
152 | return this._commits;
153 | },
154 | getClosedIssues: function () {
155 | return this._closedIssues;
156 | },
157 | getOwner: function () {
158 | return this._owner;
159 | },
160 | getRepo: function () {
161 | return this._repo;
162 | }
163 | };
164 |
165 | module.exports = GithubGraphQLWrapper;
--------------------------------------------------------------------------------
/build/tasks/bower.js:
--------------------------------------------------------------------------------
1 | module.exports = function (grunt) {
2 | var bowerJSON = {
3 | name: 'blocks',
4 | main: 'dist/blocks.js',
5 | license: 'MIT',
6 | author: {
7 | name: 'Antonio Stoilkov',
8 | email: 'antonio.stoilkov@gmail.com',
9 | url: 'http://jsblocks.com'
10 | },
11 | ignore: [
12 | 'build',
13 | 'examples',
14 | 'lib',
15 | 'node_modules',
16 | 'src',
17 | 'test',
18 | '*.gitignore',
19 | 'Gruntile.js',
20 | 'package.json',
21 | 'dist/npm'
22 | ],
23 | keywords: []
24 | };
25 |
26 | grunt.registerTask('bower', function () {
27 | grunt.file.write('bower.json', JSON.stringify(bowerJSON, null, 4));
28 | });
29 | };
30 |
--------------------------------------------------------------------------------
/build/tasks/build-test-definitions.js:
--------------------------------------------------------------------------------
1 | module.exports = function (grunt) {
2 | grunt.registerTask('build-tests-definitions', function () {
3 | var tests = {};
4 | var contents;
5 | var key;
6 |
7 | grunt.file.recurse('test/spec', function (abspath) {
8 | placeInObject(tests, abspath.replace('test/', ''), abspath.replace('test/spec/', ''));
9 | });
10 |
11 | for (key in tests) {
12 | tests['blocks.' + key] = tests[key];
13 | delete tests[key];
14 | }
15 |
16 | contents = JSON.stringify(tests, null, 4);
17 |
18 | grunt.file.write('test/tests.json', contents);
19 | });
20 |
21 | function placeInObject(current, fullPath, currentPath) {
22 | var parts = currentPath.split('/');
23 | var firstPart = parts[0];
24 | var obj;
25 |
26 | if (parts.length == 2) {
27 | (current[firstPart] = current[firstPart] || []).push(fullPath);
28 | } else {
29 | obj = current[firstPart] = current[firstPart] || {};
30 | if (obj instanceof Array) {
31 | obj.push({});
32 | obj = obj[obj.length - 1];
33 | }
34 | placeInObject(obj, fullPath, parts.slice(1).join('/'));
35 | }
36 | }
37 | };
--------------------------------------------------------------------------------
/build/tasks/build.js:
--------------------------------------------------------------------------------
1 | module.exports = function (grunt) {
2 | var esprima = require('esprima');
3 | var escodegen = require('escodegen');
4 | var estrvarse = require('estraverse');
5 | var definedModuleNames = {};
6 | var requirejsConfig = {};
7 | var requirejsOptions = {
8 | baseUrl: 'src',
9 | out: 'dist/<%= name %>/blocks-<%= name %>.js',
10 | include: ['<%= name %>.js'],
11 | optimize: 'none',
12 | skipSemiColonInsertion: true,
13 | onBuildWrite: function (name, path, contents) {
14 | var rdefineEnd = /\}\);[^}\w]*$/;
15 |
16 | if (/.\/var\//.test(path)) {
17 | contents = contents
18 | .replace(/define\([\w\W]*?return/, ' var ' + (/var\/([\w-]+)/.exec(name)[1]) + ' =')
19 | .replace(rdefineEnd, '');
20 |
21 | } else {
22 | contents = contents
23 | .replace(/\/\*\s*ExcludeStart\s*\*\/[\w\W]*?\/\*\s*ExcludeEnd\s*\*\//ig, '')
24 | .replace(/\/\/\s*BuildExclude\n\r?[\w\W]*?\n\r?/ig, '');
25 | var ast = esprima.parse(contents, {
26 | tokens: true,
27 | comment: true,
28 | range: true
29 | });
30 |
31 | estrvarse.attachComments(ast, ast.comments, ast.tokens);
32 |
33 | if (ast.body[0].expression.callee.name == 'define') {
34 | var moduleExpression = findModuleExpressionArgument(ast.body[0].expression.arguments);
35 | if (!moduleExpression || !moduleExpression.body.body[0] || moduleExpression.body.body[0].type == 'ReturnStatement') {
36 | // Null out empty define statements e.g. define(['./query/ready', '...'])
37 | // and expresions without an expression or only an return statement e.g. define([], function () { return blocks; })
38 | contents = '';
39 | } else {
40 | var moduleName;
41 | try {
42 | moduleName = findModuleExportIdentifier(moduleExpression.body.body) || /\/(\w+).?j?s?$/.exec(name)[1];
43 | } catch(e) {}
44 | if (moduleName && definedModuleNames[moduleName] && definedModuleNames[moduleName] != path) {
45 | grunt.fail.warn('[NamingConflict]: Module ' + path + ' tried to define ' + moduleName + ' which is already defined by ' + definedModuleNames[moduleName] + ' !');
46 | } else if (moduleName){
47 | definedModuleNames[moduleName] = path;
48 | }
49 | ast = wrapModuleAst(moduleExpression, moduleName);
50 | contents = escodegen.generate(ast, {
51 | format: {
52 | indent: {
53 | style: ' ',
54 | base: 0,
55 | adjustMultilineComment: true
56 | }
57 | },
58 | comment: true
59 | });
60 | }
61 | }
62 | /* contents = contents
63 | .replace(/\s*return\s+[^\}]+(\}\);[^\w\}]*)$/, '$1')
64 | // Multiple exports
65 | .replace(/\s*exports\.\w+\s*=\s*\w+;/g, '');
66 |
67 | // Remove define wrappers, closure ends, and empty declarations
68 | contents = contents
69 | .replace(/define\([^{]*?{/, '')
70 | .replace(rdefineEnd, '');
71 |
72 | // Remove anything wrapped with
73 | // /* ExcludeStart */ /* ExcludeEnd */
74 | // or a single line directly after a // BuildExclude comment
75 |
76 | // Remove empty definitions
77 | /* contents = contents
78 | .replace(/define\(\[[^\]]+\]\)[\W\n]+$/, '');*/
79 |
80 | }
81 |
82 | return contents;
83 | }
84 | };
85 |
86 | function findModuleExportIdentifier (module) {
87 | for (var i = module.length -1 ; i >= 0; i--) {
88 | var expression = module[i];
89 | if (expression.type == 'ReturnStatement') {
90 | return expression.argument.name;
91 | }
92 | }
93 | throw new Error('No return statement');
94 | }
95 |
96 | function findModuleExpressionArgument(args) {
97 | for (var i in args) {
98 | var arg = args[i];
99 | if (arg.type == 'FunctionExpression') {
100 | return arg;
101 | }
102 | }
103 | }
104 |
105 |
106 | function wrapModuleAst (node, exportName) {
107 | var wrapedModule;
108 | var bodyNode;
109 | if (exportName) {
110 | wrapedModule = esprima.parse('var ' + exportName + ' = (function () { })();');
111 | bodyNode = wrapedModule.body[0].declarations[0].init.callee.body;
112 | } else {
113 | wrapedModule = esprima.parse('(function () { })();');
114 | bodyNode = wrapedModule.body[0].expression.callee.body;
115 | }
116 | // insert body of the original "define"-function to the
117 | bodyNode.body = node.body.body;
118 | return wrapedModule;
119 | }
120 |
121 | var names = ['query', 'mvc', 'node'];
122 | names.forEach(function (name) {
123 | grunt.config.set('name', name);
124 | (requirejsConfig[name] = {}).options = grunt.config.process(requirejsOptions);
125 | grunt.config.set('name', undefined);
126 | });
127 |
128 | grunt.config.set('requirejs', requirejsConfig);
129 |
130 | grunt.registerTask('build', function () {
131 | var tasks = [];
132 | for (var i = 0; i < arguments.length; i++) {
133 | tasks.push('requirejs:' + arguments[i]);
134 | }
135 | grunt.task.run(tasks.length ? tasks : 'requirejs');
136 | });
137 | };
--------------------------------------------------------------------------------
/build/tasks/combine.js:
--------------------------------------------------------------------------------
1 | module.exports = function (grunt) {
2 |
3 | grunt.registerTask('combine', function () {
4 | var core = grunt.file.read('lib/blocks/core.js').replace('@version', grunt.config.get('version'));
5 | var jsvalue = grunt.file.read('lib/blocks/value-nocore.js');
6 | var mvc = grunt.file.read('dist/mvc/blocks-mvc.js');
7 | var query = grunt.file.read('dist/query/blocks-query.js');
8 |
9 | // TODO: Remove if node is not created until released
10 | var node = grunt.file.read('dist/node/blocks-node.js');
11 |
12 | var nodeCode = insertSourceCode(
13 | core.replace('typeof window !== \'undefined\' ? window : this', 'typeof window !== \'undefined\' && !window.__mock__ ? window : this'),
14 | [jsvalue, node]);
15 | grunt.file.write('dist/node/blocks-node.js', nodeCode);
16 |
17 |
18 | var jsblocks = insertSourceCode(core, [jsvalue, mvc]);
19 | var mvcOnly = insertSourceCode(core, [mvc]);
20 | var queryOnly = insertSourceCode(core, [query]);
21 | var queryAndValue = insertSourceCode(core, [jsvalue, query]);
22 |
23 | grunt.file.write('dist/blocks-source.js', jsblocks);
24 | grunt.file.write('dist/mvc/blocks-mvc.js', mvcOnly);
25 | grunt.file.write('dist/query/blocks-query.js', queryOnly);
26 | grunt.file.write('dist/query/blocks-query-data.js', queryAndValue);
27 | });
28 |
29 | function getSourceCodeWrap(code) {
30 | return '(function () {\n' + code + '\n})();'
31 | }
32 |
33 | function insertSourceCode(core, code) {
34 | var sourceCodeLocation;
35 | var result = core;
36 |
37 | code.forEach(function (codeBlock) {
38 | sourceCodeLocation = result.indexOf('// @source-code');
39 | result = result.substring(0, sourceCodeLocation) + '\n' + getSourceCodeWrap(codeBlock) + result.substring(sourceCodeLocation);
40 | });
41 |
42 | return result;
43 | }
44 | };
45 |
--------------------------------------------------------------------------------
/build/tasks/npm.js:
--------------------------------------------------------------------------------
1 | module.exports = function (grunt) {
2 | var packageJSON = {
3 | name: 'blocks',
4 | version: grunt.config.get('version'),
5 | description: 'jsblocks - Better MV-ish Framework',
6 | main: 'node/blocks-node.js',
7 | keyword: ['MVC', 'MVVM', 'MVW', 'server rendering', 'filtering', 'sorting', 'paging', 'framework'],
8 | scripts: {
9 | 'test': 'echo \'Error: no test specified\' && exit 1'
10 | },
11 | repository: {
12 | type: 'git',
13 | url: 'https://github.com/astoilkov/jsblocks.git'
14 | },
15 | author: {
16 | name: 'Antonio Stoilkov',
17 | email: 'antonio.stoilkov@gmail.com',
18 | url: 'http://jsblocks.com'
19 | },
20 | license: 'MIT',
21 | bugs: {
22 | url: 'https://github.com/astoilkov/jsblocks/issues',
23 | email: 'support@jsblocks.com'
24 | },
25 | homepage: 'https://github.com/astoilkov/jsblocks',
26 | dependencies: {
27 | express: "4.14.0",
28 | parse5: "2.2.1"
29 | }
30 | };
31 |
32 | grunt.registerTask('npm', function () {
33 | grunt.file.recurse('dist', function (abspath, rootdir, subdir, filename) {
34 | var subFolder = subdir ? subdir + '/' : '';
35 | subdir = subdir || '';
36 |
37 | if (subdir.indexOf('npm') == -1) {
38 | grunt.file.write('dist/npm/' + subFolder + filename, grunt.file.read(abspath));
39 | }
40 | });
41 | grunt.file.write('dist/npm/package.json', JSON.stringify(packageJSON, null, 4));
42 | grunt.file.write('dist/npm/README.md', grunt.file.read('README.md'));
43 | });
44 | };
--------------------------------------------------------------------------------
/build/tasks/test.js:
--------------------------------------------------------------------------------
1 | module.exports = function (grunt) {
2 | var karmaConfig = {
3 | options: {
4 | files: [
5 | // code for testing
6 | 'dist/blocks.js',
7 |
8 | // dependencies
9 | require.resolve('jquery/dist/jquery.js'),
10 | //'lib/jquery-1.11.2/jquery-1.11.2.js',
11 | require.resolve('jasmine-jquery'),
12 | //'lib/jasmine-jquery-2.2.0/jasmine-jquery.js',
13 | 'test/blocks.testing.js',
14 |
15 | // tests location
16 | 'test/spec/**/*.js'
17 | ],
18 | autoWatch: false,
19 | //browserNoActivityTimeout: 30000,
20 | // browserDisconnectTimeout
21 | // browserDisconnectTolerance
22 | frameworks: ['jasmine']
23 | },
24 |
25 | test: {
26 | browsers: ['Chrome', 'Firefox', 'IE11', 'IE10'],
27 | customLaunchers: {
28 | IE11: {
29 | base: 'IE',
30 | 'x-ua-compatible': 'IE=EmulateIE11'
31 | },
32 | IE10: {
33 | base: 'IE',
34 | 'x-ua-compatible': 'IE=EmulateIE10'
35 | }
36 | },
37 | singleRun: true
38 | },
39 |
40 | coverage: {
41 | browserConsoleLogOptions: {
42 | terminal: false
43 | },
44 | reporters: ['dots', 'coverage'],
45 | preprocessors: {
46 | 'dist/blocks.js': ['coverage']
47 | },
48 | coverageReporter: {
49 | type: 'html',
50 | dir: 'coverage/'
51 | },
52 | browsers: ['Firefox'],
53 | singleRun: true
54 | },
55 |
56 | watch: {
57 | browsers: ['PhantomJS'],
58 | background: true
59 | },
60 | phantom: {
61 | browsers: ['PhantomJS'],
62 | singleRun: true
63 | },
64 |
65 | chrome: {
66 | browsers: ['Chrome'],
67 | singleRun: true
68 | },
69 |
70 | firefox: {
71 | browsers: ['Firefox'],
72 | singleRun: true
73 | },
74 |
75 | ie: {
76 | browsers: ['IE11', 'IE10', 'IE9'],
77 | customLaunchers: {
78 | IE11: {
79 | base: 'IE',
80 | 'x-ua-compatible': 'IE=EmulateIE11'
81 | },
82 | IE10: {
83 | base: 'IE',
84 | 'x-ua-compatible': 'IE=EmulateIE10'
85 | },
86 | IE9: {
87 | base: 'IE',
88 | 'x-ua-compatible': 'IE=EmulateIE9'
89 | },
90 | IE8: {
91 | base: 'IE',
92 | 'x-ua-compatible': 'IE=EmulateIE8'
93 | }
94 | },
95 | singleRun: true
96 | },
97 |
98 | ie9: {
99 | browsers: ['IE9'],
100 | customLaunchers: {
101 | IE9: {
102 | base: 'IE',
103 | 'x-ua-compatible': 'IE=EmulateIE9'
104 | }
105 | },
106 | singleRun: true
107 | },
108 |
109 | safari: {
110 | browsers: ['Safari'],
111 | singleRun: true
112 | },
113 |
114 | opera: {
115 | browsers: ['Opera'],
116 | singleRun: true
117 | },
118 |
119 |
120 | build: {
121 | browsers: ['IE', 'ChromeCanary', 'Safari', 'Firefox', 'Chrome', 'PhantomJS'],
122 | singleRun: true
123 | }
124 | };
125 |
126 | grunt.config.set('karma', karmaConfig);
127 |
128 | grunt.registerTask('test', function (browser) {
129 | if (browser) {
130 | grunt.task.run('karma:' + browser);
131 | } else {
132 | grunt.task.run('karma:test');
133 | }
134 | });
135 | };
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "jsblocks",
3 | "version": "0.3.5",
4 | "description": "Better MV-ish Framework",
5 | "author": {
6 | "name": "Antonio Stoilkov",
7 | "email": "antonio.stoilkov@gmail.com",
8 | "url": "http://jsblocks.com"
9 | },
10 | "license": "MIT",
11 | "scripts": {
12 | "test": "grunt test:firefox"
13 | },
14 | "devDependencies": {
15 | "blocks": "^0.3.4",
16 | "escodegen": "^1.6.1",
17 | "esprima": "^3.0.0",
18 | "estraverse": "^4.1.0",
19 | "grunt": "^1.0.1",
20 | "grunt-cli": "^1.2.0",
21 | "grunt-contrib-jshint": "^1.0.0",
22 | "grunt-contrib-requirejs": "^1.0.0",
23 | "grunt-contrib-uglify": "^2.0.0",
24 | "grunt-contrib-watch": "^1.0.0",
25 | "grunt-karma": "^2.0.0",
26 | "grunt-notify": "^0.4.1",
27 | "grunt-preprocess": "^5.1.0",
28 | "highlight.js": "^9.6.0",
29 | "jasmine-core": "^2.2.0",
30 | "jasmine-jquery": "^2.1.1",
31 | "jquery": "^3.2.1",
32 | "karma": "^1.2.0",
33 | "karma-chrome-launcher": "^2.0.0",
34 | "karma-coverage": "^1.1.1",
35 | "karma-firefox-launcher": "^1.0.0",
36 | "karma-ie-launcher": "^1.0.0",
37 | "karma-jasmine": "^1.0.2",
38 | "karma-jasmine-jquery": "^0.1.1",
39 | "node-fetch": "^1.6.3",
40 | "nodegit": "^0.18.0",
41 | "npm-utils": "^1.11.0",
42 | "parse5": "^2.2.1"
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/src/.jshintrc:
--------------------------------------------------------------------------------
1 | {
2 | "eqeqeq": false,
3 | "forin": false,
4 | "plusplus": false,
5 | "strict": false,
6 | "newcap": false,
7 |
8 | "es3": true,
9 | "bitwise": true,
10 | "camelcase": true,
11 | "curly": true,
12 | "freeze": true,
13 | "immed": true,
14 | "latedef": false,
15 | "noarg": true,
16 | "noempty": true,
17 | "nonbsp": true,
18 | "nonew": true,
19 | "undef": true,
20 | "unused": true,
21 | "trailing": true,
22 | "loopfunc": true,
23 | "eqnull": true,
24 | "quotmark": "single",
25 |
26 | "browser": true,
27 |
28 | "globals": {
29 | "blocks": true,
30 | "define": true,
31 | "global": true
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/src/DataSource.js:
--------------------------------------------------------------------------------
1 | define([
2 | './dataSource/DataSource'
3 | ], function (DataSource) {
4 | return DataSource;
5 | });
--------------------------------------------------------------------------------
/src/core.js:
--------------------------------------------------------------------------------
1 | define([
2 |
3 | ], function (blocks) {
4 | return blocks;
5 | });
6 |
--------------------------------------------------------------------------------
/src/modules/Escape.js:
--------------------------------------------------------------------------------
1 | define([],
2 | function () {
3 | var htmlEntityMap = {
4 | '&': '&',
5 | '<': '<',
6 | '>': '>',
7 | '"': '"',
8 | '\'': ''',
9 | '/': '/'
10 | };
11 |
12 | var htmlEscapeRegEx = (function () {
13 | var entities = [];
14 | for (var entity in htmlEntityMap) {
15 | entities.push(entity);
16 | }
17 | return new RegExp('(' + entities.join('|') + ')', 'g');
18 | })();
19 |
20 | function internalHTMLEscapeReplacer(entity) {
21 | return htmlEntityMap[entity];
22 | }
23 |
24 | var Escape = {
25 | // moved from modules/escapeRegEx
26 | forRegEx: function escapeRegEx(string) {
27 | return string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
28 | },
29 | forHTML: function (value) {
30 | if (blocks.isString(value)) {
31 | return value.replace(htmlEscapeRegEx, internalHTMLEscapeReplacer);
32 | }
33 | return value;
34 | },
35 | // This is only valid because jsblocks forces (inserts itself) double quotes for attributes
36 | // don't use this in other cases
37 | forHTMLAttributes: function (value) {
38 | if (blocks.isString(value)) {
39 | return value.replace(/"/g, '"');
40 | }
41 | return value;
42 | }
43 | };
44 | return Escape;
45 | });
46 |
--------------------------------------------------------------------------------
/src/modules/Event.js:
--------------------------------------------------------------------------------
1 | define(function () {
2 | var isMouseEventRegEx = /^(?:mouse|pointer|contextmenu)|click/;
3 | var isKeyEventRegEx = /^key/;
4 |
5 | function returnFalse() {
6 | return false;
7 | }
8 |
9 | function returnTrue() {
10 | return true;
11 | }
12 |
13 | function Event(e) {
14 | this.originalEvent = e;
15 | this.type = e.type;
16 |
17 | this.isDefaultPrevented = e.defaultPrevented ||
18 | (e.defaultPrevented === undefined &&
19 | // Support: IE < 9, Android < 4.0
20 | e.returnValue === false) ?
21 | returnTrue :
22 | returnFalse;
23 |
24 | this.timeStamp = e.timeStamp || +new Date();
25 | }
26 |
27 | Event.PropertiesToCopy = {
28 | all: 'altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which'.split(' '),
29 | mouse: 'button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement'.split(' '),
30 | keyboard: 'char charCode key keyCode'.split(' ')
31 | };
32 |
33 | Event.CopyProperties = function (originalEvent, event, propertiesName) {
34 | blocks.each(Event.PropertiesToCopy[propertiesName], function (propertyName) {
35 | event[propertyName] = originalEvent[propertyName];
36 | });
37 | };
38 |
39 | Event.prototype = {
40 | preventDefault: function () {
41 | var e = this.originalEvent;
42 |
43 | this.isDefaultPrevented = returnTrue;
44 |
45 | if (e.preventDefault) {
46 | // If preventDefault exists, run it on the original event
47 | e.preventDefault();
48 | } else {
49 | // Support: IE
50 | // Otherwise set the returnValue property of the original event to false
51 | e.returnValue = false;
52 | }
53 | },
54 |
55 | stopPropagation: function () {
56 | var e = this.originalEvent;
57 |
58 | this.isPropagationStopped = returnTrue;
59 |
60 | // If stopPropagation exists, run it on the original event
61 | if (e.stopPropagation) {
62 | e.stopPropagation();
63 | }
64 |
65 | // Support: IE
66 | // Set the cancelBubble property of the original event to true
67 | e.cancelBubble = true;
68 | },
69 |
70 | stopImmediatePropagation: function () {
71 | var e = this.originalEvent;
72 |
73 | this.isImmediatePropagationStopped = returnTrue;
74 |
75 | if (e.stopImmediatePropagation) {
76 | e.stopImmediatePropagation();
77 | }
78 |
79 | this.stopPropagation();
80 | }
81 | };
82 |
83 | Event.fix = function (originalEvent) {
84 | var type = originalEvent.type;
85 | var event = new Event(originalEvent);
86 |
87 | Event.CopyProperties(originalEvent, event, 'all');
88 |
89 | // Support: IE<9
90 | // Fix target property (#1925)
91 | if (!event.target) {
92 | event.target = originalEvent.srcElement || document;
93 | }
94 |
95 | // Support: Chrome 23+, Safari?
96 | // Target should not be a text node (#504, #13143)
97 | if (event.target.nodeType === 3) {
98 | event.target = event.target.parentNode;
99 | }
100 |
101 | // Support: IE<9
102 | // For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
103 | event.metaKey = !!event.metaKey;
104 |
105 | if (isMouseEventRegEx.test(type)) {
106 | Event.fixMouse(originalEvent, event);
107 | } else if (isKeyEventRegEx.test(type) && event.which == null) {
108 | Event.CopyProperties(originalEvent, event, 'keyboard');
109 | // Add which for key events
110 | event.which = originalEvent.charCode != null ? originalEvent.charCode : originalEvent.keyCode;
111 | }
112 |
113 | return event;
114 | };
115 |
116 | Event.fixMouse = function (originalEvent, event) {
117 | var button = originalEvent.button;
118 | var fromElement = originalEvent.fromElement;
119 | var body;
120 | var eventDoc;
121 | var doc;
122 |
123 | Event.CopyProperties(originalEvent, event, 'mouse');
124 |
125 | // Calculate pageX/Y if missing and clientX/Y available
126 | if (event.pageX == null && originalEvent.clientX != null) {
127 | eventDoc = event.target.ownerDocument || document;
128 | doc = eventDoc.documentElement;
129 | body = eventDoc.body;
130 |
131 | event.pageX = originalEvent.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
132 | event.pageY = originalEvent.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
133 | }
134 |
135 | // Add relatedTarget, if necessary
136 | if (!event.relatedTarget && fromElement) {
137 | event.relatedTarget = fromElement === event.target ? originalEvent.toElement : fromElement;
138 | }
139 |
140 | // Add which for click: 1 === left; 2 === middle; 3 === right
141 | // Note: button is not normalized, so don't use it
142 | if (!event.which && button !== undefined) {
143 | /* jshint bitwise: false */
144 | event.which = (button & 1 ? 1 : (button & 2 ? 3 : (button & 4 ? 2 : 0)));
145 | }
146 | };
147 |
148 | //var event = blocks.Event();
149 | //event.currentTarget = 1; // the current element from which is the event is fired
150 | //event.namespace = ''; // the namespace for the event
151 |
152 | return Event;
153 | });
154 |
--------------------------------------------------------------------------------
/src/modules/Events.js:
--------------------------------------------------------------------------------
1 | define([
2 | '../core'
3 | ], function (blocks) {
4 | var Events = (function () {
5 | function createEventMethod(eventName) {
6 | return function (callback, context) {
7 | if (arguments.length > 1) {
8 | Events.on(this, eventName, callback, context);
9 | } else {
10 | Events.on(this, eventName, callback);
11 | }
12 | return this;
13 | };
14 | }
15 |
16 | var methods = {
17 | on: function (eventName, callback, context) {
18 | if (arguments.length > 2) {
19 | Events.on(this, eventName, callback, context);
20 | } else {
21 | Events.on(this, eventName, callback);
22 | }
23 | return this;
24 | },
25 |
26 | once: function (eventNames, callback, thisArg) {
27 | Events.once(this, eventNames, callback, thisArg);
28 | },
29 |
30 | off: function (eventName, callback) {
31 | Events.off(this, eventName, callback);
32 | },
33 |
34 | trigger: function (eventName) {
35 | Events.trigger(this, eventName, blocks.toArray(arguments).slice(1, 100));
36 | }
37 | };
38 | methods._trigger = methods.trigger;
39 |
40 | return {
41 | register: function (object, eventNames) {
42 | eventNames = blocks.isArray(eventNames) ? eventNames : [eventNames];
43 | for (var i = 0; i < eventNames.length; i++) {
44 | var methodName = eventNames[i];
45 | if (methods[methodName]) {
46 | object[methodName] = methods[methodName];
47 | } else {
48 | object[methodName] = createEventMethod(methodName);
49 | }
50 | }
51 | },
52 |
53 | on: function (object, eventNames, callback, thisArg) {
54 | eventNames = blocks.toArray(eventNames).join(' ').split(' ');
55 |
56 | var i = 0;
57 | var length = eventNames.length;
58 | var eventName;
59 |
60 | if (!callback) {
61 | return;
62 | }
63 |
64 | if (!object._events) {
65 | object._events = {};
66 | }
67 | for (; i < length; i++) {
68 | eventName = eventNames[i];
69 | if (!object._events[eventName]) {
70 | object._events[eventName] = [];
71 | }
72 | object._events[eventName].push({
73 | callback: callback,
74 | thisArg: thisArg
75 | });
76 | }
77 | },
78 |
79 | once: function (object, eventNames, callback, thisArg) {
80 | Events.on(object, eventNames, callback, thisArg);
81 | Events.on(object, eventNames, function () {
82 | Events.off(object, eventNames, callback);
83 | });
84 | },
85 |
86 | off: function (object, eventName, callback) {
87 | if (blocks.isFunction(eventName)) {
88 | callback = eventName;
89 | eventName = undefined;
90 | }
91 |
92 | if (eventName !== undefined || callback !== undefined) {
93 | blocks.each(object._events, function (events, currentEventName) {
94 | if (eventName !== undefined && callback === undefined) {
95 | object._events[eventName] = [];
96 | } else {
97 | blocks.each(events, function (eventData, index) {
98 | if (eventData.callback == callback) {
99 | object._events[currentEventName].splice(index, 1);
100 | return false;
101 | }
102 | });
103 | }
104 | });
105 | } else {
106 | object._events = undefined;
107 | }
108 | },
109 |
110 | trigger: function (object, eventName) {
111 | var result = true;
112 | var eventsData;
113 | var thisArg;
114 | var args;
115 |
116 | if (object && object._events) {
117 | eventsData = object._events[eventName];
118 |
119 | if (eventsData && eventsData.length > 0) {
120 | args = Array.prototype.slice.call(arguments, 2);
121 |
122 | blocks.each(eventsData, function iterateEventsData(eventData) {
123 | if (eventData) {
124 | thisArg = object;
125 | if (eventData.thisArg !== undefined) {
126 | thisArg = eventData.thisArg;
127 | }
128 | if (eventData.callback.apply(thisArg, args) === false) {
129 | result = false;
130 | }
131 | }
132 | });
133 | }
134 | }
135 |
136 | return result;
137 | },
138 |
139 | has: function (object, eventName) {
140 | return !!blocks.access(object, '_events.' + eventName + '.length');
141 | }
142 | };
143 | })();
144 |
145 | return Events;
146 | });
--------------------------------------------------------------------------------
/src/modules/Request.js:
--------------------------------------------------------------------------------
1 | define([
2 | '../core',
3 | '../modules/uniqueId',
4 | '../query/serverData'
5 | ], function (blocks, uniqueId, serverData) {
6 | function Request(options) {
7 | this.options = blocks.extend({}, Request.Defaults, options);
8 | this.execute();
9 | }
10 |
11 | Request.Execute = function (options) {
12 | return new Request(options);
13 | };
14 |
15 | Request.Defaults = {
16 | type: 'GET',
17 | url: '',
18 | processData: true,
19 | async: true,
20 | contentType: 'application/x-www-form-urlencoded; charset=UTF-8',
21 | jsonp: 'callback',
22 | jsonpCallback: function () {
23 | return uniqueId();
24 | }
25 |
26 | /*
27 | timeout: 0,
28 | data: null,
29 | dataType: null,
30 | username: null,
31 | password: null,
32 | cache: null,
33 | throws: false,
34 | traditional: false,
35 | headers: {},
36 | */
37 | };
38 |
39 | Request.Accepts = {
40 | '*': '*/'.concat('*'),
41 | text: 'text/plain',
42 | html: 'text/html',
43 | xml: 'application/xml, text/xml',
44 | json: 'application/json, text/javascript'
45 | };
46 |
47 | Request.Meta = {
48 | statusFix: {
49 | // file protocol always yields status code 0, assume 200
50 | 0: 200,
51 | // Support: IE9
52 | // IE sometimes returns 1223 instead of 204
53 | 1223: 204
54 | }
55 | };
56 |
57 | Request.prototype = {
58 | execute: function () {
59 | var options = this.options;
60 |
61 | if (options.type == 'GET' && options.data) {
62 | this.appendDataToUrl(options.data);
63 | }
64 |
65 | if (serverData.hasData && serverData.data.requests && serverData.data.requests[options.url]) {
66 | setTimeout(function (self) {
67 | self.callSuccess(serverData.data.requests[options.url]);
68 | }, 5, this);
69 | } else {
70 | try {
71 | if (options.dataType == 'jsonp') {
72 | this.scriptRequest();
73 | } else {
74 | this.xhrRequest();
75 | }
76 | } catch (e) {
77 |
78 | }
79 | }
80 | },
81 |
82 | xhrRequest: function () {
83 | var options = this.options;
84 | var xhr = this.createXHR();
85 |
86 | xhr.onabort = blocks.bind(this.xhrError, this);
87 | xhr.ontimeout = blocks.bind(this.xhrError, this);
88 | xhr.onload = blocks.bind(this.xhrLoad, this);
89 | xhr.onerror = blocks.bind(this.xhrError, this);
90 | xhr.open(options.type.toUpperCase(), options.url, options.async, options.username, options.password);
91 | xhr.setRequestHeader('Content-Type', options.contentType);
92 | xhr.setRequestHeader('Accept', Request.Accepts[options.dataType || '*']);
93 | xhr.send(options.data || null);
94 | },
95 |
96 | createXHR: function () {
97 | var Type = XMLHttpRequest || window.ActiveXObject;
98 | try {
99 | return new Type('Microsoft.XMLHTTP');
100 | } catch (e) {
101 |
102 | }
103 | },
104 |
105 | xhrLoad: function (e) {
106 | var request = e.target;
107 | var status = Request.Meta.statusFix[request.status] || request.status;
108 | var isSuccess = status >= 200 && status < 300 || status === 304;
109 | if (isSuccess) {
110 | this.callSuccess(request.responseText);
111 | } else {
112 | this.callError(request.statusText);
113 | }
114 | },
115 |
116 | xhrError: function () {
117 | this.callError();
118 | },
119 |
120 | scriptRequest: function () {
121 | var that = this;
122 | var options = this.options;
123 | var script = document.createElement('script');
124 | var jsonpCallback = {};
125 | var callbackName = blocks.isFunction(options.jsonpCallback) ? options.jsonpCallback() : options.jsonpCallback;
126 |
127 | jsonpCallback[options.jsonp] = callbackName;
128 | this.appendDataToUrl(jsonpCallback);
129 | window[callbackName] = function (result) {
130 | window[callbackName] = null;
131 | that.scriptLoad(result);
132 | };
133 |
134 | script.onerror = this.scriptError;
135 | script.async = options.async;
136 | script.src = options.url;
137 | document.head.appendChild(script);
138 | },
139 |
140 | scriptLoad: function (data) {
141 | this.callSuccess(data);
142 | },
143 |
144 | scriptError: function () {
145 | this.callError();
146 | },
147 |
148 | appendDataToUrl: function (data) {
149 | var that = this;
150 | var options = this.options;
151 | var hasParameter = /\?/.test(options.url);
152 |
153 | if (blocks.isPlainObject(data)) {
154 | blocks.each(data, function (value, key) {
155 | options.url += that.append(hasParameter, key, value.toString());
156 | });
157 | } else if (blocks.isArray(data)) {
158 | blocks.each(data, function (index, value) {
159 | that.appendDataToUrl(value);
160 | });
161 | } else {
162 | options.url += that.append(hasParameter, data.toString(), '');
163 | }
164 | },
165 |
166 | append: function (hasParameter, key, value) {
167 | var result = hasParameter ? '&' : '?';
168 | result += key;
169 | if (value) {
170 | result += '=' + value;
171 | }
172 | return result;
173 | },
174 |
175 | callSuccess: function (data) {
176 | var success = this.options.success;
177 | var textStatus = 'success';
178 | if (success) {
179 | success(data, textStatus, null);
180 | }
181 | this.callComplete(textStatus);
182 | },
183 |
184 | callError: function (errorThrown) {
185 | var error = this.options.error;
186 | var textStatus = 'error';
187 | if (error) {
188 | error(null, textStatus, errorThrown);
189 | }
190 | this.callComplete(textStatus);
191 | },
192 |
193 | callComplete: function (textStatus) {
194 | var complete = this.options.complete;
195 | if (complete) {
196 | complete(null, textStatus);
197 | }
198 | }
199 | };
200 | return Request;
201 | });
202 |
--------------------------------------------------------------------------------
/src/modules/ajax.js:
--------------------------------------------------------------------------------
1 | define([
2 | './Request'
3 | ], function (Request) {
4 | function ajax(options) {
5 | if (window) {
6 | var jQuery = window.jQuery || window.$;
7 | if (jQuery && jQuery.ajax) {
8 | jQuery.ajax(options);
9 | } else {
10 | Request.Execute(options);
11 | }
12 | }
13 | }
14 |
15 | return ajax;
16 | });
--------------------------------------------------------------------------------
/src/modules/createProperty.js:
--------------------------------------------------------------------------------
1 | define(function () {
2 | function createProperty(propertyName) {
3 | return function (value) {
4 | if (arguments.length === 0) {
5 | return this[propertyName];
6 | }
7 | this[propertyName] = value;
8 | return this;
9 | };
10 | }
11 |
12 | return createProperty;
13 | });
--------------------------------------------------------------------------------
/src/modules/keys.js:
--------------------------------------------------------------------------------
1 | define(function () {
2 | function keys(array) {
3 | var result = {};
4 | blocks.each(array, function (value) {
5 | result[value] = true;
6 | });
7 | return result;
8 | }
9 |
10 | return keys;
11 | });
--------------------------------------------------------------------------------
/src/modules/parseCallback.js:
--------------------------------------------------------------------------------
1 | define(function () {
2 | function parseCallback(callback, thisArg) {
3 | //callback = parseExpression(callback);
4 | if (thisArg != null) {
5 | var orgCallback = callback;
6 | callback = function (value, index, collection) {
7 | return orgCallback.call(thisArg, value, index, collection);
8 | };
9 | }
10 | return callback;
11 | }
12 |
13 | return parseCallback;
14 | });
--------------------------------------------------------------------------------
/src/modules/uniqueId.js:
--------------------------------------------------------------------------------
1 | define([
2 | '../core'
3 | ], function (blocks) {
4 | var uniqueId = (function () {
5 | var timeStamp = Date.now();
6 | return function () {
7 | return 'blocks_' + blocks.version + '_' + timeStamp++;
8 | };
9 | })();
10 |
11 | return uniqueId;
12 | });
13 |
--------------------------------------------------------------------------------
/src/mvc.js:
--------------------------------------------------------------------------------
1 | define([
2 | './core',
3 | './query',
4 | './mvc/queries',
5 | './mvc/validators',
6 | './mvc/validation',
7 | './mvc/Application'
8 | ], function () {
9 |
10 | });
11 |
--------------------------------------------------------------------------------
/src/mvc/Property.js:
--------------------------------------------------------------------------------
1 | define([
2 | '../core'
3 | ], function (blocks) {
4 | function Property(options) {
5 | this._options = options || {};
6 | }
7 |
8 | Property.Is = function (value) {
9 | return Property.prototype.isPrototypeOf(value);
10 | };
11 |
12 | Property.Inflate = function (object) {
13 | var properties = {};
14 | var key;
15 | var value;
16 | var defaultValue;
17 |
18 | for (key in object) {
19 | value = object[key];
20 | if (Property.Is(value)) {
21 | value = value._options;
22 | defaultValue = value.defaultValue;
23 | value.propertyName = key;
24 | properties[value.field || key] = value;
25 | }
26 | }
27 |
28 | return properties;
29 | };
30 |
31 | Property.Create = function (options, thisArg, value) {
32 | var observable;
33 |
34 | if (arguments.length < 3) {
35 | value = options.value || options.defaultValue;
36 | }
37 | thisArg = options.thisArg ? options.thisArg : thisArg;
38 |
39 | value = blocks.clone(value);
40 |
41 | observable = blocks
42 | .observable(value, thisArg)
43 | .extend('validation', options)
44 | .on('changing', options.changing, thisArg)
45 | .on('change', options.change, thisArg);
46 |
47 | if (options.extenders) {
48 | blocks.each(options.extenders, function (extendee) {
49 | observable = observable.extend.apply(observable, extendee);
50 | });
51 | }
52 |
53 | return observable;
54 | };
55 |
56 | Property.prototype.extend = function () {
57 | var options = this._options;
58 | options.extenders = options.extenders || [];
59 | options.extenders.push(blocks.toArray(arguments));
60 |
61 | return this;
62 | };
63 | return Property;
64 | });
65 |
--------------------------------------------------------------------------------
/src/mvc/View.js:
--------------------------------------------------------------------------------
1 | define([
2 | '../core',
3 | '../modules/ajax',
4 | '../modules/Events',
5 | './bindContext',
6 | '../query/serverData'
7 | ], function (blocks, ajax, Events, bindContext, serverData) {
8 | /**
9 | * @namespace View
10 | */
11 | function View(application, parentView) {
12 | var _this = this;
13 |
14 | bindContext(this);
15 | this._views = [];
16 | this._application = application;
17 | this._parentView = parentView || null;
18 | this._initCalled = false;
19 | this._html = undefined;
20 |
21 | this.loading = blocks.observable(false);
22 | this.isActive = blocks.observable(!blocks.has(this.options, 'route'));
23 | this.isActive.on('changing', function (oldValue, newValue) {
24 | _this._tryInitialize(newValue);
25 | });
26 |
27 | if (this.options.preload || this.isActive()) {
28 | this._load();
29 | }
30 | }
31 |
32 | View.prototype = {
33 | /**
34 | * Determines if the view is visible or not.
35 | * This property is automatically populated when routing is enabled for the view.
36 | *
37 | * @memberof View
38 | * @name isActive
39 | * @type {blocks.observable}
40 | */
41 |
42 | /**
43 | * Override the init method to perform actions when the View is first created
44 | * and shown on the page
45 | *
46 | * @memberof View
47 | * @type {Function}
48 | *
49 | * @example {javascript}
50 | * var App = blocks.Application();
51 | *
52 | * App.View('Statistics', {
53 | * init: function () {
54 | * this.loadRemoteData();
55 | * },
56 | *
57 | * loadRemoteData: function () {
58 | * // ...stuff...
59 | * }
60 | * });
61 | */
62 | init: blocks.noop,
63 |
64 | /**
65 | * Override the ready method to perform actions when the DOM is ready and
66 | * all data-query have been executed.
67 | *
68 | * @memberof View
69 | * @type {Function}
70 | *
71 | * @example {javascript}
72 | * var App = blocks.Application();
73 | *
74 | * App.View('ContactUs', {
75 | * ready: function () {
76 | * $('#contact-form').ajaxSubmit();
77 | * }
78 | * });
79 | */
80 | ready: blocks.noop,
81 |
82 | /**
83 | * Override the routed method to perform actions when the View have routing and routing
84 | * mechanism actives it.
85 | *
86 | * @memberof View
87 | * @type {Function}
88 | *
89 | * @example {javascript}
90 | * var App = blocks.Application();
91 | *
92 | * App.View('ContactUs', {
93 | * options: {
94 | * route: 'contactus'
95 | * },
96 | *
97 | * routed: function () {
98 | * alert('Navigated to ContactUs page!')
99 | * }
100 | * });
101 | */
102 | routed: blocks.noop,
103 |
104 | /**
105 | * Observable which value is true when the View html
106 | * is being loaded using ajax request. It could be used
107 | * to show a loading indicator.
108 | *
109 | * @memberof View
110 | */
111 | loading: blocks.observable(false),
112 |
113 | /**
114 | * Gets the parent view.
115 | * Returns null if the view is not a child of another view.
116 | *
117 | * @memberof View
118 | */
119 | parentView: function () {
120 | return this._parentView;
121 | },
122 |
123 | /**
124 | * Routes to a specific URL and actives the appropriate views associated with the URL
125 | *
126 | * @memberof View
127 | * @param {String} name -
128 | * @returns {View} - Chainable. Returns this
129 | *
130 | * @example {javascript}
131 | * var App = blocks.Application();
132 | *
133 | * App.View('ContactUs', {
134 | * options: {
135 | * route: 'contactus'
136 | * }
137 | * });
138 | *
139 | * App.View('Navigation', {
140 | * navigateToContactUs: function () {
141 | * this.route('contactus')
142 | * }
143 | * });
144 | */
145 | route: function (/* name */ /*, ...params */) {
146 | this._application._history.navigate(blocks.toArray(arguments).join('/'));
147 | return this;
148 | },
149 |
150 | navigateTo: function (view, params) {
151 | this._application.navigateTo(view, params);
152 | },
153 |
154 | _tryInitialize: function (isActive) {
155 | if (!this._initialized && isActive) {
156 | if (this.options.url && !this._html) {
157 | this._callInit();
158 | this._load();
159 | } else {
160 | this._initialized = true;
161 | this._callInit();
162 | if (this.isActive()) {
163 | this.isActive.update();
164 | }
165 | }
166 | }
167 | },
168 |
169 | _routed: function (params, metadata) {
170 | this._tryInitialize(true);
171 | this.routed(params, metadata);
172 | blocks.each(this._views, function (view) {
173 | if (!view.options.route) {
174 | view._routed(params, metadata);
175 | }
176 | });
177 | this.isActive(true);
178 | },
179 |
180 | _callInit: function () {
181 | if (this._initCalled) {
182 | return;
183 | }
184 |
185 | var key;
186 | var value;
187 |
188 | blocks.__viewInInitialize__ = this;
189 | for (key in this) {
190 | value = this[key];
191 | if (blocks.isObservable(value)) {
192 | value.__context__ = this;
193 | }
194 | }
195 | this.init();
196 | blocks.__viewInInitialize__ = undefined;
197 | this._initCalled = true;
198 | },
199 |
200 | _load: function () {
201 | var url = this.options.url;
202 | if (serverData.hasData && serverData.data.views && serverData.data.views[url]) {
203 | url = this.options.url = undefined;
204 | this._tryInitialize(true);
205 | }
206 |
207 | if (url && !this.loading()) {
208 | this.loading(true);
209 | ajax({
210 | isView: true,
211 | url: url,
212 | success: blocks.bind(this._loaded, this),
213 | error: blocks.bind(this._error, this)
214 | });
215 | }
216 | },
217 |
218 | _loaded: function (html) {
219 | this._html = html;
220 | this._tryInitialize(true);
221 | this.loading(false);
222 | },
223 |
224 | _error: function () {
225 | this.loading(false);
226 | },
227 | // View is a singleton so return a reference
228 | clone: function () {
229 | return this;
230 | }
231 | };
232 |
233 | Events.register(View.prototype, ['on', 'off', 'trigger']);
234 |
235 | /* @if DEBUG */ {
236 | blocks.debug.addType('View', function (value) {
237 | if (value && View.prototype.isPrototypeOf(value)) {
238 | return true;
239 | }
240 | return false;
241 | });
242 | } /* @endif */
243 | return View;
244 | });
245 |
--------------------------------------------------------------------------------
/src/mvc/bindContext.js:
--------------------------------------------------------------------------------
1 | define([
2 | '../core'
3 | ], function (blocks) {
4 | function bindContext (context, object) {
5 | var key;
6 | var value;
7 | /* @if DEBUG */ blocks.debug.pause(); /* @endif */
8 | if (!object) {
9 | object = context;
10 | }
11 |
12 | for (key in object) {
13 | value = object[key];
14 |
15 | if (blocks.isObservable(value)) {
16 | context[key].__context__ = context;
17 | } else if (blocks.isFunction(value)) {
18 | context[key] = blocks.bind(value, context);
19 | }
20 |
21 | }
22 | /* @if DEBUG */ blocks.debug.resume(); /* @endif */
23 | }
24 | return bindContext;
25 | });
--------------------------------------------------------------------------------
/src/mvc/clonePrototype.js:
--------------------------------------------------------------------------------
1 | define([
2 | './Model',
3 | './Property'
4 | ], function (Model, Property) {
5 | function clonePrototype(prototype, object) {
6 | var key;
7 | var value;
8 |
9 | for (key in prototype) {
10 | value = prototype[key];
11 | if (Property.Is(value)) {
12 | continue;
13 | }
14 |
15 | if (blocks.isObservable(value)) {
16 | // clone the observable and also its value by passing true to the clone method
17 | object[key] = value.clone(true);
18 | object[key].__context__ = object;
19 | } else if (blocks.isFunction(value)) {
20 | object[key] = blocks.bind(value, object);
21 | } else if (Model.prototype.isPrototypeOf(value)) {
22 | object[key] = value.clone(true);
23 | } else if (blocks.isObject(value) && !blocks.isPlainObject(value)) {
24 | object[key] = blocks.clone(value, true);
25 | } else {
26 | object[key] = blocks.clone(value, true);
27 | }
28 | }
29 | }
30 |
31 | return clonePrototype;
32 | });
33 |
--------------------------------------------------------------------------------
/src/mvc/queries.js:
--------------------------------------------------------------------------------
1 | define([
2 | '../core',
3 | '../query/var/queries',
4 | '../query/animation',
5 | '../query/addListener',
6 | '../query/createVirtual',
7 | '../query/VirtualElement',
8 | '../query/Expression'
9 | ], function (blocks, queries, animation, addListener, createVirtual, VirtualElement, Expression) {
10 | blocks.extend(blocks.queries, {
11 | /**
12 | * Associates the element with the particular view and creates a $view context property.
13 | * The View will be automatically hidden and shown if the view have routing. The visibility
14 | * of the View could be also controlled using the isActive observable property
15 | *
16 | * @memberof blocks.queries
17 | * @param {View} view - The view to associate with the current element
18 | *
19 | * @example {html}
20 | *
21 | * | 17 | 18 | | 19 |