Datasets:

Anonymous2023

/

dataset2js

like 0

[ "function", "loadSchemas", "(", "ajv", ")", "{", "var", "metaSchema", "=", "helper", ".", "require", "(", "'/lib/task-data/schemas/rackhd-task-schema.json'", ")", ";", "ajv", ".", "addMetaSchema", "(", "metaSchema", ",", "'rackhd-task-schema.json'", ")", ";", "var", "fileNames", "=", "glob", ".", "sync", "(", "helper", ".", "relativeToRoot", "(", "'/lib/task-data/schemas/*.json'", ")", ")", ";", "_", "(", "fileNames", ")", ".", "filter", "(", "function", "(", "filename", ")", "{", "return", "path", ".", "basename", "(", "filename", ")", "!==", "'rackhd-task-schema.json'", ";", "}", ")", ".", "forEach", "(", "function", "(", "filename", ")", "{", "try", "{", "var", "data", "=", "fs", ".", "readFileSync", "(", "filename", ")", ".", "toString", "(", ")", ";", "jsonlint", ".", "parse", "(", "data", ")", ";", "ajv", ".", "addSchema", "(", "JSON", ".", "parse", "(", "data", ")", ",", "path", ".", "basename", "(", "filename", ")", ")", ";", "}", "catch", "(", "err", ")", "{", "console", ".", "error", "(", "'fail to add schema: '", "+", "filename", ")", ";", "throw", "err", ";", "}", "}", ")", ".", "value", "(", ")", ";", "return", "ajv", ";", "}" ]

[ "load", "all", "schemas", "into", "the", "validator", "to", "resolve", "all", "schema", "references" ]

[ "function", "getSchema", "(", "ajv", ",", "name", ")", "{", "var", "result", "=", "ajv", ".", "getSchema", "(", "name", ")", ";", "if", "(", "!", "result", "||", "!", "result", ".", "schema", ")", "{", "throw", "new", "Error", "(", "'cannot find the schema with name \"'", "+", "name", "+", "'\".'", ")", ";", "}", "return", "result", ".", "schema", ";", "}" ]

[ "Get", "the", "schema", "definition", "via", "name" ]

[ "function", "validateData", "(", "validator", ",", "schemaId", ",", "data", ",", "expected", ")", "{", "var", "result", "=", "validator", ".", "validate", "(", "schemaId", ",", "data", ")", ";", "if", "(", "!", "result", "&&", "expected", "||", "result", "&&", "!", "expected", ")", "{", "if", "(", "!", "result", ")", "{", "return", "new", "Error", "(", "validator", ".", "errorsText", "(", ")", ")", ";", "}", "else", "{", "return", "new", "Error", "(", "'expected schema violation, but get conformity.'", ")", ";", "}", "}", "}" ]

[ "validate", "the", "data", "against", "a", "schema" ]

[ "function", "getNumberOfTiles", "(", "options", ")", "{", "determineGroundResolution", "(", "options", ".", "tiles", ".", "resolutions", ")", ";", "let", "countOfAllTiles", "=", "0", ";", "let", "widthM", "=", "options", ".", "task", ".", "area", ".", "bbox", ".", "xmax", "-", "options", ".", "task", ".", "area", ".", "bbox", ".", "xmin", ";", "let", "heightM", "=", "options", ".", "task", ".", "area", ".", "bbox", ".", "ymax", "-", "options", ".", "task", ".", "area", ".", "bbox", ".", "ymin", ";", "for", "(", "let", "int", "=", "0", ";", "int", "<", "options", ".", "tiles", ".", "resolutions", ".", "length", ";", "int", "++", ")", "{", "let", "res", "=", "options", ".", "tiles", ".", "resolutions", "[", "int", "]", ";", "let", "widthPx", "=", "widthM", "/", "res", ".", "groundResolution", ";", "let", "heightPx", "=", "heightM", "/", "res", ".", "groundResolution", ";", "let", "tiles", "=", "{", "}", ";", "tiles", ".", "sizePx", "=", "options", ".", "tiles", ".", "maxSizePx", "-", "2", "*", "options", ".", "tiles", ".", "gutterPx", ";", "tiles", ".", "xCount", "=", "Math", ".", "ceil", "(", "widthPx", "/", "tiles", ".", "sizePx", ")", ";", "tiles", ".", "yCount", "=", "Math", ".", "ceil", "(", "heightPx", "/", "tiles", ".", "sizePx", ")", ";", "countOfAllTiles", "+=", "tiles", ".", "xCount", "*", "tiles", ".", "yCount", "*", "options", ".", "wms", ".", "length", ";", "}", "return", "countOfAllTiles", ";", "}" ]

[ "Calculates", "the", "number", "of", "tiles", "of", "a", "task", "." ]

[ "function", "handleTask", "(", "options", ",", "config", ",", "progress", ",", "callback", ")", "{", "fs", ".", "ensureDir", "(", "options", ".", "task", ".", "workspace", ",", "(", "err", ")", "=>", "{", "if", "(", "err", ")", "{", "callback", "(", "err", ")", ";", "}", "else", "{", "let", "ws", "=", "options", ".", "task", ".", "workspace", "+", "'/'", "+", "options", ".", "task", ".", "id", ";", "fs", ".", "ensureDir", "(", "ws", ",", "(", "err", ")", "=>", "{", "if", "(", "err", ")", "{", "callback", "(", "err", ")", ";", "}", "else", "{", "handleResolution", "(", "options", ",", "ws", ",", "0", ",", "config", ",", "progress", ",", "(", "err", ")", "=>", "{", "if", "(", "err", ")", "{", "callback", "(", "err", ")", ";", "}", "else", "{", "callback", "(", "null", ")", ";", "}", "}", ")", ";", "}", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "It", "handles", "a", "download", "task", "of", "Web", "Map", "Services", "." ]

[ "function", "load", "(", "buf", ",", "file", ",", "cfg", ")", "{", "if", "(", "typeof", "buf", "!==", "'string'", ")", "{", "throw", "new", "TypeError", "(", "'First argument must be a string.'", ")", ";", "}", "cfg", "=", "Object", ".", "assign", "(", "{", "maps", ":", "false", ",", "lang", ":", "{", "script", ":", "'js'", ",", "template", ":", "'html'", "}", ",", "plugins", ":", "{", "}", ",", "}", ",", "cfg", ")", ";", "let", "vue", "=", "{", "}", ";", "for", "(", "let", "section", "of", "extract", "(", "buf", ",", "[", "'script'", ",", "'template'", "]", ")", ")", "{", "let", "attrs", "=", "section", ".", "attrs", ";", "let", "lang", "=", "has", "(", "attrs", ",", "'lang'", ")", "?", "attrs", ".", "lang", ":", "cfg", ".", "lang", "[", "section", ".", "tag", "]", ";", "if", "(", "has", "(", "attrs", ",", "'src'", ")", ")", "{", "let", "dir", "=", "file", "?", "path", ".", "dirname", "(", "file", ")", ":", "process", ".", "cwd", "(", ")", ";", "file", "=", "path", ".", "resolve", "(", "dir", ",", "attrs", ".", "src", ")", ";", "section", ".", "text", "=", "fs", ".", "readFileSync", "(", "file", ",", "'utf8'", ")", ";", "}", "let", "transpiled", "=", "transpile", "(", "lang", ",", "section", ".", "text", ",", "{", "file", ",", "maps", ":", "cfg", ".", "maps", ",", "offset", ":", "section", ".", "offset", ",", "extra", ":", "Object", ".", "assign", "(", "{", "}", ",", "cfg", ".", "plugins", "[", "lang", "]", ")", ",", "}", ")", ";", "vue", "[", "section", ".", "tag", "]", "=", "transpiled", ".", "data", ";", "if", "(", "cfg", ".", "maps", "&&", "transpiled", ".", "map", ")", "{", "sourceMapsCache", ".", "set", "(", "file", ",", "transpiled", ".", "map", ")", ";", "}", "}", "vue", ".", "script", "+=", "injectTemplate", "(", "vue", ".", "template", ")", ";", "return", "vue", ".", "script", ";", "}" ]

[ "Parses", "SFC", "high", "level", "API", "." ]

[ "function", "unregister", "(", ")", "{", "let", "list", "=", "[", "]", ";", "let", "unload", "=", "(", "id", ")", "=>", "{", "let", "module", "=", "require", ".", "cache", "[", "id", "]", ";", "if", "(", "!", "module", ")", "return", ";", "module", ".", "children", ".", "forEach", "(", "(", "child", ")", "=>", "unload", "(", "child", ".", "id", ")", ")", ";", "delete", "require", ".", "cache", "[", "id", "]", ";", "list", ".", "push", "(", "id", ")", ";", "}", ";", "let", "sourceMapSupport", "=", "require", ".", "resolve", "(", "'source-map-support'", ")", ";", "Object", ".", "keys", "(", "require", ".", "cache", ")", ".", "forEach", "(", "(", "key", ")", "=>", "{", "if", "(", "path", ".", "extname", "(", "key", ")", "===", "VUE_EXT", "||", "key", "===", "sourceMapSupport", ")", "{", "unload", "(", "key", ")", ";", "}", "}", ")", ";", "if", "(", "has", "(", "require", ".", "extensions", ",", "VUE_EXT", ")", ")", "{", "delete", "require", ".", "extensions", "[", "VUE_EXT", "]", ";", "}", "if", "(", "has", "(", "Error", ",", "'prepareStackTrace'", ")", ")", "{", "delete", "Error", ".", "prepareStackTrace", ";", "}", "sourceMapsCache", ".", "clear", "(", ")", ";", "return", "list", ";", "}" ]

[ "Removes", "requre", "hook", "." ]

[ "function", "transpile", "(", "lang", ",", "text", ",", "options", ")", "{", "let", "plugin", "=", "`", "${", "lang", "}", "`", ";", "let", "langs", "=", "{", "js", "(", ")", "{", "let", "map", "=", "(", "options", ".", "maps", "&&", "options", ".", "offset", ">", "0", ")", "?", "generateMap", "(", "text", ",", "options", ".", "file", ",", "options", ".", "offset", ")", ":", "null", ";", "return", "{", "data", ":", "text", ",", "map", "}", ";", "}", ",", "html", "(", ")", "{", "return", "{", "data", ":", "text", ",", "map", ":", "null", "}", ";", "}", ",", "error", "(", "err", ")", "{", "let", "error", "=", "`", "${", "plugin", "}", "`", "+", "os", ".", "EOL", "+", "err", ".", "message", ";", "throw", "new", "Error", "(", "error", ")", ";", "}", ",", "}", ";", "try", "{", "return", "require", "(", "plugin", ")", "(", "text", ",", "options", ")", ";", "}", "catch", "(", "err", ")", "{", "return", "(", "langs", "[", "lang", "]", "||", "langs", "[", "'error'", "]", "(", "err", ")", ")", "(", ")", ";", "}", "}" ]

[ "Passes", "given", "code", "to", "the", "external", "plugin", "." ]

[ "function", "generateMap", "(", "content", ",", "file", ",", "offset", ")", "{", "if", "(", "offset", "<=", "0", ")", "{", "throw", "new", "RangeError", "(", "'Offset parameter should be greater than zero.'", ")", ";", "}", "let", "generator", "=", "new", "sourceMap", ".", "SourceMapGenerator", "(", ")", ";", "let", "options", "=", "{", "locations", ":", "true", ",", "sourceType", ":", "'module'", ",", "}", ";", "for", "(", "let", "token", "of", "tokenizer", "(", "content", ",", "options", ")", ")", "{", "let", "position", "=", "token", ".", "loc", ".", "start", ";", "generator", ".", "addMapping", "(", "{", "source", ":", "file", ",", "original", ":", "{", "line", ":", "position", ".", "line", "+", "offset", ",", "column", ":", "position", ".", "column", "}", ",", "generated", ":", "position", ",", "name", ":", "token", ".", "value", ",", "}", ")", ";", "}", "return", "generator", ".", "toJSON", "(", ")", ";", "}" ]

[ "Generates", "source", "map", "for", "JavaScript", "." ]

[ "function", "installMapsSupport", "(", ")", "{", "require", "(", "'source-map-support'", ")", ".", "install", "(", "{", "environment", ":", "'node'", ",", "handleUncaughtExceptions", ":", "false", ",", "retrieveSourceMap", ":", "(", "source", ")", "=>", "{", "return", "sourceMapsCache", ".", "has", "(", "source", ")", "?", "{", "map", ":", "sourceMapsCache", ".", "get", "(", "source", ")", ",", "url", ":", "source", "}", ":", "null", ";", "}", ",", "}", ")", ";", "}" ]

[ "Installs", "handler", "on", "prepareStackTrace" ]

[ "function", "kill", "(", "cb", ")", "{", "if", "(", "!", "meteor", ")", "{", "return", "cb", "(", ")", ";", "}", "meteor", ".", "once", "(", "'exit'", ",", "function", "(", "code", ")", "{", "if", "(", "!", "code", "||", "code", "===", "0", "||", "code", "===", "130", ")", "{", "cb", "(", ")", ";", "}", "else", "{", "cb", "(", "new", "Error", "(", "'exited with code '", "+", "code", ")", ")", ";", "}", "}", ")", ";", "meteor", ".", "kill", "(", "'SIGINT'", ")", ";", "meteor", "=", "null", ";", "process", ".", "removeListener", "(", "'exit'", ",", "onProcessExit", ")", ";", "}" ]

[ "Kill", "the", "meteor", "process", "and", "cleanup", "." ]

[ "function", "getIgnoredFiles", "(", ")", "{", "const", "filePath", "=", "path", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "'.remarkignore'", ")", "const", "ignoredFilesSource", "=", "fs", ".", "existsSync", "(", "filePath", ")", "?", "fs", ".", "readFileSync", "(", "filePath", ",", "{", "encoding", ":", "'utf8'", "}", ")", ":", "''", "var", "ignoredFiles", "=", "ignoredFilesSource", ".", "split", "(", "'\\n'", ")", "\\n", "ignoredFiles", "=", "ignoredFiles", ".", "filter", "(", "function", "(", "item", ")", "{", "return", "item", "!==", "''", "}", ")", "}" ]

[ "The", "entries", "in", "the", "consumer", "s", ".", "remarkignore", "file" ]

[ "function", "(", "err", ")", "{", "\"use strict\"", ";", "var", "message", "=", "''", ";", "if", "(", "typeof", "err", "===", "'string'", ")", "{", "return", "new", "Error", "(", "err", ")", ";", "}", "else", "if", "(", "typeof", "err", "===", "'object'", ")", "{", "if", "(", "err", ".", "cause", ")", "{", "try", "{", "message", "=", "JSON", ".", "parse", "(", "err", ".", "cause", ".", "value", ".", "message", ")", ".", "errorMessage", ";", "}", "catch", "(", "$", ")", "{", "message", "=", "err", ".", "cause", ".", "value", ".", "message", ";", "}", "}", "else", "{", "message", "=", "err", ".", "message", "||", "err", ".", "toString", "(", ")", ";", "}", "return", "new", "Error", "(", "message", ")", ";", "}", "return", "new", "Error", "(", "err", ".", "toString", "(", ")", ")", ";", "}" ]

[ "Make", "an", "error", "comming", "from", "webdriver", "a", "little", "more", "readable", "." ]

[ "function", "(", ")", "{", "\"use strict\"", ";", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "var", "numberOfRetries", "=", "5", ";", "(", "function", "retry", "(", ")", "{", "var", "port", "=", "4000", "+", "Math", ".", "floor", "(", "Math", ".", "random", "(", ")", "*", "1000", ")", ";", "portscanner", ".", "checkPortStatus", "(", "port", ",", "'localhost'", ",", "function", "(", "err", ",", "status", ")", "{", "if", "(", "err", "||", "status", "!==", "'closed'", ")", "{", "if", "(", "--", "numberOfRetries", ">", "0", ")", "{", "setTimeout", "(", "retry", ")", ";", "}", "else", "{", "reject", "(", "'Cannot find a free port... giving up'", ")", ";", "}", "}", "else", "{", "resolve", "(", "port", ")", ";", "}", "}", ")", ";", "}", ")", "(", ")", ";", "}", ")", ";", "}" ]

[ "Find", "a", "port", "nobody", "is", "listening", "on", "." ]

[ "function", "(", "text", ",", "options", ")", "{", "\"use strict\"", ";", "var", "marginX", "=", "options", ".", "marginX", "!==", "undefined", "?", "options", ".", "marginX", ":", "2", ";", "var", "marginY", "=", "options", ".", "marginY", "!==", "undefined", "?", "options", ".", "marginY", ":", "1", ";", "var", "margin", "=", "new", "Array", "(", "marginX", "+", "1", ")", ".", "join", "(", "\" \"", ")", ";", "var", "indent", "=", "options", ".", "indent", "!==", "undefined", "?", "options", ".", "indent", ":", "\" \"", ";", "var", "maxLength", "=", "0", ";", "var", "linesOfText", "=", "text", ".", "split", "(", "'\\n'", ")", ";", "\\n", "var", "pattern", "=", "options", ".", "pattern", "||", "{", "T", ":", "\"/\"", ",", "B", ":", "\"/\"", ",", "TR", ":", "\"//\"", ",", "BR", ":", "\"//\"", ",", "TL", ":", "\"//\"", ",", "BL", ":", "\"//\"", ",", "R", ":", "\"//\"", ",", "L", ":", "\"//\"", "}", ";", "linesOfText", ".", "forEach", "(", "function", "(", "line", ")", "{", "maxLength", "=", "Math", ".", "max", "(", "maxLength", ",", "line", ".", "length", ")", ";", "}", ")", ";", "var", "top", "=", "pattern", ".", "TL", "+", "new", "Array", "(", "2", "*", "marginX", "+", "maxLength", "+", "1", ")", ".", "join", "(", "pattern", ".", "T", ")", "+", "pattern", ".", "TR", ";", "var", "empty", "=", "pattern", ".", "L", "+", "new", "Array", "(", "2", "*", "marginX", "+", "maxLength", "+", "1", ")", ".", "join", "(", "\" \"", ")", "+", "pattern", ".", "R", ";", "var", "bottom", "=", "pattern", ".", "BL", "+", "new", "Array", "(", "2", "*", "marginX", "+", "maxLength", "+", "1", ")", ".", "join", "(", "pattern", ".", "B", ")", "+", "pattern", ".", "BR", ";", "linesOfText", "=", "linesOfText", ".", "map", "(", "function", "(", "line", ")", "{", "while", "(", "line", ".", "length", "<", "maxLength", ")", "{", "line", "+=", "\" \"", ";", "}", "return", "pattern", ".", "L", "+", "margin", "+", "line", "+", "margin", "+", "pattern", ".", "R", ";", "}", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "marginY", ";", "i", "++", ")", "{", "linesOfText", ".", "unshift", "(", "empty", ")", ";", "linesOfText", ".", "push", "(", "empty", ")", ";", "}", "linesOfText", ".", "unshift", "(", "top", ")", ";", "linesOfText", ".", "push", "(", "bottom", ")", ";", "}" ]

[ "Creates", "a", "nice", "banner", "containing", "the", "given", "text", "." ]

[ "function", "resolveDeps", "(", "ast", ",", "result", ")", "{", "const", "{", "from", ":", "selfPath", ",", "graph", ",", "resolve", ",", "rootPath", ",", "rootTree", ",", "}", "=", "result", ".", "opts", ";", "const", "cwd", "=", "dirname", "(", "selfPath", ")", ";", "const", "rootDir", "=", "dirname", "(", "rootPath", ")", ";", "const", "processor", "=", "result", ".", "processor", ";", "const", "self", "=", "graph", "[", "selfPath", "]", "=", "graph", "[", "selfPath", "]", "||", "{", "}", ";", "self", ".", "mark", "=", "TEMPORARY_MARK", ";", "const", "moduleExports", "=", "{", "}", ";", "const", "translations", "=", "{", "}", ";", "ast", ".", "walkRules", "(", "moduleDeclaration", ",", "rule", "=>", "{", "if", "(", "importDeclaration", ".", "exec", "(", "rule", ".", "selector", ")", ")", "{", "rule", ".", "walkDecls", "(", "decl", "=>", "translations", "[", "decl", ".", "prop", "]", "=", "decl", ".", "value", ")", ";", "const", "dependencyPath", "=", "RegExp", ".", "$1", ".", "replace", "(", "/", "['\"]", "/", "g", ",", "''", ")", ";", "const", "absDependencyPath", "=", "resolveModule", "(", "dependencyPath", ",", "{", "cwd", ",", "resolve", "}", ")", ";", "if", "(", "!", "absDependencyPath", ")", "throw", "new", "Error", "(", "'Can\\'t resolve module path from `'", "+", "\\'", "+", "cwd", "+", "'` to `'", "+", "dependencyPath", ")", ";", "'`'", "if", "(", "graph", "[", "absDependencyPath", "]", "&&", "graph", "[", "absDependencyPath", "]", ".", "mark", "===", "TEMPORARY_MARK", ")", "throw", "new", "Error", "(", "'Circular dependency was found between `'", "+", "selfPath", "+", "'` and `'", "+", "absDependencyPath", "+", "'`. '", "+", "'Circular dependencies lead to the unpredictable state and considered harmful.'", ")", ";", "if", "(", "!", "(", "graph", "[", "absDependencyPath", "]", "&&", "graph", "[", "absDependencyPath", "]", ".", "mark", "===", "PERMANENT_MARK", ")", ")", "{", "const", "css", "=", "readFileSync", "(", "absDependencyPath", ",", "'utf8'", ")", ";", "const", "lazyResult", "=", "processor", ".", "process", "(", "css", ",", "Object", ".", "assign", "(", "{", "}", ",", "result", ".", "opts", ",", "{", "from", ":", "absDependencyPath", "}", ")", ")", ";", "updateTranslations", "(", "translations", ",", "lazyResult", ".", "root", ".", "exports", ")", ";", "}", "else", "{", "updateTranslations", "(", "translations", ",", "graph", "[", "absDependencyPath", "]", ".", "exports", ")", ";", "}", "}", "return", "void", "rule", ".", "remove", "(", ")", ";", "rule", ".", "walkDecls", "(", "decl", "=>", "moduleExports", "[", "decl", ".", "prop", "]", "=", "decl", ".", "value", ")", ";", "}", ")", ";", "rule", ".", "remove", "(", ")", ";", "replaceSymbols", "(", "ast", ",", "translations", ")", ";", "for", "(", "const", "token", "in", "moduleExports", ")", "for", "(", "const", "genericId", "in", "translations", ")", "moduleExports", "[", "token", "]", "=", "moduleExports", "[", "token", "]", ".", "replace", "(", "genericId", ",", "translations", "[", "genericId", "]", ")", ";", "self", ".", "mark", "=", "PERMANENT_MARK", ";", "self", ".", "exports", "=", "ast", ".", "exports", "=", "moduleExports", ";", "if", "(", "cwd", "!==", "rootDir", ")", "resolvePaths", "(", "ast", ",", "cwd", ",", "rootDir", ")", ";", "const", "importNotes", "=", "comment", "(", "{", "parent", ":", "rootTree", ",", "raws", ":", "{", "before", ":", "rootTree", ".", "nodes", ".", "length", "===", "0", "?", "''", ":", "'\\n\\n'", "}", ",", "\\n", ",", "}", ")", ";", "\\n", "}" ]

[ "Topological", "sorting", "is", "used", "to", "resolve", "the", "deps", "order", "actually", "depth", "-", "first", "search", "algorithm", "." ]

[ "function", "Closure", "(", "parent", ",", "listOfKeys", ",", "accessor", ")", "{", "\"use strict\"", ";", "var", "closure", "=", "{", "}", ";", "listOfKeys", "=", "listOfKeys", "||", "[", "]", ";", "accessor", "=", "accessor", "||", "function", "(", ")", "{", "}", ";", "parent", "&&", "parent", ".", "__mixin__", "&&", "parent", ".", "__mixin__", "(", "closure", ")", ";", "listOfKeys", ".", "forEach", "(", "function", "(", "key", ")", "{", "closure", "[", "key", "]", "=", "accessor", ".", "bind", "(", "null", ",", "key", ")", ";", "}", ")", ";", "this", ".", "getValues", "=", "function", "(", ")", "{", "var", "values", "=", "{", "}", ";", "Object", ".", "keys", "(", "closure", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "values", "[", "key", "]", "=", "closure", "[", "key", "]", "(", ")", ";", "if", "(", "values", "[", "key", "]", "===", "undefined", ")", "{", "values", "[", "key", "]", "=", "null", ";", "}", "if", "(", "typeof", "values", "[", "key", "]", "===", "'function'", ")", "{", "throw", "new", "Error", "(", "'a closure variable must be serializable, so you cannot use a function'", ")", ";", "}", "}", ")", ";", "return", "values", ";", "}", "this", ".", "setValues", "=", "function", "(", "values", ")", "{", "Object", ".", "keys", "(", "values", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "closure", "[", "key", "]", "(", "values", "[", "key", "]", ")", ";", "}", ")", ";", "}", "this", ".", "__mixin__", "=", "function", "(", "object", ")", "{", "Object", ".", "keys", "(", "closure", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "object", "[", "key", "]", "=", "closure", "[", "key", "]", ";", "}", ")", ";", "}", "}" ]

[ "Creates", "a", "new", "closure", "manager", "." ]

[ "function", "(", "key", ",", "object", ")", "{", "var", "json", "=", "JSON", ".", "stringify", "(", "object", ")", ";", "persistenceStrategy", ".", "set", "(", "key", ",", "json", ")", ";", "objectCache", "[", "key", "]", "=", "object", ";", "}" ]

[ "Stores", "an", "object", "in", "local", "storage", "under", "the", "given", "key" ]

[ "function", "(", "key", ")", "{", "var", "cached", "=", "objectCache", "[", "key", "]", ";", "if", "(", "cached", ")", "{", "return", "cached", ";", "}", "var", "json", "=", "persistenceStrategy", ".", "get", "(", "key", ")", ";", "if", "(", "json", "==", "null", ")", "{", "return", "null", ";", "}", "try", "{", "return", "JSON", ".", "parse", "(", "json", ")", ";", "}", "catch", "(", "err", ")", "{", "return", "null", ";", "}", "}" ]

[ "Either", "retrieves", "the", "cached", "copy", "of", "an", "object", "or", "the", "object", "itself", "from", "localStorage", ".", "Returns", "null", "if", "the", "object", "couldn", "t", "be", "found", "." ]

[ "function", "(", "lockKey", ",", "asyncFunction", ")", "{", "var", "deferred", "=", "$q", ".", "defer", "(", ")", ";", "if", "(", "memoryLocks", "[", "lockKey", "]", ")", "{", "deferred", ".", "reject", "(", "'in_progress'", ")", ";", "return", "deferred", ".", "promise", ";", "}", "if", "(", "persistenceStrategy", ".", "get", "(", "lockKey", ")", "===", "'locked'", ")", "{", "deferred", ".", "reject", "(", "'last_call_interrupted'", ")", ";", "deferred", ".", "promise", ".", "then", "(", "null", ",", "function", "(", ")", "{", "persistenceStrategy", ".", "remove", "(", "lockKey", ")", ";", "}", ")", ";", "return", "deferred", ".", "promise", ";", "}", "memoryLocks", "[", "lockKey", "]", "=", "true", ";", "persistenceStrategy", ".", "set", "(", "lockKey", ",", "'locked'", ")", ";", "asyncFunction", "(", ")", ".", "then", "(", "function", "(", "successData", ")", "{", "deferred", ".", "resolve", "(", "successData", ")", ";", "delete", "memoryLocks", "[", "lockKey", "]", ";", "persistenceStrategy", ".", "remove", "(", "lockKey", ")", ";", "}", ",", "function", "(", "errorData", ")", "{", "deferred", ".", "reject", "(", "errorData", ")", ";", "delete", "memoryLocks", "[", "lockKey", "]", ";", "persistenceStrategy", ".", "remove", "(", "lockKey", ")", ";", "}", ",", "function", "(", "notifyData", ")", "{", "deferred", ".", "notify", "(", "notifyData", ")", ";", "}", ")", ";", "return", "deferred", ".", "promise", ";", "}" ]

[ "Locks", "the", "async", "call", "represented", "by", "the", "given", "promise", "and", "lock", "key", ".", "Only", "one", "asyncFunction", "given", "by", "the", "lockKey", "can", "be", "running", "at", "any", "time", "." ]

[ "function", "(", "key", ",", "value", ",", "isUnique", ")", "{", "if", "(", "isUnique", ")", "{", "return", "this", ".", "_op", "(", "key", ",", "value", ",", "'pushUnique'", ")", ";", "}", "else", "{", "return", "this", ".", "_op", "(", "key", ",", "value", ",", "'push'", ")", ";", "}", "}" ]

[ "Push", "the", "given", "value", "into", "the", "array", "field", "identified", "by", "the", "key", ".", "Pass", "true", "to", "isUnique", "to", "only", "push", "the", "value", "if", "the", "value", "does", "not", "already", "exist", "in", "the", "array", "." ]

[ "function", "BuildPromise", "(", "options", ")", "{", "\"use strict\"", ";", "options", "=", "options", "||", "{", "}", ";", "var", "pathToApp", "=", "options", ".", "pathToApp", "||", "path", ".", "resolve", "(", "'.'", ")", ";", "var", "mongoUrl", "=", "options", ".", "mongoUrl", "||", "\"http://localhost:27017\"", ";", "var", "timeout", "=", "options", ".", "timeout", "||", "120000", ";", "var", "verbose", "=", "options", ".", "verbose", "!==", "undefined", "?", "!", "!", "options", ".", "verbose", ":", "false", ";", "var", "pathToMain", "=", "path", ".", "join", "(", "pathToApp", ",", "'.gagarin'", ",", "'local'", ",", "'bundle'", ",", "'main.js'", ")", ";", "var", "pathToLocal", "=", "path", ".", "join", "(", "pathToApp", ",", "'.gagarin'", ",", "'local'", ")", ";", "var", "env", "=", "Object", ".", "create", "(", "process", ".", "env", ")", ";", "return", "tools", ".", "getReleaseVersion", "(", "pathToApp", ")", ".", "then", "(", "function", "(", "version", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "var", "args", ";", "logs", ".", "system", "(", "\"detected METEOR@\"", "+", "version", ")", ";", "if", "(", "version", ">=", "'1.0.0'", ")", "{", "args", "=", "[", "'build'", ",", "'--debug'", ",", "'--directory'", ",", "pathToLocal", "]", ";", "}", "else", "{", "args", "=", "[", "'bundle'", ",", "'--debug'", ",", "'--directory'", ",", "path", ".", "join", "(", "pathToLocal", ",", "'bundle'", ")", "]", ";", "}", "logs", ".", "system", "(", "\"spawning meteor process with the following args\"", ")", ";", "logs", ".", "system", "(", "JSON", ".", "stringify", "(", "args", ")", ")", ";", "var", "buildTimeout", "=", "null", ";", "var", "meteorBinary", "=", "tools", ".", "getMeteorBinary", "(", ")", ";", "var", "platformsFilePath", "=", "path", ".", "join", "(", "pathToApp", ",", "'.meteor'", ",", "'platforms'", ")", ";", "var", "platformsBackupPath", "=", "path", ".", "join", "(", "pathToApp", ",", "'.meteor'", ",", "'platforms.gagarin.backup'", ")", ";", "fs", ".", "rename", "(", "platformsFilePath", ",", "platformsBackupPath", ",", "function", "(", "err", ",", "data", ")", "{", "fs", ".", "writeFile", "(", "platformsFilePath", ",", "'server\\nbrowser\\n'", ",", "\\n", ")", ";", "}", ")", ";", "\\n", "function", "(", ")", "{", "spawnMeteorProcess", "(", ")", ";", "}", "var", "output", "=", "\"\"", ";", "}", ")", ";", "}", ")", ";", "var", "meteor", "=", "null", ";", "}" ]

[ "PRIVATE", "BUILD", "PROMISE", "IMPLEMENTATION" ]

[ "function", "ensureGagarinVersionsMatch", "(", "pathToApp", ",", "verbose", ")", "{", "var", "pathToMeteorPackages", "=", "path", ".", "join", "(", "pathToApp", ",", "'.meteor'", ",", "'packages'", ")", ";", "var", "nodeModuleVersion", "=", "require", "(", "'../../package.json'", ")", ".", "version", ";", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "utils", ".", "getGagarinPackageVersion", "(", "pathToApp", ")", ".", "then", "(", "function", "(", "packageVersion", ")", "{", "if", "(", "packageVersion", "===", "nodeModuleVersion", ")", "{", "logs", ".", "system", "(", "\"node module and smart package versions match, \"", "+", "packageVersion", ")", ";", "return", "resolve", "(", ")", ";", "}", "tools", ".", "getReleaseVersion", "(", "pathToApp", ")", ".", "then", "(", "function", "(", "meteorReleaseVersion", ")", "{", "if", "(", "meteorReleaseVersion", "<", "\"0.9.0\"", ")", "{", "logs", ".", "system", "(", "\"meteor version is too old to automatically fix package version\"", ")", ";", "return", "resolve", "(", ")", ";", "}", "logs", ".", "system", "(", "\"meteor add anti:gagarin@=\"", "+", "nodeModuleVersion", ")", ";", "var", "meteor", "=", "spawn", "(", "'meteor'", ",", "[", "'add'", ",", "'anti:gagarin@='", "+", "nodeModuleVersion", "]", ",", "{", "stdio", ":", "verbose", "?", "'inherit'", ":", "'ignore'", ",", "cwd", ":", "pathToApp", "}", ")", ";", "meteor", ".", "on", "(", "'error'", ",", "reject", ")", ";", "meteor", ".", "on", "(", "'exit'", ",", "function", "(", "code", ")", "{", "if", "(", "code", ">", "0", ")", "{", "return", "reject", "(", "new", "Error", "(", "'meteor exited with code '", "+", "code", ")", ")", ";", "}", "logs", ".", "system", "(", "\"anti:gagarin is now in version \"", "+", "nodeModuleVersion", ")", ";", "resolve", "(", ")", ";", "}", ")", ";", "}", ")", ".", "catch", "(", "reject", ")", ";", "}", ")", ".", "catch", "(", "reject", ")", ";", "}", ")", ";", "}" ]

[ "Build", "Check", "smart", "package", "version", "and", "if", "it", "s", "wrong", "install", "the", "right", "one", "." ]

[ "function", "checkIfMeteorIsRunning", "(", "pathToApp", ")", "{", "var", "pathToMongoLock", "=", "path", ".", "join", "(", "pathToApp", ",", "'.meteor'", ",", "'local'", ",", "'db'", ",", "'mongod.lock'", ")", ";", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "fs", ".", "readFile", "(", "pathToMongoLock", ",", "{", "encoding", ":", "'utf8'", "}", ",", "function", "(", "err", ",", "data", ")", "{", "if", "(", "err", ")", "{", "return", "err", ".", "code", "!==", "'ENOENT'", "?", "reject", "(", "err", ")", ":", "resolve", "(", ")", ";", "}", "else", "{", "resolve", "(", "!", "!", "data", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Guess", "if", "develop", "meteor", "is", "currently", "running", "." ]

[ "function", "smartJsonWarning", "(", "pathToApp", ")", "{", "var", "pathToSmartJSON", "=", "path", ".", "join", "(", "pathToApp", ",", "'smart.json'", ")", ";", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "fs", ".", "readFile", "(", "pathToSmartJSON", ",", "{", "endcoding", ":", "'urf8'", "}", ",", "function", "(", "err", ",", "data", ")", "{", "if", "(", "err", ")", "{", "return", "err", ".", "code", "!==", "'ENOENT'", "?", "reject", "(", "err", ")", ":", "resolve", "(", ")", ";", "}", "else", "{", "process", ".", "stdout", ".", "write", "(", "chalk", ".", "yellow", "(", "tools", ".", "banner", "(", "[", "'we have detected a smart.json file in '", "+", "pathToApp", ",", "'since Gagarin no longer supports meteorite, this file will be ignored'", ",", "]", ".", "join", "(", "'\\n'", ")", ",", "\\n", ")", ")", ")", ";", "{", "}", "process", ".", "stdout", ".", "write", "(", "'\\n'", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Look", "for", "smart", ".", "json", "file", ".", "If", "there", "s", "one", "print", "warning", "before", "resolving", "." ]

[ "async", "function", "start", "(", ")", "{", "const", "mainRoute", "=", "server", ".", "addReactRoute", "(", "\"\"", ",", "path", ".", "resolve", "(", "process", ".", "cwd", "(", ")", ",", "\"app/Routes.js\"", ")", ")", ";", "await", "server", ".", "start", "(", ")", ";", "console", ".", "log", "(", "\"started\"", ")", ";", "}" ]

[ "create", "a", "new", "instance" ]

[ "function", "providePlugins", "(", "code", ")", "{", "var", "chunks", "=", "[", "]", ";", "if", "(", "typeof", "code", "===", "'string'", ")", "{", "code", "=", "code", ".", "split", "(", "'\\n'", ")", ";", "}", "\\n", "chunks", ".", "push", "(", "\"function (\"", "+", "Object", ".", "keys", "(", "plugins", ")", ".", "join", "(", "', '", ")", "+", "\") {\"", ")", ";", "chunks", ".", "push", "(", "\" return \"", "+", "code", "[", "0", "]", ")", ";", "code", ".", "forEach", "(", "function", "(", "line", ",", "index", ")", "{", "if", "(", "index", "===", "0", ")", "return", ";", "chunks", ".", "push", "(", "\" \"", "+", "line", ")", ";", "}", ")", ";", "chunks", ".", "push", "(", "\"}\"", ")", ";", "}" ]

[ "Provide", "plugins", "the", "the", "local", "context", "." ]

[ "function", "isolateScope", "(", "code", ",", "closure", ")", "{", "if", "(", "typeof", "code", "===", "'string'", ")", "{", "code", "=", "code", ".", "split", "(", "'\\n'", ")", ";", "}", "\\n", "var", "keys", "=", "Object", ".", "keys", "(", "closure", ")", ".", "map", "(", "function", "(", "key", ")", "{", "return", "stringify", "(", "key", ")", "+", "\": \"", "+", "key", ";", "}", ")", ";", "var", "chunks", "=", "[", "]", ";", "chunks", ".", "push", "(", "\"function (\"", "+", "Object", ".", "keys", "(", "closure", ")", ".", "join", "(", "', '", ")", "+", "\") {\"", ",", "\" 'use strict';\"", ",", "\" return (function (userFunc, getClosure, action) {\"", ",", "\" try {\"", ",", "\" return action(userFunc, getClosure);\"", ",", "\" } catch (err) {\"", ",", "\" return { error: err.message, closure: getClosure() };\"", ",", "\" }\"", ",", "\" })(\"", ")", ";", "align", "(", "code", ")", ".", "forEach", "(", "function", "(", "line", ")", "{", "chunks", ".", "push", "(", "\" \"", "+", "line", ")", ";", "}", ")", ";", "chunks", "[", "chunks", ".", "length", "-", "1", "]", "+=", "','", ";", "chunks", ".", "push", "(", "\" function () {\"", ",", "\" return { \"", "+", "keys", ".", "join", "(", "', '", ")", "+", "\" };\"", ",", "\" },\"", ",", "\" arguments[arguments.length-1]\"", ",", "\" );\"", ",", "\"}\"", ")", ";", "}" ]

[ "Make", "sure", "that", "the", "only", "local", "variables", "visible", "inside", "the", "code", "are", "those", "from", "the", "closure", "object", "." ]

[ "function", "align", "(", "code", ")", "{", "if", "(", "typeof", "code", "===", "'string'", ")", "{", "code", "=", "code", ".", "split", "(", "'\\n'", ")", ";", "}", "\\n", "var", "match", "=", "code", "[", "code", ".", "length", "-", "1", "]", ".", "match", "(", "/", "^(\\s+)\\}", "/", ")", ";", "var", "regex", "=", "null", ";", "if", "(", "match", "&&", "code", "[", "0", "]", ".", "match", "(", "/", "^function", "/", ")", ")", "{", "regex", "=", "new", "RegExp", "(", "\"^\"", "+", "match", "[", "1", "]", ")", ";", "return", "code", ".", "map", "(", "function", "(", "line", ")", "{", "return", "line", ".", "replace", "(", "regex", ",", "\"\"", ")", ";", "}", ")", ";", "}", "}" ]

[ "Fixes", "the", "source", "code", "indentation", "." ]

[ "function", "compile", "(", "code", ",", "closure", ")", "{", "code", "=", "providePlugins", "(", "isolateScope", "(", "code", ",", "closure", ")", ")", ".", "join", "(", "'\\n'", ")", ";", "\\n", "}" ]

[ "Creates", "a", "function", "from", "the", "provided", "source", "code", "and", "closure", "object", "." ]

[ "function", "Gagarin", "(", "options", ")", "{", "\"use strict\"", ";", "var", "write", "=", "process", ".", "stdout", ".", "write", ".", "bind", "(", "process", ".", "stdout", ")", ";", "var", "listOfFrameworks", "=", "[", "]", ";", "var", "numberOfLinesPrinted", "=", "0", ";", "require", "(", "'./interface'", ")", ";", "options", ".", "settings", "=", "tools", ".", "getSettings", "(", "options", ".", "settings", ")", ";", "options", ".", "ui", "=", "'gagarin'", ";", "var", "factory", "=", "!", "options", ".", "parallel", "?", "null", ":", "createParallelReporterFactory", "(", "function", "(", "allStats", ",", "elapsed", ")", "{", "if", "(", "numberOfLinesPrinted", ">", "0", ")", "{", "write", "(", "'\\u001b['", "+", "\\u001b", "+", "numberOfLinesPrinted", ")", "}", "'A'", "write", "(", "' elapsed time: '", "+", "Math", ".", "floor", "(", "elapsed", "/", "100", ")", "/", "10", "+", "'s'", "+", "'\\n\\n'", ")", ";", "}", ")", ";", "\\n", "\\n", "numberOfLinesPrinted", "=", "2", "+", "table", "(", "allStats", ",", "write", ")", ";", "function", "getMocha", "(", ")", "{", "if", "(", "options", ".", "parallel", "===", "0", "&&", "listOfFrameworks", ".", "length", ">", "0", ")", "{", "return", "listOfFrameworks", "[", "0", "]", ";", "}", "var", "mocha", "=", "new", "Mocha", "(", "options", ")", ";", "if", "(", "factory", ")", "{", "mocha", ".", "_reporter", "=", "factory", "(", "listOfFrameworks", ".", "length", ")", ";", "}", "var", "reporter", "=", "mocha", ".", "_reporter", ";", "listOfFrameworks", ".", "push", "(", "mocha", ")", ";", "return", "mocha", ";", "}", ";", "}" ]

[ "Creates", "Gagarin", "with", "options", "." ]

[ "function", "getConfigFilePath", "(", ")", "{", "const", "files", "=", "fs", ".", "readdirSync", "(", "process", ".", "cwd", "(", ")", ")", "const", "configFile", "=", "files", ".", "find", "(", "(", "filePath", ")", "=>", "{", "return", "CONFIG_FILE_NAMES", ".", "find", "(", "(", "configFileName", ")", "=>", "filePath", ".", "indexOf", "(", "configFileName", ")", "!==", "-", "1", ")", "}", ")", "if", "(", "!", "configFile", ")", "{", "return", "path", ".", "join", "(", "__dirname", ",", "'..'", ",", "this", ".", "defaultConfig", ")", "}", "return", "path", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "configFile", ")", "}" ]

[ "Get", "configuration", "options", "for", "dockerfile_lint" ]

[ "function", "lintFile", "(", "linter", ",", "fileName", ")", "{", "const", "fileContents", "=", "fs", ".", "readFileSync", "(", "fileName", ",", "{", "encoding", ":", "'utf8'", "}", ")", ".", "toString", "(", ")", "const", "report", "=", "linter", ".", "validate", "(", "fileContents", ")", "const", "errors", "=", "report", ".", "error", ".", "count", "const", "warnings", "=", "report", ".", "warn", ".", "count", "if", "(", "errors", "||", "warnings", ")", "{", "this", ".", "printFilePath", "(", "fileName", ")", "report", ".", "error", ".", "data", ".", "forEach", "(", "logItem", ".", "bind", "(", "this", ")", ")", "report", ".", "warn", ".", "data", ".", "forEach", "(", "logItem", ".", "bind", "(", "this", ")", ")", "console", ".", "log", "(", "''", ")", "}", "return", "report", "}" ]

[ "Lint", "a", "single", "Dockerfile" ]

[ "function", "processByte", "(", "stream", ",", "b", ")", "{", "assert", ".", "equal", "(", "typeof", "b", ",", "'number'", ")", ";", "if", "(", "b", "===", "NEWLINE", ")", "{", "stream", ".", "emit", "(", "'newline'", ")", ";", "}", "}" ]

[ "Processes", "an", "individual", "byte", "being", "written", "to", "a", "stream" ]

[ "function", "log", "(", "fn", ",", "args", ",", "indent", ")", "{", "if", "(", "args", ".", "length", "===", "0", ")", "{", "return", ";", "}", "const", "indentation", "=", "_", ".", "repeat", "(", "'\\t'", ",", "\\t", ")", ";", "indent", "if", "(", "_", ".", "isString", "(", "args", "[", "0", "]", ")", ")", "{", "args", "[", "0", "]", "=", "indentation", "+", "args", "[", "0", "]", ";", "}", "else", "{", "args", ".", "splice", "(", "0", ",", "0", ",", "indentation", ")", ";", "}", "}" ]

[ "Internal", "helper", "for", "logging", "stuff", "out" ]

[ "function", "getFunction", "(", "name", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "lambda", ".", "getFunctionConfiguration", "(", "{", "FunctionName", ":", "name", "}", ",", "function", "(", "err", ",", "data", ")", "{", "if", "(", "err", ")", "return", "reject", "(", "err", ")", ";", "resolve", "(", "data", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Get", "function", "configuration", "by", "its", "name" ]

[ "function", "getFunctionVersions", "(", "name", ",", "marker", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "lambda", ".", "listVersionsByFunction", "(", "{", "FunctionName", ":", "name", ",", "Marker", ":", "marker", "}", ",", "function", "(", "err", ",", "data", ")", "{", "if", "(", "err", ")", "return", "reject", "(", "err", ")", ";", "if", "(", "data", ".", "NextMarker", ")", "{", "return", "getFunctionVersions", "(", "name", ",", "data", ".", "NextMarker", ")", ".", "then", "(", "(", "versions", ")", "=>", "{", "resolve", "(", "data", ".", "Versions", ".", "concat", "(", "versions", ")", ")", ";", "}", ")", ";", "}", "resolve", "(", "data", ".", "Versions", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Get", "all", "function", "versions" ]

[ "function", "functionPublishVersion", "(", "name", ",", "description", ",", "hash", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "lambda", ".", "publishVersion", "(", "{", "FunctionName", ":", "name", ",", "Description", ":", "description", ",", "CodeSha256", ":", "hash", "}", ",", "function", "(", "err", ",", "data", ")", "{", "if", "(", "err", ")", "return", "reject", "(", "err", ")", ";", "resolve", "(", "data", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Publish", "a", "new", "Lambda", "function", "version" ]

[ "function", "getDirectoryTree", "(", "dir", ")", "{", "const", "items", "=", "[", "]", ";", "return", "new", "Promise", "(", "function", "(", "resolve", ")", "{", "fs", ".", "walk", "(", "dir", ")", ".", "on", "(", "'data'", ",", "function", "(", "item", ")", "{", "items", ".", "push", "(", "item", ".", "path", ")", ";", "}", ")", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "resolve", "(", "items", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Helper", "function", "for", "capturing", "the", "state", "of", "a", "directory" ]

[ "function", "replaceVariables", "(", "localPath", ",", "variables", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "let", "body", "=", "fs", ".", "readFileSync", "(", "localPath", ",", "'utf8'", ")", ";", "const", "keys", "=", "Object", ".", "keys", "(", "variables", ")", ";", "keys", ".", "forEach", "(", "function", "(", "key", ")", "{", "const", "value", "=", "variables", "[", "key", "]", ";", "const", "re", "=", "new", "RegExp", "(", "`", "\\\\", "${", "key", "}", "`", ",", "'g'", ")", ";", "try", "{", "const", "parsed", "=", "JSON", ".", "parse", "(", "value", ")", ";", "body", "=", "body", ".", "replace", "(", "re", ",", "parsed", "?", "`", "${", "parsed", "}", "`", ":", "`", "`", ")", ";", "}", "catch", "(", "err", ")", "{", "body", "=", "body", ".", "replace", "(", "re", ",", "`", "${", "value", "}", "`", ")", ";", "}", "}", ")", ";", "console", ".", "log", "(", "'Variables replaced'", ",", "body", ")", ";", "fs", ".", "writeFile", "(", "localPath", ",", "body", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "return", "reject", "(", "err", ")", ";", "resolve", "(", "localPath", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Helper", "function", "for", "replacing", "variables", "in", "the", "API", "definition" ]

[ "function", "(", "apiId", ")", "{", "return", "APIG", ".", "getStages", "(", "{", "restApiId", ":", "apiId", "}", ")", ".", "promise", "(", ")", ".", "then", "(", "function", "(", "data", ")", "{", "return", "data", ".", "item", ";", "}", ")", ";", "}" ]

[ "Fetch", "existing", "stages", "for", "a", "specific", "API" ]

[ "function", "(", "apiId", ",", "stageName", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "APIG", ".", "deleteStage", "(", "{", "restApiId", ":", "apiId", ",", "stageName", ":", "stageName", "}", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "if", "(", "err", ".", "code", "===", "404", "||", "err", ".", "code", "===", "'NotFoundException'", ")", "{", "return", "resolve", "(", "apiId", ")", ";", "}", "return", "reject", "(", "err", ")", ";", "}", "resolve", "(", "apiId", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Delete", "a", "specific", "stage", "on", "a", "specific", "API" ]

[ "function", "(", "apiId", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "APIG", ".", "deleteRestApi", "(", "{", "restApiId", ":", "apiId", "}", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "if", "(", "err", ".", "code", "===", "404", "||", "err", ".", "code", "===", "'NotFoundException'", ")", "{", "return", "resolve", "(", "apiId", ")", ";", "}", "return", "reject", "(", "err", ")", ";", "}", "resolve", "(", "apiId", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Delete", "the", "entire", "API", "ID" ]

[ "function", "(", "apiId", ")", "{", "return", "module", ".", "exports", ".", "fetchExistingStages", "(", "apiId", ")", ".", "then", "(", "function", "(", "stages", ")", "{", "if", "(", "!", "stages", "||", "stages", ".", "length", "===", "0", ")", "{", "return", "module", ".", "exports", ".", "deleteAPI", "(", "apiId", ")", ";", "}", "return", "apiId", ";", "}", ")", ";", "}" ]

[ "Delete", "the", "API", "if", "and", "only", "if", "there", "are", "no", "more", "stages", "deployed", "on", "it" ]

[ "function", "(", "apiName", ",", "swaggerPath", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "fs", ".", "readFile", "(", "swaggerPath", ",", "function", "(", "err", ",", "data", ")", "{", "if", "(", "err", ")", "return", "reject", "(", "err", ")", ";", "resolve", "(", "APIG", ".", "importRestApi", "(", "{", "body", ":", "data", ",", "failOnWarnings", ":", "false", "}", ")", ".", "promise", "(", ")", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Create", "a", "new", "API", "instance", "from", "a", "Swagger", "file" ]

[ "function", "(", "apiId", ",", "swaggerPath", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "fs", ".", "readFile", "(", "swaggerPath", ",", "function", "(", "err", ",", "data", ")", "{", "if", "(", "err", ")", "return", "reject", "(", "err", ")", ";", "resolve", "(", "APIG", ".", "putRestApi", "(", "{", "restApiId", ":", "apiId", ",", "body", ":", "data", ",", "mode", ":", "'overwrite'", "}", ")", ".", "promise", "(", ")", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Update", "an", "API", "with", "a", "specification", "from", "a", "Swagger", "file", "The", "update", "is", "done", "in", "the", "overwrite", "mode", "of", "API", "Gateway" ]

[ "function", "archiveDependencies", "(", "cwd", ",", "pkg", ")", "{", "let", "result", "=", "[", "]", ";", "if", "(", "pkg", ".", "path", ")", "{", "result", ".", "push", "(", "{", "data", ":", "pkg", ".", "path", ",", "type", ":", "'directory'", ",", "name", ":", "path", ".", "relative", "(", "cwd", ",", "pkg", ".", "path", ")", "}", ")", ";", "}", "pkg", ".", "dependencies", ".", "forEach", "(", "function", "(", "dep", ")", "{", "if", "(", "dep", ".", "path", ")", "{", "result", ".", "push", "(", "{", "data", ":", "dep", ".", "path", ",", "type", ":", "'directory'", ",", "name", ":", "path", ".", "relative", "(", "cwd", ",", "dep", ".", "path", ")", "}", ")", ";", "}", "if", "(", "dep", ".", "dependencies", ")", "{", "result", "=", "result", ".", "concat", "(", "archiveDependencies", "(", "cwd", ",", "dep", ")", ")", ";", "}", "}", ")", ";", "return", "result", ";", "}" ]

[ "Helper", "for", "recursively", "adding", "all", "dependencies", "to", "an", "archive" ]

[ "function", "bundleLambda", "(", "lambda", ",", "exclude", ",", "environment", ",", "bundlePath", ",", "sourceMapPath", ")", "{", "environment", "=", "environment", "||", "{", "}", ";", "exclude", "=", "exclude", "||", "[", "]", ";", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "const", "bundler", "=", "new", "Browserify", "(", "lambda", ".", "path", ",", "{", "basedir", ":", "path", ".", "dirname", "(", "lambda", ".", "path", ")", ",", "standalone", ":", "lambda", ".", "name", ",", "browserField", ":", "false", ",", "builtins", ":", "false", ",", "commondir", ":", "false", ",", "ignoreMissing", ":", "true", ",", "detectGlobals", ":", "true", ",", "debug", ":", "!", "!", "sourceMapPath", ",", "insertGlobalVars", ":", "{", "process", ":", "function", "(", ")", "{", "}", "}", "}", ")", ";", "bundler", ".", "exclude", "(", "'aws-sdk'", ")", ";", "[", "]", ".", "concat", "(", "exclude", ")", ".", "forEach", "(", "function", "(", "module", ")", "{", "bundler", ".", "exclude", "(", "module", ")", ";", "}", ")", ";", "if", "(", "environment", ")", "{", "bundler", ".", "transform", "(", "envify", "(", "environment", ")", ",", "{", "global", ":", "true", "}", ")", ";", "}", "let", "stream", "=", "bundler", ".", "bundle", "(", ")", ";", "if", "(", "sourceMapPath", ")", "{", "stream", "=", "stream", ".", "pipe", "(", "exorcist", "(", "sourceMapPath", ")", ")", ";", "}", "stream", ".", "pipe", "(", "fs", ".", "createWriteStream", "(", "bundlePath", ")", ")", ";", "stream", ".", "on", "(", "'error'", ",", "function", "(", "err", ")", "{", "reject", "(", "err", ")", ";", "}", ")", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "resolve", "(", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Processing", "pipeline", "all", "functions", "should", "return", "a", "promise", "Bundles", "the", "lambda", "code", "returning", "the", "bundled", "code" ]

[ "function", "(", "bucket", ",", "key", ",", "version", ",", "localPath", ")", "{", "return", "S3", ".", "getObject", "(", "{", "Bucket", ":", "bucket", ",", "Key", ":", "key", ",", "VersionId", ":", "version", "}", ")", ".", "promise", "(", ")", ".", "then", "(", "function", "(", "data", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "fs", ".", "writeFile", "(", "localPath", ",", "data", ".", "Body", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "return", "reject", "(", "err", ")", ";", "resolve", "(", "localPath", ")", ";", "}", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Download", "a", "file", "from", "remote", "bucket", "to", "a", "local", "path" ]

[ "function", "(", "bucket", ",", "key", ",", "version", ")", "{", "return", "S3", ".", "headObject", "(", "{", "Bucket", ":", "bucket", ",", "Key", ":", "key", ",", "VersionId", ":", "version", "}", ")", ".", "promise", "(", ")", ";", "}" ]

[ "Execute", "a", "HEAD", "operation", "on", "a", "specific", "key", "in", "a", "bucket", ".", "The", "request", "can", "also", "contain", "an", "optional", "version", "for", "the", "file" ]

[ "function", "cloudFormationDependencies", "(", "value", ")", "{", "if", "(", "_", ".", "isString", "(", "value", ")", ")", "{", "return", "[", "value", "]", ";", "}", "if", "(", "!", "_", ".", "isObject", "(", "value", ")", ")", "{", "return", "[", "]", ";", "}", "const", "keys", "=", "_", ".", "keys", "(", "value", ")", ";", "if", "(", "keys", ".", "length", "!==", "1", ")", "{", "return", "[", "]", ";", "}", "const", "key", "=", "keys", "[", "0", "]", ";", "if", "(", "key", "===", "'Fn::GetAtt'", ")", "{", "return", "cloudFormationDependencies", "(", "value", "[", "key", "]", "[", "0", "]", ")", ";", "}", "if", "(", "key", "===", "'Ref'", ")", "{", "return", "cloudFormationDependencies", "(", "value", "[", "key", "]", ")", ";", "}", "if", "(", "key", "===", "'Fn::Join'", ")", "{", "return", "_", ".", "flatten", "(", "value", "[", "key", "]", "[", "1", "]", ".", "filter", "(", "_", ".", "isObject", ")", ".", "map", "(", "cloudFormationDependencies", ")", ")", ";", "}", "if", "(", "key", "===", "'Fn::Select'", ")", "{", "const", "index", "=", "value", "[", "key", "]", "[", "0", "]", ";", "const", "list", "=", "value", "[", "key", "]", "[", "1", "]", ";", "return", "cloudFormationDependencies", "(", "list", "[", "index", "]", ")", ";", "}", "return", "[", "]", ";", "}" ]

[ "Helper", "function", "for", "deriving", "the", "list", "of", "resources", "that", "are", "referenced", "by", "a", "CF", "function" ]

[ "function", "EE", "(", "fn", ",", "context", ",", "once", ")", "{", "this", ".", "fn", "=", "fn", ";", "this", ".", "context", "=", "context", ";", "this", ".", "once", "=", "once", "||", "false", ";", "}" ]

[ "Representation", "of", "a", "single", "event", "listener", "." ]

[ "function", "addListener", "(", "emitter", ",", "event", ",", "fn", ",", "context", ",", "once", ")", "{", "if", "(", "typeof", "fn", "!==", "'function'", ")", "{", "throw", "new", "TypeError", "(", "'The listener must be a function'", ")", ";", "}", "var", "listener", "=", "new", "EE", "(", "fn", ",", "context", "||", "emitter", ",", "once", ")", ",", "evt", "=", "prefix", "?", "prefix", "+", "event", ":", "event", ";", "if", "(", "!", "emitter", ".", "_events", "[", "evt", "]", ")", "emitter", ".", "_events", "[", "evt", "]", "=", "listener", ",", "emitter", ".", "_eventsCount", "++", ";", "else", "if", "(", "!", "emitter", ".", "_events", "[", "evt", "]", ".", "fn", ")", "emitter", ".", "_events", "[", "evt", "]", ".", "push", "(", "listener", ")", ";", "else", "emitter", ".", "_events", "[", "evt", "]", "=", "[", "emitter", ".", "_events", "[", "evt", "]", ",", "listener", "]", ";", "return", "emitter", ";", "}" ]

[ "Add", "a", "listener", "for", "a", "given", "event", "." ]

[ "function", "clearEvent", "(", "emitter", ",", "evt", ")", "{", "if", "(", "--", "emitter", ".", "_eventsCount", "===", "0", ")", "emitter", ".", "_events", "=", "new", "Events", "(", ")", ";", "else", "delete", "emitter", ".", "_events", "[", "evt", "]", ";", "}" ]

[ "Clear", "event", "by", "name", "." ]

[ "function", "handleStream", "(", "target", ",", "encoding", ",", "cb", ")", "{", "if", "(", "target", ".", "isNull", "(", ")", ")", "{", "return", "cb", "(", "null", ",", "target", ")", ";", "}", "if", "(", "target", ".", "isStream", "(", ")", ")", "{", "return", "cb", "(", "error", "(", "target", ".", "path", "+", "': Streams not supported for target templates!'", ")", ")", ";", "}", "try", "{", "const", "tagsRegExp", "=", "getRegExpTags", "(", "opt", ",", "null", ")", ";", "target", ".", "contents", "=", "processContent", "(", "target", ",", "opt", ",", "tagsRegExp", ",", "[", "target", ".", "path", "]", ")", ";", "this", ".", "push", "(", "target", ")", ";", "return", "cb", "(", ")", ";", "}", "catch", "(", "err", ")", "{", "this", ".", "emit", "(", "'error'", ",", "err", ")", ";", "return", "cb", "(", ")", ";", "}", "}" ]

[ "Handle", "injection", "of", "files" ]

[ "function", "processContent", "(", "target", ",", "opt", ",", "tagsRegExp", ",", "listOfFiles", ")", "{", "let", "targetContent", "=", "String", "(", "target", ".", "contents", ")", ";", "const", "targetPath", "=", "target", ".", "path", ";", "const", "files", "=", "extractFilePaths", "(", "targetContent", ",", "targetPath", ",", "opt", ",", "tagsRegExp", ")", ";", "files", ".", "forEach", "(", "function", "(", "fileData", ")", "{", "if", "(", "listOfFiles", ".", "indexOf", "(", "fileData", ".", "file", ".", "path", ")", "!==", "-", "1", ")", "{", "throw", "error", "(", "\"Circular definition found. File: \"", "+", "fileData", ".", "file", ".", "path", "+", "\" referenced in a child file.\"", ")", ";", "}", "listOfFiles", ".", "push", "(", "fileData", ".", "file", ".", "path", ")", ";", "const", "content", "=", "processContent", "(", "fileData", ".", "file", ",", "opt", ",", "tagsRegExp", ",", "listOfFiles", ")", ";", "listOfFiles", ".", "pop", "(", ")", ";", "targetContent", "=", "inject", "(", "targetContent", ",", "String", "(", "content", ")", ",", "opt", ",", "fileData", ".", "tags", ")", ";", "}", ")", ";", "if", "(", "listOfFiles", ".", "length", "===", "1", "&&", "!", "opt", ".", "quiet", "&&", "files", ".", "length", ")", "{", "log", "(", "colors", ".", "cyan", "(", "files", ".", "length", ".", "toString", "(", ")", ")", "+", "' partials injected into '", "+", "colors", ".", "magenta", "(", "targetPath", ")", "+", "'.'", ")", ";", "}", "return", "new", "Buffer", ".", "from", "(", "targetContent", ")", ";", "}" ]

[ "Parse", "content", "and", "create", "new", "template", "with", "all", "injections", "made" ]

[ "function", "inject", "(", "targetContent", ",", "sourceContent", ",", "opt", ",", "tagsRegExp", ")", "{", "const", "startTag", "=", "tagsRegExp", ".", "start", ";", "const", "endTag", "=", "tagsRegExp", ".", "end", ";", "let", "startMatch", ";", "let", "endMatch", ";", "while", "(", "(", "startMatch", "=", "startTag", ".", "exec", "(", "targetContent", ")", ")", "!==", "null", ")", "{", "endTag", ".", "lastIndex", "=", "startTag", ".", "lastIndex", ";", "endMatch", "=", "endTag", ".", "exec", "(", "targetContent", ")", ";", "if", "(", "!", "endMatch", ")", "{", "throw", "error", "(", "'Missing end tag for start tag: '", "+", "startMatch", "[", "0", "]", ")", ";", "}", "const", "toInject", "=", "[", "sourceContent", "]", ";", "let", "newContent", "=", "targetContent", ".", "slice", "(", "0", ",", "startMatch", ".", "index", ")", ";", "if", "(", "opt", ".", "removeTags", ")", "{", "startTag", ".", "lastIndex", "-=", "startMatch", "[", "0", "]", ".", "length", ";", "}", "else", "{", "toInject", ".", "unshift", "(", "startMatch", "[", "0", "]", ")", ";", "toInject", ".", "push", "(", "endMatch", "[", "0", "]", ")", ";", "}", "const", "previousInnerContent", "=", "targetContent", ".", "substring", "(", "startTag", ".", "lastIndex", ",", "endMatch", ".", "index", ")", ";", "const", "indent", "=", "getLeadingWhitespace", "(", "previousInnerContent", ")", ";", "newContent", "+=", "toInject", ".", "join", "(", "indent", ")", ";", "newContent", "+=", "targetContent", ".", "slice", "(", "endTag", ".", "lastIndex", ")", ";", "targetContent", "=", "newContent", ";", "}", "startTag", ".", "lastIndex", "=", "0", ";", "endTag", ".", "lastIndex", "=", "0", ";", "return", "targetContent", ";", "}" ]

[ "Inject", "tags", "into", "target", "content", "between", "given", "start", "and", "end", "tags" ]

[ "function", "extractFilePaths", "(", "content", ",", "targetPath", ",", "opt", ",", "tagsRegExp", ")", "{", "const", "files", "=", "[", "]", ";", "const", "tagMatches", "=", "content", ".", "match", "(", "tagsRegExp", ".", "start", ")", ";", "if", "(", "tagMatches", ")", "{", "tagMatches", ".", "forEach", "(", "function", "(", "tagMatch", ")", "{", "const", "fileUrl", "=", "tagsRegExp", ".", "startex", ".", "exec", "(", "tagMatch", ")", "[", "1", "]", ";", "const", "filePath", "=", "setFullPath", "(", "targetPath", ",", "opt", ".", "prefix", "+", "fileUrl", ")", ";", "try", "{", "const", "fileContent", "=", "stripBomBuf", "(", "fs", ".", "readFileSync", "(", "filePath", ")", ")", ";", "files", ".", "push", "(", "{", "file", ":", "new", "File", "(", "{", "path", ":", "filePath", ",", "cwd", ":", "__dirname", ",", "base", ":", "path", ".", "resolve", "(", "__dirname", ",", "'expected'", ",", "path", ".", "dirname", "(", "filePath", ")", ")", ",", "contents", ":", "fileContent", "}", ")", ",", "tags", ":", "getRegExpTags", "(", "opt", ",", "fileUrl", ")", "}", ")", ";", "}", "catch", "(", "e", ")", "{", "if", "(", "opt", ".", "ignoreError", ")", "{", "log", "(", "colors", ".", "red", "(", "filePath", "+", "' not found.'", ")", ")", ";", "}", "else", "{", "throw", "error", "(", "filePath", "+", "' not found.'", ")", ";", "}", "}", "tagsRegExp", ".", "startex", ".", "lastIndex", "=", "0", ";", "}", ")", ";", "}", "return", "files", ";", "}" ]

[ "Parse", "content", "and", "get", "all", "partials", "to", "be", "injected" ]

[ "function", "(", "child", ",", "parent", ")", "{", "var", "ctor", "=", "function", "(", ")", "{", "}", ";", "ctor", ".", "prototype", "=", "parent", ".", "prototype", ";", "child", ".", "__super__", "=", "parent", ".", "prototype", ";", "child", ".", "prototype", "=", "new", "ctor", "(", ")", ";", "child", ".", "prototype", ".", "constructor", "=", "child", ";", "child", ".", "fn", "=", "child", ".", "prototype", "}" ]

[ "var", "log", "=", "console", ".", "log" ]

[ "function", "consolidateFiles", "(", "files", ",", "config", ")", "{", "return", "Promise", ".", "resolve", "(", "files", ")", ".", "then", "(", "files", "=>", "{", "var", "data", "=", "{", "}", ";", "files", ".", "forEach", "(", "file", "=>", "{", "var", "path", "=", "file", ".", "relative", ".", "split", "(", "'.'", ")", ".", "shift", "(", ")", ".", "split", "(", "Path", ".", "sep", ")", ";", "if", "(", "path", ".", "length", ">=", "2", "&&", "config", ".", "flattenIndex", ")", "{", "var", "relPath", "=", "path", ".", "splice", "(", "-", "2", ",", "2", ")", ";", "path", "=", "(", "relPath", "[", "0", "]", "===", "relPath", "[", "1", "]", "||", "relPath", "[", "1", "]", "===", "'index'", ")", "?", "path", ".", "concat", "(", "relPath", "[", "0", "]", ")", ":", "path", ".", "concat", "(", "relPath", ")", ";", "}", "data", "[", "path", ".", "join", "(", "'.'", ")", "]", "=", "JSON", ".", "parse", "(", "file", ".", "contents", ".", "toString", "(", ")", ")", ";", "}", ")", ";", "data", "=", "sort", "(", "data", ")", ";", "const", "tree", "=", "expand", "(", "data", ")", ";", "const", "json", "=", "JSON", ".", "stringify", "(", "tree", ")", ";", "return", "Promise", ".", "resolve", "(", "new", "Vinyl", "(", "{", "base", ":", "'/'", ",", "cwd", ":", "'/'", ",", "path", ":", "'/'", "+", "(", "config", ".", "name", "||", "'content.json'", ")", ",", "contents", ":", "new", "Buffer", "(", "json", ")", "}", ")", ")", ";", "}", ")", ";", "}" ]

[ "Consolidates", "JSON", "output", "into", "a", "nested", "and", "sorted", "object", "whose", "hierarchy", "matches", "the", "input", "directory", "structure" ]

[ "function", "isBinary", "(", "file", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "isTextOrBinary", ".", "isText", "(", "Path", ".", "basename", "(", "file", ".", "path", ")", ",", "file", ".", "contents", ",", "(", "err", ",", "isText", ")", "=>", "{", "if", "(", "err", ")", "return", "reject", "(", "err", ")", ";", "if", "(", "isText", ")", "file", ".", "isText", "=", "true", ";", "resolve", "(", "file", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Tests", "if", "file", "content", "is", "ASCII" ]

[ "function", "isJSON", "(", "file", ")", "{", "try", "{", "JSON", ".", "parse", "(", "file", ".", "contents", ".", "toString", "(", ")", ")", ";", "return", "true", ";", "}", "catch", "(", "err", ")", "{", "return", "false", ";", "}", "}" ]

[ "Tests", "if", "file", "content", "is", "valid", "JSON" ]

[ "function", "toJSON", "(", "file", ",", "config", ")", "{", "if", "(", "Path", ".", "extname", "(", "file", ".", "path", ")", "===", "'.json'", ")", "{", "if", "(", "!", "isJSON", "(", "file", ")", ")", "file", ".", "isInvalid", "=", "true", ";", "return", "Promise", ".", "resolve", "(", "file", ")", ";", "}", "let", "jsonFile", "=", "file", ".", "clone", "(", ")", ";", "return", "Promise", ".", "resolve", "(", "file", ")", ".", "then", "(", "file", "=>", "{", "try", "{", "let", "parsed", "=", "frontmatter", "(", "file", ".", "contents", ".", "toString", "(", ")", ")", ";", "return", "Promise", ".", "resolve", "(", "parsed", ")", ";", "}", "catch", "(", "err", ")", "{", "return", "Promise", ".", "reject", "(", "err", ")", ";", "}", "}", ")", ".", "then", "(", "parsed", "=>", "{", "try", "{", "let", "data", "=", "parsed", ".", "attributes", ";", "data", ".", "body", "=", "config", ".", "renderer", ".", "call", "(", "config", ".", "context", ",", "parsed", ".", "body", ")", ";", "return", "Promise", ".", "resolve", "(", "data", ")", ";", "}", "catch", "(", "err", ")", "{", "return", "Promise", ".", "reject", "(", "err", ")", ";", "}", "}", ")", ".", "then", "(", "data", "=>", "{", "if", "(", "!", "data", ".", "title", ")", "{", "let", "extracted", "=", "extractTitle", "(", "data", ".", "body", ",", "config", ".", "stripTitle", ")", ";", "if", "(", "typeof", "extracted", "===", "'object'", ")", "data", "=", "assign", "(", "data", ",", "extracted", ")", ";", "}", "data", ".", "updatedAt", "=", "file", ".", "stat", ".", "mtime", ".", "toISOString", "(", ")", ";", "if", "(", "config", ".", "transform", ")", "var", "transformedData", "=", "config", ".", "transform", "(", "data", ",", "file", ")", ";", "jsonFile", ".", "extname", "=", "'.json'", ";", "jsonFile", ".", "contents", "=", "new", "Buffer", "(", "JSON", ".", "stringify", "(", "transformedData", "||", "data", ")", ")", ";", "return", "Promise", ".", "resolve", "(", "jsonFile", ")", ";", "}", ")", ";", "}" ]

[ "Parse", "text", "files", "for", "YAML", "and", "Markdown", "render", "to", "HTML", "and", "wrap", "in", "JSON" ]

[ "function", "decorateEvents", "(", "comp", ")", "{", "const", "prototype", "=", "(", "comp", ".", "constructor", ")", ".", "prototype", ";", "if", "(", "prototype", ".", "__events", ")", "return", ";", "let", "events", "=", "{", "}", ";", "if", "(", "prototype", ".", "events", ")", "{", "events", "=", "prototype", ".", "events", ";", "}", "Object", ".", "getOwnPropertyNames", "(", "prototype", ")", ".", "map", "(", "propertyName", "=>", "handlerMethodPattern", ".", "exec", "(", "propertyName", ")", ")", ".", "filter", "(", "x", "=>", "x", ")", ".", "forEach", "(", "(", "[", "methodName", ",", "eventType", ",", "eventTarget", "]", ")", "=>", "{", "events", "[", "eventType", "]", "=", "events", "[", "eventType", "]", "||", "{", "}", ";", "events", "[", "eventType", "]", "[", "eventTarget", "]", "=", "comp", "[", "methodName", "]", ";", "}", ")", "prototype", ".", "__events", "=", "events", ";", "}" ]

[ "Fills", "events", "object", "of", "given", "component", "class", "from", "method", "names", "that", "match", "event", "handler", "pattern", "." ]

[ "function", "expectedFile", "(", "file", ")", "{", "const", "filePath", "=", "path", ".", "resolve", "(", "__dirname", ",", "'expected'", ",", "file", ")", ";", "return", "new", "File", "(", "{", "path", ":", "filePath", ",", "cwd", ":", "__dirname", ",", "base", ":", "path", ".", "resolve", "(", "__dirname", ",", "'expected'", ",", "path", ".", "dirname", "(", "file", ")", ")", ",", "contents", ":", "fs", ".", "readFileSync", "(", "filePath", ")", "}", ")", ";", "}" ]

[ "get", "expected", "file" ]

[ "function", "encode", "(", "data", ",", "ch", ")", "{", "if", "(", "!", "self", ".", "utfMouse", ")", "{", "if", "(", "ch", "===", "255", ")", "return", "data", ".", "push", "(", "0", ")", ";", "if", "(", "ch", ">", "127", ")", "ch", "=", "127", ";", "data", ".", "push", "(", "ch", ")", ";", "}", "else", "{", "if", "(", "ch", "===", "2047", ")", "return", "data", ".", "push", "(", "0", ")", ";", "if", "(", "ch", "<", "127", ")", "{", "data", ".", "push", "(", "ch", ")", ";", "}", "else", "{", "if", "(", "ch", ">", "2047", ")", "ch", "=", "2047", ";", "data", ".", "push", "(", "0xC0", "|", "(", "ch", ">>", "6", ")", ")", ";", "data", ".", "push", "(", "0x80", "|", "(", "ch", "&", "0x3F", ")", ")", ";", "}", "}", "}" ]

[ "encode", "button", "and", "position", "to", "characters" ]

[ "function", "_curry2", "(", "fn", ")", "{", "return", "function", "f2", "(", "a", ",", "b", ")", "{", "if", "(", "!", "arguments", ".", "length", ")", "{", "return", "f2", "}", "if", "(", "arguments", ".", "length", "===", "1", ")", "{", "return", "function", "(", "_b", ")", "{", "return", "fn", "(", "a", ",", "_b", ")", "}", "}", "return", "fn", "(", "a", ",", "b", ")", "}", "}" ]

[ "This", "is", "an", "optimized", "internal", "curry", "function", "for", "2", "param", "functions" ]

[ "function", "next", "(", ")", "{", "let", "doNext", "=", "true", "let", "decoded", "=", "false", "const", "decodeCb", "=", "(", "err", ",", "msg", ")", "=>", "{", "decoded", "=", "true", "if", "(", "err", ")", "{", "p", ".", "end", "(", "err", ")", "doNext", "=", "false", "}", "else", "{", "p", ".", "push", "(", "msg", ")", "if", "(", "!", "doNext", ")", "{", "next", "(", ")", "}", "}", "}", "while", "(", "doNext", ")", "{", "decoded", "=", "false", "_decodeFromReader", "(", "reader", ",", "opts", ",", "decodeCb", ")", "if", "(", "!", "decoded", ")", "{", "doNext", "=", "false", "}", "}", "}" ]

[ "this", "function", "has", "to", "be", "written", "without", "recursion", "or", "it", "blows", "the", "stack", "in", "case", "of", "sync", "stream" ]

[ "function", "decodeFromReader", "(", "reader", ",", "opts", ",", "cb", ")", "{", "if", "(", "typeof", "opts", "===", "'function'", ")", "{", "cb", "=", "opts", "opts", "=", "{", "}", "}", "_decodeFromReader", "(", "reader", ",", "opts", ",", "function", "onComplete", "(", "err", ",", "msg", ")", "{", "if", "(", "err", ")", "{", "if", "(", "err", "===", "true", ")", "return", "cb", "(", "new", "Error", "(", "'Unexpected end of input from reader.'", ")", ")", "return", "cb", "(", "err", ")", "}", "cb", "(", "null", ",", "msg", ")", "}", ")", "}" ]

[ "wrapper", "to", "detect", "sudden", "pull", "-", "stream", "disconnects" ]

[ "function", "(", "str", ")", "{", "var", "ret", "=", "new", "Array", "(", "str", ".", "length", ")", ",", "len", "=", "str", ".", "length", ";", "while", "(", "len", "--", ")", "ret", "[", "len", "]", "=", "str", ".", "charCodeAt", "(", "len", ")", ";", "return", "Uint8Array", ".", "from", "(", "ret", ")", ";", "}" ]

[ "we", "do", "not", "need", "Buffer", "pollyfill", "for", "now" ]

[ "function", "parseOption", "(", "nest", ",", "cons", ",", "name", ")", "{", "if", "(", "name", "in", "options", ")", "{", "var", "opt", "=", "options", "[", "name", "]", "var", "prev", "=", "this", "[", "name", "]", "var", "next", "if", "(", "nest", "?", "(", "Array", ".", "isArray", "(", "opt", ")", "&&", "Array", ".", "isArray", "(", "opt", "[", "0", "]", ")", ")", ":", "Array", ".", "isArray", "(", "opt", ")", ")", "{", "this", "[", "name", "]", "=", "next", "=", "[", "cons", "(", "opt", "[", "0", "]", ")", ",", "cons", "(", "opt", "[", "1", "]", ")", ",", "cons", "(", "opt", "[", "2", "]", ")", "]", "}", "else", "{", "this", "[", "name", "]", "=", "next", "=", "[", "cons", "(", "opt", ")", ",", "cons", "(", "opt", ")", ",", "cons", "(", "opt", ")", "]", "}", "for", "(", "var", "i", "=", "0", ";", "i", "<", "3", ";", "++", "i", ")", "{", "if", "(", "next", "[", "i", "]", "!==", "prev", "[", "i", "]", ")", "{", "return", "true", "}", "}", "}", "return", "false", "}" ]

[ "Option", "parsing", "helper", "functions" ]

[ "function", "launchPlayground", "(", ")", "{", "$", "(", "'.playground-item'", ")", ".", "playground", "(", ")", ";", "$", "(", "'.cp_eyedropper'", ")", ".", "on", "(", "'click'", ",", "function", "(", ")", "{", "if", "(", "$", "(", "this", ")", ".", "next", "(", "'.cp_grid'", ")", ".", "hasClass", "(", "'visuallyhidden'", ")", ")", "{", "$", "(", "\".cp_grid\"", ")", ".", "addClass", "(", "'visuallyhidden'", ")", ";", "$", "(", "this", ")", ".", "next", "(", "\".cp_grid\"", ")", ".", "removeClass", "(", "'visuallyhidden'", ")", ";", "}", "else", "{", "$", "(", "this", ")", ".", "next", "(", "\".cp_grid\"", ")", ".", "addClass", "(", "'visuallyhidden'", ")", ";", "}", "}", ")", "$", "(", "document", ")", ".", "on", "(", "'click'", ",", "function", "(", "event", ")", "{", "if", "(", "!", "$", "(", "event", ".", "target", ")", ".", "closest", "(", "'.cp_eyedropper'", ")", ".", "length", "&&", "!", "$", "(", "event", ".", "target", ")", ".", "hasClass", "(", "'playground-list_item'", ")", ")", "{", "$", "(", "\".cp_grid\"", ")", ".", "addClass", "(", "'visuallyhidden'", ")", ";", "}", "}", ")", ";", "$", "(", "'body'", ")", ".", "on", "(", "'playgroundUpdated'", ",", "'.playground-item'", ",", "function", "(", ")", "{", "var", "$input", "=", "$", "(", "this", ")", ",", "base", "=", "$input", ".", "data", "(", "'playground'", ")", ",", "$playground", "=", "$input", ".", "closest", "(", "'.playground'", ")", ",", "$codeEl", ",", "targetHtmlStr", ";", "if", "(", "!", "$playground", ".", "length", ")", "$playground", "=", "$input", ".", "closest", "(", "'article'", ")", ";", "$codeEl", "=", "$playground", ".", "find", "(", "'.exampleWithCode code'", ")", ";", "if", "(", "$playground", ".", "find", "(", "'.copyable'", ")", ".", "length", ")", "{", "targetHtmlStr", "=", "$playground", ".", "find", "(", "'.copyable'", ")", "[", "0", "]", ".", "outerHTML", ";", "}", "else", "if", "(", "$playground", ".", "find", "(", "'.copyable-inner'", ")", ".", "length", ")", "{", "targetHtmlStr", "=", "$playground", ".", "find", "(", "'.copyable-inner'", ")", ".", "html", "(", ")", ";", "}", "else", "{", "targetHtmlStr", "=", "base", ".", "$targetEl", "[", "0", "]", ".", "outerHTML", ";", "}", "$codeEl", ".", "html", "(", "escapeHtml", "(", "targetHtmlStr", ")", ")", ";", "Prism", ".", "highlightElement", "(", "$codeEl", "[", "0", "]", ")", ";", "}", ")", ";", "$", "(", "'.playground-item'", ")", ".", "trigger", "(", "'input'", ")", ";", "}" ]

[ "Sets", "up", "all", "playground", "elements", "and", "makes", "the", "code", "copy", "function", "for", "dynamic", "elements" ]

[ "function", "f", "(", "x", ",", "y", ",", "z", ")", "{", "return", "x", "*", "x", "+", "y", "*", "y", "+", "z", "*", "z", "-", "2.0", "}" ]

[ "Plot", "level", "set", "of", "f", "=", "0" ]

[ "function", "animate", "(", "animationName", ",", "configOrCallback", ")", "{", "return", "this", ".", "each", "(", "function", "eachAnimate", "(", ")", "{", "return", "window", ".", "rb", ".", "animate", ".", "animate", "(", "this", ",", "animationName", ",", "configOrCallback", ")", ";", "}", ")", ";", "}" ]

[ "Add", "a", "Rocketbelt", "animation", "to", "a", "jQuery", "object", "." ]

[ "function", "isFileOrDir", "(", "filePath", ")", "{", "let", "fsStat", ";", "try", "{", "fsStat", "=", "fs", ".", "statSync", "(", "filePath", ")", ";", "}", "catch", "(", "error", ")", "{", "return", "error", ";", "}", "let", "r", "=", "'file'", ";", "if", "(", "fsStat", ".", "isDirectory", "(", ")", ")", "{", "r", "=", "'directory'", ";", "}", "return", "r", ";", "}" ]

[ "Check", "if", "a", "path", "points", "to", "a", "file", "or", "a", "directory" ]

[ "function", "_curry3", "(", "fn", ")", "{", "return", "function", "f3", "(", "a", ",", "b", ",", "c", ")", "{", "switch", "(", "arguments", ".", "length", ")", "{", "case", "0", ":", "return", "f3", "case", "1", ":", "return", "_curry2", "(", "function", "(", "_b", ",", "_c", ")", "{", "return", "fn", "(", "a", ",", "_b", ",", "_c", ")", "}", ")", "case", "2", ":", "return", "function", "(", "_c", ")", "{", "return", "fn", "(", "a", ",", "b", ",", "_c", ")", "}", "default", ":", "return", "fn", "(", "a", ",", "b", ",", "c", ")", "}", "}", "}" ]

[ "This", "is", "an", "optimized", "internal", "curry", "function", "for", "3", "param", "functions" ]

[ "function", "qgen", "(", "options", ")", "{", "const", "defaultOptions", "=", "{", "dest", ":", "DEFAULT_DESTINATION", ",", "cwd", ":", "process", ".", "cwd", "(", ")", ",", "directory", ":", "'qgen-templates'", ",", "config", ":", "'./qgen.json'", ",", "helpers", ":", "undefined", ",", "force", ":", "false", ",", "preview", ":", "false", "}", ";", "const", "configfilePath", "=", "createConfigFilePath", "(", "defaultOptions", ",", "options", ")", ";", "const", "configfileOptions", "=", "loadConfig", "(", "configfilePath", ")", ";", "const", "config", "=", "Object", ".", "assign", "(", "defaultOptions", ",", "configfileOptions", ",", "options", ")", ";", "if", "(", "isFileOrDir", "(", "config", ".", "directory", ")", "!==", "'directory'", ")", "{", "throw", "new", "QGenError", "(", "`", "${", "config", ".", "directory", "}", "`", ")", ";", "}", "const", "templates", "=", "(", ")", "=>", "{", "return", "globby", ".", "sync", "(", "[", "'*'", "]", ",", "{", "cwd", ":", "path", ".", "join", "(", "config", ".", "cwd", ",", "config", ".", "directory", ")", ",", "expandDirectories", ":", "false", ",", "onlyFiles", ":", "false", "}", ")", ";", "}", ";", "const", "render", "=", "async", "(", "template", ",", "destination", ")", "=>", "{", "const", "templatePath", "=", "path", ".", "join", "(", "config", ".", "directory", ",", "template", ")", ";", "const", "templateType", "=", "isFileOrDir", "(", "path", ".", "join", "(", "config", ".", "cwd", ",", "templatePath", ")", ")", ";", "const", "templateConfig", "=", "createTemplateConfig", "(", "config", ",", "template", ",", "DEFAULT_DESTINATION", ")", ";", "const", "filepathRenderer", "=", "templateRenderer", "(", "{", "helpers", ":", "config", ".", "helpers", ",", "cwd", ":", "config", ".", "cwd", "}", ")", ";", "if", "(", "destination", ")", "{", "templateConfig", ".", "dest", "=", "destination", ";", "}", "let", "fileObjects", ";", "if", "(", "templateType", "===", "'directory'", ")", "{", "const", "files", "=", "globby", ".", "sync", "(", "[", "'**/*'", "]", ",", "{", "cwd", ":", "path", ".", "join", "(", "config", ".", "cwd", ",", "templatePath", ")", ",", "nodir", ":", "true", "}", ")", ";", "fileObjects", "=", "files", ".", "map", "(", "filePath", "=>", "{", "return", "{", "src", ":", "path", ".", "join", "(", "templatePath", ",", "filePath", ")", ",", "dest", ":", "path", ".", "join", "(", "templateConfig", ".", "cwd", ",", "templateConfig", ".", "dest", ",", "filepathRenderer", ".", "render", "(", "filePath", ",", "config", ")", ")", "}", ";", "}", ")", ";", "}", "else", "if", "(", "templateType", "===", "'file'", ")", "{", "fileObjects", "=", "[", "{", "src", ":", "templatePath", ",", "dest", ":", "path", ".", "join", "(", "templateConfig", ".", "cwd", ",", "templateConfig", ".", "dest", ",", "template", ")", "}", "]", ";", "}", "else", "{", "throw", "new", "QGenError", "(", "`", "${", "templatePath", "}", "`", ")", ";", "}", "const", "filesForRender", "=", "config", ".", "preview", "?", "fileObjects", ":", "await", "enquireToOverwrite", "(", "fileObjects", ",", "config", ".", "force", ")", ";", "if", "(", "!", "filesForRender", ".", "some", "(", "f", "=>", "f", ".", "abort", ")", ")", "{", "renderFiles", "(", "filesForRender", ",", "templateConfig", ",", "config", ".", "preview", ")", ";", "}", "}", ";", "return", "Object", ".", "freeze", "(", "{", "templates", ",", "render", "}", ")", ";", "}" ]

[ "Creates", "new", "qgen", "object" ]

[ "function", "trapTabKey", "(", "node", ",", "event", ")", "{", "var", "focusableChildren", "=", "getFocusableChildren", "(", "node", ")", ";", "var", "focusedItemIndex", "=", "focusableChildren", ".", "index", "(", "$", "(", "document", ".", "activeElement", ")", ")", ";", "if", "(", "event", ".", "shiftKey", "&&", "focusedItemIndex", "===", "0", ")", "{", "focusableChildren", "[", "focusableChildren", ".", "length", "-", "1", "]", ".", "focus", "(", ")", ";", "event", ".", "preventDefault", "(", ")", ";", "}", "else", "if", "(", "!", "event", ".", "shiftKey", "&&", "focusedItemIndex", "===", "focusableChildren", ".", "length", "-", "1", ")", "{", "focusableChildren", "[", "0", "]", ".", "focus", "(", ")", ";", "event", ".", "preventDefault", "(", ")", ";", "}", "}" ]

[ "Helper", "function", "trapping", "the", "tab", "key", "inside", "a", "node" ]

[ "function", "regexCache", "(", "fn", ",", "str", ",", "opts", ")", "{", "var", "key", "=", "'_default_'", ",", "regex", ",", "cached", ";", "if", "(", "!", "str", "&&", "!", "opts", ")", "{", "if", "(", "typeof", "fn", "!==", "'function'", ")", "{", "return", "fn", ";", "}", "return", "basic", "[", "key", "]", "||", "(", "basic", "[", "key", "]", "=", "fn", "(", "str", ")", ")", ";", "}", "var", "isString", "=", "typeof", "str", "===", "'string'", ";", "if", "(", "isString", ")", "{", "if", "(", "!", "opts", ")", "{", "return", "basic", "[", "str", "]", "||", "(", "basic", "[", "str", "]", "=", "fn", "(", "str", ")", ")", ";", "}", "key", "=", "str", ";", "}", "else", "{", "opts", "=", "str", ";", "}", "cached", "=", "cache", "[", "key", "]", ";", "if", "(", "cached", "&&", "equal", "(", "cached", ".", "opts", ",", "opts", ")", ")", "{", "return", "cached", ".", "regex", ";", "}", "memo", "(", "key", ",", "opts", ",", "(", "regex", "=", "fn", "(", "str", ",", "opts", ")", ")", ")", ";", "return", "regex", ";", "}" ]

[ "Memoize", "the", "results", "of", "a", "call", "to", "the", "new", "RegExp", "constructor", "." ]

[ "function", "(", ")", "{", "var", "peer", "=", "self", ".", "swr", ".", "webrtc", ".", "getPeers", "(", "uid", ")", "[", "0", "]", "var", "success", "if", "(", "peer", ")", "{", "success", "=", "peer", ".", "sendDirectly", "(", "'simplewebrtc'", ",", "'yjs'", ",", "message", ")", "}", "if", "(", "!", "success", ")", "{", "setTimeout", "(", "send", ",", "500", ")", "}", "}" ]

[ "we", "have", "to", "make", "sure", "that", "the", "message", "is", "sent", "under", "all", "circumstances" ]

[ "function", "next", "(", ")", "{", "shake", ".", "read", "(", "PING_LENGTH", ",", "(", "err", ",", "buf", ")", "=>", "{", "if", "(", "err", "===", "true", ")", "{", "return", "}", "if", "(", "err", ")", "{", "return", "log", ".", "error", "(", "err", ")", "}", "shake", ".", "write", "(", "buf", ")", "return", "next", "(", ")", "}", ")", "}" ]

[ "receive", "and", "echo", "back" ]

[ "function", "raw", "(", "obj", ")", "{", "const", "result", "=", "{", "}", "for", "(", "const", "key", "in", "obj", ")", "{", "const", "value", "=", "obj", "[", "key", "]", "if", "(", "value", "!==", "null", "&&", "value", "!==", "undefined", ")", "{", "result", "[", "key", "]", "=", "value", ".", "toString", "(", ")", "}", "}", "return", "result", "}" ]

[ "Serializes", "env", "values", "as", "strings", "." ]

[ "function", "circularSectionsError", "(", "sectionName", ",", "path", ")", "{", "const", "joinedPath", "=", "path", ".", "join", "(", "' -> '", ")", "const", "message", "=", "`", "${", "joinedPath", "}", "${", "sectionName", "}", "`", "return", "new", "Error", "(", "message", ")", "}" ]

[ "Returns", "a", "new", "error", "indicating", "circular", "sections", "." ]

[ "function", "circularImportsError", "(", "fileBeingImported", ",", "importTrail", ")", "{", "const", "message", "=", "`", "${", "fileBeingImported", "}", "\\r", "\\n", "`", "+", "'Import trace:\\r\\n'", "+", "\\r", "\\n", "}" ]

[ "Constructs", "a", "circular", "imports", "error", "." ]

[ "function", "mapFiles", "(", "files", ",", "relative", ",", "required", ")", "{", "if", "(", "!", "files", ")", "{", "return", "[", "]", "}", "if", "(", "Array", ".", "isArray", "(", "files", ")", "===", "false", ")", "{", "files", "=", "[", "files", "]", "}", "return", "files", ".", "map", "(", "f", "=>", "(", "{", "file", ":", "resolvePath", "(", "relative", ",", "f", ")", ",", "required", ":", "required", "}", ")", ")", "}" ]

[ "Maps", "file", "paths", "as", "well", "as", "whether", "not", "they", "are", "required", "to", "descriptors", "." ]

[ "function", "validate", "(", "property", ",", "validators", ")", "{", "let", "errors", "=", "[", "]", ",", "res", ",", "validator", ";", "if", "(", "validators", ")", "{", "for", "(", "let", "i", "=", "0", ",", "_len", "=", "validators", ".", "length", ";", "i", "<", "_len", ";", "i", "++", ")", "{", "validator", "=", "validators", "[", "i", "]", ";", "res", "=", "validateProperty", "(", "property", ",", "validator", ")", ";", "if", "(", "!", "isNull", "(", "res", ")", "&&", "!", "isUndefined", "(", "res", ")", ")", "{", "errors", ".", "push", "(", "res", ")", ";", "}", "}", "}", "return", "{", "name", ":", "property", ".", "name", ",", "value", ":", "property", ".", "value", ",", "isValid", ":", "0", "===", "errors", ".", "length", ",", "errors", ":", "errors", "}", ";", "}" ]

[ "Validae", "a", "property", "given", "validators", "." ]

[ "function", "getErrorLabel", "(", "type", ",", "fieldName", ",", "options", "=", "{", "}", ")", "{", "options", "=", "options", "||", "{", "}", ";", "const", "translationKey", "=", "options", ".", "translationKey", "?", "options", ".", "translationKey", ":", "`", "${", "type", "}", "`", ";", "const", "opts", "=", "{", "fieldName", ":", "translate", "(", "fieldName", ")", ",", "...", "options", "}", ";", "return", "translate", "(", "translationKey", ",", "opts", ")", ";", "}" ]

[ "Get", "the", "error", "label", "from", "a", "type", "and", "a", "field", "name", "." ]

[ "function", "orderAndSort", "(", "sortConf", ")", "{", "return", "{", "sortFieldName", ":", "sortConf", ".", "sortBy", ",", "sortDesc", ":", "sortConf", ".", "sortAsc", "===", "undefined", "?", "false", ":", "!", "sortConf", ".", "sortAsc", "}", ";", "}" ]

[ "Build", "sort", "infotmation", "." ]

[ "function", "pagination", "(", "opts", ")", "{", "let", "{", "isScroll", ",", "dataList", ",", "totalCount", ",", "nbElement", "}", "=", "opts", ";", "if", "(", "isScroll", ")", "{", "if", "(", "!", "isArray", "(", "dataList", ")", ")", "{", "throw", "new", "Error", "(", "'The data list options sould exist and be an array'", ")", "}", "if", "(", "dataList", ".", "length", "<", "totalCount", ")", "{", "return", "{", "top", ":", "nbElement", ",", "skip", ":", "dataList", ".", "length", "}", ";", "}", "}", "return", "{", "top", ":", "nbElement", ",", "skip", ":", "0", "}", "}" ]

[ "Build", "the", "pagination", "configuration", "given", "the", "options", "." ]

[ "function", "triggerPromise", "(", ")", "{", "var", "me", "=", "this", ";", "var", "args", "=", "arguments", ";", "var", "canHandlePromise", "=", "this", ".", "children", ".", "indexOf", "(", "\"completed\"", ")", ">=", "0", "&&", "this", ".", "children", ".", "indexOf", "(", "\"failed\"", ")", ">=", "0", ";", "var", "createdPromise", "=", "new", "PromiseFactory", "(", "function", "(", "resolve", ",", "reject", ")", "{", "if", "(", "me", ".", "willCallPromise", ")", "{", "_", ".", "nextTick", "(", "function", "(", ")", "{", "var", "previousPromise", "=", "me", ".", "promise", ";", "me", ".", "promise", "=", "function", "(", "inputPromise", ")", "{", "inputPromise", ".", "then", "(", "resolve", ",", "reject", ")", ";", "me", ".", "promise", "=", "previousPromise", ";", "return", "me", ".", "promise", ".", "apply", "(", "me", ",", "arguments", ")", ";", "}", ";", "me", ".", "trigger", ".", "apply", "(", "me", ",", "args", ")", ";", "}", ")", ";", "return", ";", "}", "if", "(", "canHandlePromise", ")", "{", "var", "removeSuccess", "=", "me", ".", "completed", ".", "listen", "(", "function", "(", ")", "{", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "removeSuccess", "(", ")", ";", "removeFailed", "(", ")", ";", "resolve", "(", "args", ".", "length", ">", "1", "?", "args", ":", "args", "[", "0", "]", ")", ";", "}", ")", ";", "var", "removeFailed", "=", "me", ".", "failed", ".", "listen", "(", "function", "(", ")", "{", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "removeSuccess", "(", ")", ";", "removeFailed", "(", ")", ";", "reject", "(", "args", ".", "length", ">", "1", "?", "args", ":", "args", "[", "0", "]", ")", ";", "}", ")", ";", "}", "_", ".", "nextTick", "(", "function", "(", ")", "{", "me", ".", "trigger", ".", "apply", "(", "me", ",", "args", ")", ";", "}", ")", ";", "if", "(", "!", "canHandlePromise", ")", "{", "resolve", "(", ")", ";", "}", "}", ")", ";", "createdPromise", ".", "catch", "(", "function", "(", ")", "{", "}", ")", ";", "return", "createdPromise", ";", "}" ]

[ "Returns", "a", "Promise", "for", "the", "triggered", "action" ]

[ "function", "promise", "(", "p", ")", "{", "var", "me", "=", "this", ";", "var", "canHandlePromise", "=", "this", ".", "children", ".", "indexOf", "(", "\"completed\"", ")", ">=", "0", "&&", "this", ".", "children", ".", "indexOf", "(", "\"failed\"", ")", ">=", "0", ";", "if", "(", "!", "canHandlePromise", ")", "{", "throw", "new", "Error", "(", "\"Publisher must have \\\"completed\\\" and \\\"failed\\\" child publishers\"", ")", ";", "}", "\\\"", "}" ]

[ "Attach", "handlers", "to", "promise", "that", "trigger", "the", "completed", "and", "failed", "child", "publishers", "if", "available", "." ]

[ "function", "listenAndPromise", "(", "callback", ",", "bindContext", ")", "{", "var", "me", "=", "this", ";", "bindContext", "=", "bindContext", "||", "this", ";", "this", ".", "willCallPromise", "=", "(", "this", ".", "willCallPromise", "||", "0", ")", "+", "1", ";", "var", "removeListen", "=", "this", ".", "listen", "(", "function", "(", ")", "{", "if", "(", "!", "callback", ")", "{", "throw", "new", "Error", "(", "\"Expected a function returning a promise but got \"", "+", "callback", ")", ";", "}", "var", "args", "=", "arguments", ",", "returnedPromise", "=", "callback", ".", "apply", "(", "bindContext", ",", "args", ")", ";", "return", "me", ".", "promise", ".", "call", "(", "me", ",", "returnedPromise", ")", ";", "}", ",", "bindContext", ")", ";", "return", "function", "(", ")", "{", "me", ".", "willCallPromise", "--", ";", "removeListen", ".", "call", "(", "me", ")", ";", "}", ";", "}" ]

[ "Subscribes", "the", "given", "callback", "for", "action", "triggered", "which", "should", "return", "a", "promise", "that", "in", "turn", "is", "passed", "to", "this", ".", "promise" ]

[ "function", "hasRole", "(", "role", ")", "{", "role", "=", "isArray", "(", "role", ")", "?", "role", ":", "[", "role", "]", ";", "return", "0", "<", "intersection", "(", "role", ",", "userBuiltInStore", ".", "getRoles", "(", ")", ")", ".", "length", ";", "}" ]

[ "Check", "if", "a", "user", "has", "the", "givent", "role", "or", "roles", "." ]

[ "function", "check", "(", "file", ",", "frontmatter", ")", "{", "if", "(", "!", "match", "(", "file", ",", "pattern", ")", "[", "0", "]", ")", "{", "return", "false", ";", "}", "if", "(", "get", "(", "frontmatter", ",", "privateProperty", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Checks", "whether", "files", "should", "be", "processed" ]

[ "function", "buildUrl", "(", "file", ",", "frontmatter", ")", "{", "var", "canonicalUrl", "=", "get", "(", "frontmatter", ",", "urlProperty", ")", ";", "if", "(", "is", ".", "string", "(", "canonicalUrl", ")", ")", "{", "return", "canonicalUrl", ";", "}", "var", "indexFile", "=", "'index.html'", ";", "if", "(", "omitIndex", "&&", "path", ".", "basename", "(", "file", ")", "===", "indexFile", ")", "{", "return", "replaceBackslash", "(", "file", ".", "slice", "(", "0", ",", "0", "-", "indexFile", ".", "length", ")", ")", ";", "}", "if", "(", "omitExtension", ")", "{", "return", "replaceBackslash", "(", "file", ".", "slice", "(", "0", ",", "0", "-", "path", ".", "extname", "(", "file", ")", ".", "length", ")", ")", ";", "}", "return", "replaceBackslash", "(", "file", ")", ";", "}" ]

[ "Builds", "a", "url" ]

[ "function", "init", "(", "format", "=", "DEFAULT_FORMAT", ",", "locale", "=", "'fr'", ")", "{", "numeral", ".", "locale", "(", "locale", ")", ";", "numeral", ".", "defaultFormat", "(", "format", ")", ";", "}" ]

[ "Initialize", "numeral", "locale", "and", "default", "format", "." ]

[ "function", "updateRequestStatus", "(", "request", ")", "{", "if", "(", "!", "request", "||", "!", "request", ".", "id", "||", "!", "request", ".", "status", ")", "{", "return", ";", "}", "dispatcher", ".", "handleViewAction", "(", "{", "data", ":", "{", "request", ":", "request", "}", ",", "type", ":", "'update'", "}", ")", ";", "return", "request", ";", "}" ]

[ "Update", "the", "request", "status", "." ]

[ "function", "getResponseContent", "(", "response", ",", "dataType", ")", "{", "const", "{", "type", ",", "status", ",", "ok", "}", "=", "response", ";", "if", "(", "type", "===", "'opaque'", ")", "{", "console", ".", "error", "(", "'You tried to make a Cross Domain Request with no-cors options'", ")", ";", "return", "Promise", ".", "reject", "(", "{", "status", ":", "status", ",", "globalErrors", ":", "[", "'error.noCorsOptsOnCors'", "]", "}", ")", ";", "}", "if", "(", "type", "===", "'error'", ")", "{", "console", ".", "error", "(", "'An unknown network issue has happened'", ")", ";", "return", "Promise", ".", "reject", "(", "{", "status", ":", "status", ",", "globalErrors", ":", "[", "'error.unknownNetworkIssue'", "]", "}", ")", ";", "}", "if", "(", "!", "ok", "&&", "dataType", "===", "'json'", ")", "{", "return", "response", ".", "json", "(", ")", ".", "catch", "(", "err", "=>", "Promise", ".", "reject", "(", "{", "globalErrors", ":", "[", "err", "]", "}", ")", ")", ".", "then", "(", "data", "=>", "Promise", ".", "reject", "(", "{", "status", ",", "...", "data", "}", ")", ")", ";", "}", "if", "(", "!", "ok", ")", "{", "return", "response", ".", "text", "(", ")", ".", "then", "(", "text", "=>", "Promise", ".", "reject", "(", "{", "status", ",", "globalErrors", ":", "[", "text", "]", "}", ")", ")", ";", "}", "if", "(", "ok", "&&", "status", "===", "'204'", ")", "{", "return", "Promise", ".", "resolve", "(", "null", ")", ";", "}", "return", "[", "'arrayBuffer'", ",", "'blob'", ",", "'formData'", ",", "'json'", "]", ".", "includes", "(", "dataType", ")", "?", "response", "[", "dataType", "]", "(", ")", ".", "catch", "(", "err", "=>", "Promise", ".", "reject", "(", "{", "globalErrors", ":", "[", "err", "]", "}", ")", ")", ":", "response", ".", "text", "(", ")", ";", "}" ]

[ "Extract", "the", "data", "from", "the", "response", "and", "handle", "network", "or", "server", "errors", "or", "wrong", "data", "format", "." ]

[ "function", "checkErrors", "(", "response", ",", "xhrErrors", ")", "{", "let", "{", "status", ",", "ok", "}", "=", "response", ";", "if", "(", "!", "ok", ")", "{", "if", "(", "xhrErrors", "[", "status", "]", ")", "{", "xhrErrors", "[", "status", "]", "(", "response", ")", ";", "}", "}", "}" ]

[ "Check", "if", "a", "special", "treatment", "is", "specify", "for", "a", "specific", "error", "code" ]

[ "function", "wrappingFetch", "(", "{", "url", ",", "method", ",", "data", "}", ",", "optionsArg", ")", "{", "let", "requestStatus", "=", "createRequestStatus", "(", ")", ";", "let", "{", "CORS", ",", "isCORS", ",", "xhrErrors", ",", "...", "config", "}", "=", "configGetter", "(", ")", ";", "const", "{", "noStringify", ",", "...", "options", "}", "=", "optionsArg", "||", "{", "}", ";", "const", "reqOptions", "=", "merge", "(", "{", "headers", ":", "{", "}", "}", ",", "config", ",", "options", ",", "{", "method", ",", "body", ":", "noStringify", "?", "data", ":", "JSON", ".", "stringify", "(", "data", ")", "}", ")", ";", "if", "(", "!", "reqOptions", ".", "noContentType", "&&", "!", "reqOptions", ".", "headers", "[", "'Content-Type'", "]", ")", "{", "reqOptions", ".", "headers", "[", "'Content-Type'", "]", "=", "'application/json'", ";", "}", "updateRequestStatus", "(", "{", "id", ":", "requestStatus", ".", "id", ",", "status", ":", "'pending'", "}", ")", ";", "return", "fetch", "(", "url", ",", "reqOptions", ")", ".", "catch", "(", "error", "=>", "{", "updateRequestStatus", "(", "{", "id", ":", "requestStatus", ".", "id", ",", "status", ":", "'error'", "}", ")", ";", "return", "Promise", ".", "reject", "(", "{", "globalErrors", ":", "[", "error", "]", "}", ")", ";", "}", ")", ".", "then", "(", "response", "=>", "{", "updateRequestStatus", "(", "{", "id", ":", "requestStatus", ".", "id", ",", "status", ":", "response", ".", "ok", "?", "'success'", ":", "'error'", "}", ")", ";", "const", "contentType", "=", "response", ".", "headers", ".", "get", "(", "'content-type'", ")", ";", "return", "getResponseContent", "(", "response", ",", "reqOptions", ".", "dataType", "?", "reqOptions", ".", "dataType", ":", "contentType", "&&", "contentType", ".", "includes", "(", "'application/json'", ")", "?", "'json'", ":", "'text'", ")", ";", "}", ")", ".", "catch", "(", "data", "=>", "{", "checkErrors", "(", "data", ",", "xhrErrors", ")", ";", "return", "Promise", ".", "reject", "(", "data", ")", ";", "}", ")", ";", "}" ]

[ "Fetch", "function", "to", "ease", "http", "request", "." ]