Top 10 Examples of "falcor in functional component" in JavaScript

import Falcor from 'falcor';
import bodyParser from 'body-parser';
import HttpDataSource from 'falcor-http-datasource';

const SERVER_PORT = 15649;
const FALCOR_MODEL = '/model.json';
const FALCOR_MODEL_URL = `http://localhost:${SERVER_PORT}${FALCOR_MODEL}`;

let instance = null;

// Initialize Falcor HTTP client:
const testModel = new Falcor.Model(
	{ source: new HttpDataSource(FALCOR_MODEL_URL) }
);

const batchTestModel = new Falcor.Model(
	{ source: new HttpDataSource(FALCOR_MODEL_URL) }
);

export class TestServer {
	constructor() {
    if (!instance) {
			instance = this;
			this.app = express();
    }
    return instance;
	}

	refresh() {
		this.app = express();
		return this.app;
	}

//                });
//
//                return results
//            }
//        }
//    ]);
//}));

//console.log(JSON.stringify(yearInvoices.invoicesById,null,2));
app.use('/mfcr.json',falcorExpress.dataSourceRoute(function (req, res) {
    return mfcrDataSource;
}));


var dataSource =
    new falcor.Model({
        cache: {
            todos: [
                { $type: "ref", value: ['todosById', 1450000365] },
                { $type: "ref", value: ['todosById', 54] },
                { $type: "ref", value: ['todosById', 97] },
                { $type: "ref", value: ['todosById', 197] }
            ],
            todosById: {
                "1450000365": {
                    name: 'get milk from corner store',
                    done: false,
                    prerequisites: [
                        { $type: "ref", value: ['todosById', 54] },
                        { $type: "ref", value: ['todosById', 97] }
                    ]
                },

import { ModalProvider } from 'components/admin/hocs/modals/ModalProvider';
import HttpDataSource from 'falcor-http-datasource';
import { MuiThemeProvider } from 'material-ui';
import { Provider as FalcorProvider } from 'react-falcor';

/** We need to initialize the logger */
import { initializeLogger } from 'lib/logger';

// We start with window.alert as our alert function but later will replace
// it with our alert function from ModalProvider
initializeLogger(true, window.alert);

// Set app ready so falcor doesn't try to load from cache
setAppReady();

const clientModel = new falcor.Model({
  source: new HttpDataSource('/model.json'),
});

ReactDOM.render(
  
    
      
        
      
    
  ,
  document.getElementById('main'),

// Merging pathsets
  falcorPaths = falcorPaths.reduce((currentPathSets, nextPathSet) => {
    if (nextPathSet[0] instanceof Array) {
      return currentPathSets.concat(nextPathSet);
    }
    currentPathSets.push(nextPathSet);
    return currentPathSets;
  }, []);

  // create a new model for this specific request
  // the reason we do this is so that the serverModel
  // cache won't expire records we need during the unlikely
  // event of heavy concurrent and unique traffic
  // And also it creates the minimum set of data we can send down
  // to the client and reload on the falcor there
  const localModel = new falcor.Model({ source: serverModel.asDataSource() });

  // If the component doesn't want any data
  if (
    !falcorPaths ||
    falcorPaths.length === 0 ||
    falcorPaths[0].length === 0 &&
    falcorPaths.length === 1
  ) {
    return new Promise((resolve) => {
      resolve(
        buildMainHtmlString(
          renderToString(

import falcor from 'falcor'
import HttpDataSource from 'falcor-http-datasource'

let url = '/model.json'
if (process.env.NODE_ENV === 'development') {
	url = 'http://127.0.0.1:3000/model.json'
}

// dataModel 按对象实体划分
export const dataModel = new falcor.Model({
	source: new HttpDataSource(url),
})

// uiModel 按 route component 划分
export const uiModel = new falcor.Model({
	cache: {
		articleList: {
			page: 1,
		},
	},
})

if (global.dataCache) {
	dataModel.setCache(global.dataCache)
}

var gulp = require('gulp');
var fs = require('fs');
var path = require('path');
var _ = require('lodash');
var moment = require('moment');
var EOL = require('os').EOL;
var falcorModel = require('falcor').Model;
var $ref = falcorModel.ref;
var $atom = falcorModel.atom;

// Some constants
var OUTPUT_FILE_NAME = 'sample-data-cache.js';
var OUTPUT_FOLDER = './src/js/stores';

// Sample data JSON
var videos = require('../data/videos.json');
var users = require('../data/users.json');
var comments = require('../data/comments.json');

// Helper function for generating an int from part of a UUID
function getIntFromPartOfUuid(uuid, startIdx, numChars, maxValue) {
  var hex = uuid.substr(startIdx, numChars);
  return parseInt('0x' + hex) % maxValue;
}

var gulp = require('gulp');
var fs = require('fs');
var path = require('path');
var _ = require('lodash');
var moment = require('moment');
var EOL = require('os').EOL;
var falcorModel = require('falcor').Model;
var $ref = falcorModel.ref;
var $atom = falcorModel.atom;

// Some constants
var OUTPUT_FILE_NAME = 'sample-data-cache.js';
var OUTPUT_FOLDER = './src/js/stores';

// Sample data JSON
var videos = require('../data/videos.json');
var users = require('../data/users.json');
var comments = require('../data/comments.json');

// Helper function for generating an int from part of a UUID
function getIntFromPartOfUuid(uuid, startIdx, numChars, maxValue) {
  var hex = uuid.substr(startIdx, numChars);
  return parseInt('0x' + hex) % maxValue;
}

export function cleanupFalcorKeys(obj) {
  if (obj === null || (typeof obj) !== 'object' || obj.cleanupFalcorKeysMetaSeen) return obj;
  const ret = {};
  // In order to handle circular objects, the key name is convoluted to make sure it's unique
  obj.cleanupFalcorKeysMetaSeen = true; // eslint-disable-line no-param-reassign
  falcor.keys(obj).forEach(key => {
    if (key === 'cleanupFalcorKeysMetaSeen') return;
    ret[key] = cleanupFalcorKeys(obj[key]);
  });
  // Cleanup to not have mutated the object
  delete obj.cleanupFalcorKeysMetaSeen; // eslint-disable-line no-param-reassign
  return ret;
}

var Keys = require('../Keys');
var Precedence = require('../Precedence');
var Observable = require('falcor').Observable;
var PrecedenceProcessor = {
    execute: executeByPrecedence
};
module.exports = PrecedenceProcessor;

function executeByPrecedence(paths, matches, method, context, valueObject) {

    // process until there are no more paths or no more matches.
    var matched;
    var newPerms;
    var matchedPaths;
    var i = 0;
    var generatedResults;
    var results = [];
    while (paths.length && matches.length) {
        matched = matches.shift();

it('should perform reference following.', function(done) {
        var router = new R(
            Routes().Videos.Integers.Summary().concat(
              Routes().Genrelists.Integers()
            )
        );
        var model = new falcor.Model({
            source: router
        });
        var called = false;

        model.get(['genreLists', 0, 'summary']).subscribe(
            function (x) {
                called = true;
                expect(x).to.deep.equals({
                    json: {
                        genreLists: {
                            0: {
                                summary: {
                                    title: 'Some Movie 0'
                                }
                            }
                        }