_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3 values | text stringlengths 52 373k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q61900 | val | validation | function val(node, _val2) {
if (node && node.el) {
var el = node.el;
if (_val2 !== undefined) {
el.value = _val2;
} else {
return el.value;
}
}
} | javascript | {
"resource": ""
} |
q61901 | on | validation | function on(element, ev, cb, context) {
for (var _len = arguments.length, args = Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
args[_key - 4] = arguments[_key];
}
var _this = this;
var el = element.el,
events = ev.split(' '),
fn = function fn(e) {
cb.apply(context || _this, [e, element].concat(args));
};
events.forEach(function (event) {
el.addEventListener(event, fn);
});
var evt = {
remove: function remove() {
events.forEach(function (event) {
return el.removeEventListener(event, fn);
});
var evts = element._events;
evts.splice(evts.indexOf(evt), 1);
}
};
element._events.push(evt);
return evt;
} | javascript | {
"resource": ""
} |
q61902 | remove | validation | function remove(el) {
while (el._events.length > 0) {
el._events.shift().remove();
}
if (el.children) {
destroy(el.children);
}
if (el.elGroup !== undefined) {
el.elGroup.delete(el.el);
}
if (el.el !== undefined) {
if (el.el.remove) {
el.el.remove();
} else if (el.el.parentNode) {
el.el.parentNode.removeChild(el.el);
}
delete el.el;
}
} | javascript | {
"resource": ""
} |
q61903 | onDOMAttached | validation | function onDOMAttached(el) {
var _this2 = this;
var handlers = [],
attached = false,
_step = undefined;
if (el.el !== undefined) {
_step = function step() {
if (attached) {
while (handlers.length > 0) {
handlers.shift()();
}
} else {
window.requestAnimationFrame(_step);
if (document.body.contains(el.el)) {
attached = true;
}
}
};
}
return {
then: function then(cb, context) {
handlers.push(cb.bind(context || _this2));
window.requestAnimationFrame(_step);
}
};
} | javascript | {
"resource": ""
} |
q61904 | match | validation | function match({ just, nothing }) {
return function (maybe) {
for (const value of maybe) {
return just(value);
}
return nothing();
};
} | javascript | {
"resource": ""
} |
q61905 | flatMap | validation | function flatMap(mapper) {
return function (maybe) {
for (const value of maybe) {
return mapper(value);
}
return maybe_1.nothing();
};
} | javascript | {
"resource": ""
} |
q61906 | filter | validation | function filter(predicate) {
return flatMap(value => predicate(value) ? maybe_1.just(value) : maybe_1.nothing());
} | javascript | {
"resource": ""
} |
q61907 | or | validation | function or(defaultValue) {
return function (maybe) {
for (const value of maybe) {
return maybe_1.just(value);
}
return defaultValue;
};
} | javascript | {
"resource": ""
} |
q61908 | validation | function(e){
var history=S.History, current = history.getFragment();
if(OLD_IE && current == history.fragment && history.iframe) current = history.getFragment(history.getHash(history.iframe));
if(current == history.fragment) return false;
if(history.iframe) history.navigate(current);
history.loadUrl();
} | javascript | {
"resource": ""
} | |
q61909 | validation | function(fragmentOverride,state){
var fragment = baseUrl+( this.fragment = this.getFragment(fragmentOverride));
if(fragment){
var a=$('a[href="'+fragment+'"]');
a.length===0 ? S.redirect(fragment) : a.click();
}
} | javascript | {
"resource": ""
} | |
q61910 | createInstance | test | function createInstance(defaultConfig) {
var context = new Axios(defaultConfig);
var instance = bind(Axios.prototype.request, context);
// Copy axios.prototype to instance
utils.extend(instance, Axios.prototype, context);
// Copy context to instance
utils.extend(instance, context);
return instance;
} | javascript | {
"resource": ""
} |
q61911 | CancelToken | test | function CancelToken(executor) {
if (typeof executor !== 'function') {
throw new TypeError('executor must be a function.');
}
var resolvePromise;
this.promise = new Promise(function promiseExecutor(resolve) {
resolvePromise = resolve;
});
var token = this;
executor(function cancel(message) {
if (token.reason) {
// Cancellation has already been requested
return;
}
token.reason = new Cancel(message);
resolvePromise(token.reason);
});
} | javascript | {
"resource": ""
} |
q61912 | isArrayBufferView | test | function isArrayBufferView(val) {
var result;
if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
result = ArrayBuffer.isView(val);
} else {
result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
}
return result;
} | javascript | {
"resource": ""
} |
q61913 | isStandardBrowserEnv | test | function isStandardBrowserEnv() {
if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
navigator.product === 'NativeScript' ||
navigator.product === 'NS')) {
return false;
}
return (
typeof window !== 'undefined' &&
typeof document !== 'undefined'
);
} | javascript | {
"resource": ""
} |
q61914 | forEach | test | function forEach(obj, fn) {
// Don't bother if no value provided
if (obj === null || typeof obj === 'undefined') {
return;
}
// Force an array if not already something iterable
if (typeof obj !== 'object') {
/*eslint no-param-reassign:0*/
obj = [obj];
}
if (isArray(obj)) {
// Iterate over array values
for (var i = 0, l = obj.length; i < l; i++) {
fn.call(null, obj[i], i, obj);
}
} else {
// Iterate over object keys
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
fn.call(null, obj[key], key, obj);
}
}
}
} | javascript | {
"resource": ""
} |
q61915 | extend | test | function extend(a, b, thisArg) {
forEach(b, function assignValue(val, key) {
if (thisArg && typeof val === 'function') {
a[key] = bind(val, thisArg);
} else {
a[key] = val;
}
});
return a;
} | javascript | {
"resource": ""
} |
q61916 | writePackageManifest | test | function writePackageManifest (packageName) {
const packagePath = require.resolve(packageName + '/package.json')
let { name, main, author, license, types, typings } = require(packagePath)
if (!main) {
main = 'index.js'
}
let typesFile = types || typings
if (typesFile) {
typesFile = require.resolve(join(packageName, typesFile))
}
const compiledPackagePath = join(__dirname, `dist/compiled/${packageName}`)
const potentialLicensePath = join(dirname(packagePath), './LICENSE')
if (existsSync(potentialLicensePath)) {
this._.files.push({
dir: compiledPackagePath,
base: 'LICENSE',
data: readFileSync(potentialLicensePath, 'utf8')
})
}
this._.files.push({
dir: compiledPackagePath,
base: 'package.json',
data:
JSON.stringify(
Object.assign(
{},
{ name, main: `${basename(main, '.' + extname(main))}` },
author ? { author } : undefined,
license ? { license } : undefined,
typesFile
? {
types: relative(compiledPackagePath, typesFile)
}
: undefined
)
) + '\n'
})
} | javascript | {
"resource": ""
} |
q61917 | processMessage | test | function processMessage (e) {
const obj = JSON.parse(e.data)
switch (obj.action) {
case 'building': {
console.log(
'[HMR] bundle ' + (obj.name ? "'" + obj.name + "' " : '') +
'rebuilding'
)
break
}
case 'built':
case 'sync': {
clearOutdatedErrors()
if (obj.hash) {
handleAvailableHash(obj.hash)
}
if (obj.warnings.length > 0) {
handleWarnings(obj.warnings)
}
if (obj.errors.length > 0) {
// When there is a compilation error coming from SSR we have to reload the page on next successful compile
if (obj.action === 'sync') {
hadRuntimeError = true
}
handleErrors(obj.errors)
break
}
handleSuccess()
break
}
default: {
if (customHmrEventHandler) {
customHmrEventHandler(obj)
break
}
break
}
}
} | javascript | {
"resource": ""
} |
q61918 | tryApplyUpdates | test | async function tryApplyUpdates (onHotUpdateSuccess) {
if (!module.hot) {
// HotModuleReplacementPlugin is not in Webpack configuration.
console.error('HotModuleReplacementPlugin is not in Webpack configuration.')
// window.location.reload();
return
}
if (!isUpdateAvailable() || !canApplyUpdates()) {
return
}
function handleApplyUpdates (err, updatedModules) {
if (err || hadRuntimeError) {
if (err) {
console.warn('Error while applying updates, reloading page', err)
}
if (hadRuntimeError) {
console.warn('Had runtime error previously, reloading page')
}
window.location.reload()
return
}
if (typeof onHotUpdateSuccess === 'function') {
// Maybe we want to do something.
onHotUpdateSuccess()
}
if (isUpdateAvailable()) {
// While we were updating, there was a new update! Do it again.
tryApplyUpdates()
}
}
// https://webpack.github.io/docs/hot-module-replacement.html#check
try {
const updatedModules = await module.hot.check(/* autoApply */ {
ignoreUnaccepted: true
})
if (updatedModules) {
handleApplyUpdates(null, updatedModules)
}
} catch (err) {
handleApplyUpdates(err, null)
}
} | javascript | {
"resource": ""
} |
q61919 | tryApplyUpdates | test | async function tryApplyUpdates () {
if (!isUpdateAvailable() || !canApplyUpdates()) {
return
}
try {
const res = await fetch(`${hotUpdatePath}${curHash}.hot-update.json`)
const data = await res.json()
const curPage = page === '/' ? 'index' : page
const pageUpdated = Object.keys(data.c)
.some(mod => {
return (
mod.indexOf(`pages${curPage.substr(0, 1) === '/' ? curPage : `/${curPage}`}`) !== -1 ||
mod.indexOf(`pages${curPage.substr(0, 1) === '/' ? curPage : `/${curPage}`}`.replace(/\//g, '\\')) !== -1
)
})
if (pageUpdated) {
document.location.reload(true)
} else {
curHash = mostRecentHash
}
} catch (err) {
console.error('Error occurred checking for update', err)
document.location.reload(true)
}
} | javascript | {
"resource": ""
} |
q61920 | formatMessage | test | function formatMessage (message, isError) {
let lines = message.split('\n')
// Strip Webpack-added headers off errors/warnings
// https://github.com/webpack/webpack/blob/master/lib/ModuleError.js
lines = lines.filter(line => !/Module [A-z ]+\(from/.test(line))
// Transform parsing error into syntax error
// TODO: move this to our ESLint formatter?
lines = lines.map(line => {
const parsingError = /Line (\d+):(?:(\d+):)?\s*Parsing error: (.+)$/.exec(
line
)
if (!parsingError) {
return line
}
const [, errorLine, errorColumn, errorMessage] = parsingError
return `${friendlySyntaxErrorLabel} ${errorMessage} (${errorLine}:${errorColumn})`
})
message = lines.join('\n')
// Smoosh syntax errors (commonly found in CSS)
message = message.replace(
/SyntaxError\s+\((\d+):(\d+)\)\s*(.+?)\n/g,
`${friendlySyntaxErrorLabel} $3 ($1:$2)\n`
)
// Remove columns from ESLint formatter output (we added these for more
// accurate syntax errors)
message = message.replace(/Line (\d+):\d+:/g, 'Line $1:')
// Clean up export errors
message = message.replace(
/^.*export '(.+?)' was not found in '(.+?)'.*$/gm,
`Attempted import error: '$1' is not exported from '$2'.`
)
message = message.replace(
/^.*export 'default' \(imported as '(.+?)'\) was not found in '(.+?)'.*$/gm,
`Attempted import error: '$2' does not contain a default export (imported as '$1').`
)
message = message.replace(
/^.*export '(.+?)' \(imported as '(.+?)'\) was not found in '(.+?)'.*$/gm,
`Attempted import error: '$1' is not exported from '$3' (imported as '$2').`
)
lines = message.split('\n')
// Remove leading newline
if (lines.length > 2 && lines[1].trim() === '') {
lines.splice(1, 1)
}
// Clean up file name
lines[0] = lines[0].replace(/^(.*) \d+:\d+-\d+$/, '$1')
// Cleans up verbose "module not found" messages for files and packages.
if (lines[1] && lines[1].indexOf('Module not found: ') === 0) {
lines = [
lines[0],
lines[1]
.replace('Error: ', '')
.replace('Module not found: Cannot find file:', 'Cannot find file:')
]
}
message = lines.join('\n')
// Internal stacks are generally useless so we strip them... with the
// exception of stacks containing `webpack:` because they're normally
// from user code generated by Webpack. For more information see
// https://github.com/facebook/create-react-app/pull/1050
message = message.replace(
/^\s*at\s((?!webpack:).)*:\d+:\d+[\s)]*(\n|$)/gm,
''
) // at ... ...:x:y
message = message.replace(/^\s*at\s<anonymous>(\n|$)/gm, '') // at <anonymous>
lines = message.split('\n')
// Remove duplicated newlines
lines = lines.filter(
(line, index, arr) =>
index === 0 || line.trim() !== '' || line.trim() !== arr[index - 1].trim()
)
// Reassemble the message
message = lines.join('\n')
return message.trim()
} | javascript | {
"resource": ""
} |
q61921 | UDecimalPad | test | function UDecimalPad(num, precision) {
var value = UDecimalString(num);
assert.equal("number", typeof precision === 'undefined' ? 'undefined' : (0, _typeof3.default)(precision), "precision");
var part = value.split(".");
if (precision === 0 && part.length === 1) {
return part[0];
}
if (part.length === 1) {
return part[0] + '.' + "0".repeat(precision);
} else {
var pad = precision - part[1].length;
assert(pad >= 0, 'decimal \'' + value + '\' exceeds precision ' + precision);
return part[0] + '.' + part[1] + "0".repeat(pad);
}
} | javascript | {
"resource": ""
} |
q61922 | parseSegment | test | function parseSegment(buffer, offset) {
let typeKey = buffer[offset];
if (typeKey <= 20) {
if (buffer[offset + 1] == undefined) throw new Error("ParseError: No value for uint8");
return { typeKey: typeKey, value: buffer[offset + 1], bufferLength: 2 };
}
if (typeKey <= 40) {
if (buffer[offset + 2] == undefined) throw new Error("ParseError: Incomplete value for uint16");
return { typeKey: typeKey, value: buffer.readUInt16BE(offset + 1), bufferLength: 3 };
}
else if (typeKey <= 90) {
if (buffer[offset + 4] == undefined) throw new Error("ParseError: Incomplete value for uint32");
return { typeKey: typeKey, value: buffer.readUInt32BE(offset + 1), bufferLength: 5 };
}
else if (typeKey <= 155) {
if (buffer[offset + 1] == undefined) throw new Error("ParseError: Incomplete length value for string");
let len = buffer.readUInt8(offset + 1);
if (buffer[offset + 1 + len] == undefined) throw new Error("ParseError: Incomplete value for string");
let value = buffer.toString("utf8", offset + 2, offset + 2 + len);
return { typeKey: typeKey, value: value, bufferLength: 2 + len };
}
else if (typeKey <= 165) {
if (buffer[offset + 16] == undefined) throw new Error("ParseError: Incomplete value for uuid");
let len = 16;
let value = new Buffer(len);
buffer.copy(value, 0, offset + 1, offset + 1 + len);
return { typeKey: typeKey, value: value, bufferLength: 1 + len };
}
else if (typeKey <= 180) {
if (buffer[offset + 1] == undefined) throw new Error("ParseError: Incomplete length value for byte string");
let len = buffer.readUInt8(offset + 1);
if (buffer[offset + len + 1] == undefined) throw new Error("ParseError: Incomplete value for byte string");
let value = new Buffer(len);
buffer.copy(value, 0, offset + 2, offset + 2 + len);
return { typeKey: typeKey, value: value, bufferLength: 2 + len };
}
else {
throw new Error("typeKey not supported");
}
} | javascript | {
"resource": ""
} |
q61923 | parseSegments | test | function parseSegments(buffer) {
if (buffer.length == 0) throw new Error("bad segments stream");
let pointer = 0;
let segments = [ ];
while (pointer < buffer.length) {
let seg = parseSegment(buffer, pointer);
segments.push(seg);
pointer += seg.bufferLength;
delete seg.bufferLength;
}
if (pointer != buffer.length) {
throw new Error("Bad / incomplete segments");
}
return segments;
} | javascript | {
"resource": ""
} |
q61924 | parseQRCode | test | function parseQRCode(text, options) {
if (text.length < 3 || text.length > 2000) throw new Error("Invalid length of EvtLink");
let textSplited = text.split("_");
if (textSplited.length > 2) return null;
let rawText;
if (textSplited[0].startsWith(qrPrefix)) {
rawText = textSplited[0].substr(qrPrefix.length);
}
else {
rawText = textSplited[0];
}
// decode segments base42
let segmentsBytes = EvtLink.dec2b(rawText);
if (segmentsBytes.length < 2) throw new Error("no flag in segment");
let flag = segmentsBytes.readInt16BE(0);
if ((flag & 1) == 0) { // check version of EvtLink
throw new Error("The EvtLink is invalid or its version is newer than version 1 and is not supported by evtjs yet");
}
let segmentsBytesRaw = new Buffer(segmentsBytes.length - 2);
segmentsBytes.copy(segmentsBytesRaw, 0, 2, segmentsBytes.length);
let publicKeys = [ ];
let signatures = [ ];
if (textSplited[1]) {
let buf = EvtLink.dec2b(textSplited[1]);
let i = 0;
if (buf.length % 65 !== 0) {
throw new Error("length of signature is invalid");
}
while (i * 65 < buf.length) {
let current = new Buffer(65);
buf.copy(current, 0, i * 65, i * 65 + 65);
let signature = ecc.Signature.fromBuffer(current);
signatures.push(signature.toString());
if (!options || options.recoverPublicKeys) {
publicKeys.push(signature.recover(segmentsBytes).toString());
}
++i;
}
}
return { flag, segments: parseSegments(segmentsBytesRaw), publicKeys, signatures };
} | javascript | {
"resource": ""
} |
q61925 | __calcKeyProvider | test | async function __calcKeyProvider(keyProvider) {
if (!keyProvider) { return []; }
// if keyProvider is function
if (keyProvider.apply && keyProvider.call) {
keyProvider = keyProvider();
}
// resolve for Promise
keyProvider = await Promise.resolve(keyProvider);
if (!Array.isArray(keyProvider)) {
keyProvider = [ keyProvider ];
}
for (let key of keyProvider) {
if (!EvtKey.isValidPrivateKey(key)) {
throw new Error("Invalid private key");
}
}
return keyProvider;
} | javascript | {
"resource": ""
} |
q61926 | random32ByteBuffer | test | function random32ByteBuffer({cpuEntropyBits = 0, safe = true} = {}) {
assert.equal(typeof cpuEntropyBits, "number", "cpuEntropyBits");
assert.equal(typeof safe, "boolean", "boolean");
if(safe) {
assert(entropyCount >= 128, "Call initialize() to add entropy (current: " + entropyCount + ")");
}
// if(entropyCount > 0) {
// console.log(`Additional private key entropy: ${entropyCount} events`)
// }
const hash_array = [];
hash_array.push(randomBytes(32));
hash_array.push(Buffer.from(cpuEntropy(cpuEntropyBits)));
hash_array.push(externalEntropyArray);
hash_array.push(browserEntropy());
return hash.sha256(Buffer.concat(hash_array));
} | javascript | {
"resource": ""
} |
q61927 | addEntropy | test | function addEntropy(...ints) {
assert.equal(externalEntropyArray.length, 101, "externalEntropyArray");
entropyCount += ints.length;
for(const i of ints) {
const pos = entropyPos++ % 101;
const i2 = externalEntropyArray[pos] += i;
if(i2 > 9007199254740991)
externalEntropyArray[pos] = 0;
}
} | javascript | {
"resource": ""
} |
q61928 | cpuEntropy | test | function cpuEntropy(cpuEntropyBits = 128) {
let collected = [];
let lastCount = null;
let lowEntropySamples = 0;
while(collected.length < cpuEntropyBits) {
const count = floatingPointCount();
if(lastCount != null) {
const delta = count - lastCount;
if(Math.abs(delta) < 1) {
lowEntropySamples++;
continue;
}
// how many bits of entropy were in this sample
const bits = Math.floor(log2(Math.abs(delta)) + 1);
if(bits < 4) {
if(bits < 2) {
lowEntropySamples++;
}
continue;
}
collected.push(delta);
}
lastCount = count;
}
if(lowEntropySamples > 10) {
const pct = Number(lowEntropySamples / cpuEntropyBits * 100).toFixed(2);
// Is this algorithm getting inefficient?
console.warn(`WARN: ${pct}% low CPU entropy re-sampled`);
}
return collected;
} | javascript | {
"resource": ""
} |
q61929 | cryptoJsDecrypt | test | function cryptoJsDecrypt(message, key, iv) {
assert(message, "Missing cipher text");
message = toBinaryBuffer(message);
const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
// decipher.setAutoPadding(true)
message = Buffer.concat([decipher.update(message), decipher.final()]);
return message;
} | javascript | {
"resource": ""
} |
q61930 | initialize | test | function initialize() {
if(initialized) {
return;
}
unitTest();
keyUtils.addEntropy(...keyUtils.cpuEntropy());
assert(keyUtils.entropyCount() >= 128, "insufficient entropy");
initialized = true;
} | javascript | {
"resource": ""
} |
q61931 | montConvert | test | function montConvert(x) {
var r = new BigInteger()
x.abs()
.dlShiftTo(this.m.t, r)
r.divRemTo(this.m, null, r)
if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r, r)
return r
} | javascript | {
"resource": ""
} |
q61932 | verify | test | function verify(data, pubkey, encoding = "utf8") {
if (typeof data === "string") {
data = Buffer.from(data, encoding);
}
assert(Buffer.isBuffer(data), "data is a required String or Buffer");
data = hash.sha256(data);
return verifyHash(data, pubkey);
} | javascript | {
"resource": ""
} |
q61933 | recover | test | function recover(data, encoding = "utf8") {
if (typeof data === "string") {
data = Buffer.from(data, encoding);
}
assert(Buffer.isBuffer(data), "data is a required String or Buffer");
data = hash.sha256(data);
return recoverHash(data);
} | javascript | {
"resource": ""
} |
q61934 | invokeWith | test | function invokeWith(msg) {
// Debugging can be done using println like this
print('Finding comments in ' + msg.getRequestHeader().getURI().toString());
var body = msg.getResponseBody().toString()
// Look for html comments
if (body.indexOf('<!--') > 0) {
var o = body.indexOf('<!--');
while (o > 0) {
var e = body.indexOf('-->', o);
print("\t" + body.substr(o,e-o+3))
o = body.indexOf('<!--', e);
}
}
} | javascript | {
"resource": ""
} |
q61935 | FormGroup | test | function FormGroup(props) {
const { children, className, grouped, inline, unstackable, widths } = props
const classes = cx(
useKeyOnly(grouped, 'grouped'),
useKeyOnly(inline, 'inline'),
useKeyOnly(unstackable, 'unstackable'),
useWidthProp(widths, null, true),
'fields',
className,
)
const rest = getUnhandledProps(FormGroup, props)
const ElementType = getElementType(FormGroup, props)
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61936 | Loader | test | function Loader(props) {
const {
active,
children,
className,
content,
disabled,
indeterminate,
inline,
inverted,
size,
} = props
const classes = cx(
'ui',
size,
useKeyOnly(active, 'active'),
useKeyOnly(disabled, 'disabled'),
useKeyOnly(indeterminate, 'indeterminate'),
useKeyOnly(inverted, 'inverted'),
useKeyOnly(children || content, 'text'),
useKeyOrValueAndKey(inline, 'inline'),
'loader',
className,
)
const rest = getUnhandledProps(Loader, props)
const ElementType = getElementType(Loader, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61937 | ItemContent | test | function ItemContent(props) {
const { children, className, content, description, extra, header, meta, verticalAlign } = props
const classes = cx(useVerticalAlignProp(verticalAlign), 'content', className)
const rest = getUnhandledProps(ItemContent, props)
const ElementType = getElementType(ItemContent, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{ItemHeader.create(header, { autoGenerateKey: false })}
{ItemMeta.create(meta, { autoGenerateKey: false })}
{ItemDescription.create(description, { autoGenerateKey: false })}
{ItemExtra.create(extra, { autoGenerateKey: false })}
{content}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61938 | Table | test | function Table(props) {
const {
attached,
basic,
celled,
children,
className,
collapsing,
color,
columns,
compact,
definition,
fixed,
footerRow,
headerRow,
headerRows,
inverted,
padded,
renderBodyRow,
selectable,
singleLine,
size,
sortable,
stackable,
striped,
structured,
tableData,
textAlign,
unstackable,
verticalAlign,
} = props
const classes = cx(
'ui',
color,
size,
useKeyOnly(celled, 'celled'),
useKeyOnly(collapsing, 'collapsing'),
useKeyOnly(definition, 'definition'),
useKeyOnly(fixed, 'fixed'),
useKeyOnly(inverted, 'inverted'),
useKeyOnly(selectable, 'selectable'),
useKeyOnly(singleLine, 'single line'),
useKeyOnly(sortable, 'sortable'),
useKeyOnly(stackable, 'stackable'),
useKeyOnly(striped, 'striped'),
useKeyOnly(structured, 'structured'),
useKeyOnly(unstackable, 'unstackable'),
useKeyOrValueAndKey(attached, 'attached'),
useKeyOrValueAndKey(basic, 'basic'),
useKeyOrValueAndKey(compact, 'compact'),
useKeyOrValueAndKey(padded, 'padded'),
useTextAlignProp(textAlign),
useVerticalAlignProp(verticalAlign),
useWidthProp(columns, 'column'),
'table',
className,
)
const rest = getUnhandledProps(Table, props)
const ElementType = getElementType(Table, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
const hasHeaderRows = headerRow || headerRows
const headerShorthandOptions = { defaultProps: { cellAs: 'th' } }
const headerElement = hasHeaderRows && (
<TableHeader>
{TableRow.create(headerRow, headerShorthandOptions)}
{_.map(headerRows, (data) => TableRow.create(data, headerShorthandOptions))}
</TableHeader>
)
return (
<ElementType {...rest} className={classes}>
{headerElement}
<TableBody>
{renderBodyRow &&
_.map(tableData, (data, index) => TableRow.create(renderBodyRow(data, index)))}
</TableBody>
{footerRow && <TableFooter>{TableRow.create(footerRow)}</TableFooter>}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61939 | Rail | test | function Rail(props) {
const {
attached,
children,
className,
close,
content,
dividing,
internal,
position,
size,
} = props
const classes = cx(
'ui',
position,
size,
useKeyOnly(attached, 'attached'),
useKeyOnly(dividing, 'dividing'),
useKeyOnly(internal, 'internal'),
useKeyOrValueAndKey(close, 'close'),
'rail',
className,
)
const rest = getUnhandledProps(Rail, props)
const ElementType = getElementType(Rail, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61940 | ButtonGroup | test | function ButtonGroup(props) {
const {
attached,
basic,
buttons,
children,
className,
color,
compact,
content,
floated,
fluid,
icon,
inverted,
labeled,
negative,
positive,
primary,
secondary,
size,
toggle,
vertical,
widths,
} = props
const classes = cx(
'ui',
color,
size,
useKeyOnly(basic, 'basic'),
useKeyOnly(compact, 'compact'),
useKeyOnly(fluid, 'fluid'),
useKeyOnly(icon, 'icon'),
useKeyOnly(inverted, 'inverted'),
useKeyOnly(labeled, 'labeled'),
useKeyOnly(negative, 'negative'),
useKeyOnly(positive, 'positive'),
useKeyOnly(primary, 'primary'),
useKeyOnly(secondary, 'secondary'),
useKeyOnly(toggle, 'toggle'),
useKeyOnly(vertical, 'vertical'),
useKeyOrValueAndKey(attached, 'attached'),
useValueAndKey(floated, 'floated'),
useWidthProp(widths),
'buttons',
className,
)
const rest = getUnhandledProps(ButtonGroup, props)
const ElementType = getElementType(ButtonGroup, props)
if (_.isNil(buttons)) {
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{_.map(buttons, button => Button.create(button))}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61941 | GridRow | test | function GridRow(props) {
const {
centered,
children,
className,
color,
columns,
divided,
only,
reversed,
stretched,
textAlign,
verticalAlign,
} = props
const classes = cx(
color,
useKeyOnly(centered, 'centered'),
useKeyOnly(divided, 'divided'),
useKeyOnly(stretched, 'stretched'),
useMultipleProp(only, 'only'),
useMultipleProp(reversed, 'reversed'),
useTextAlignProp(textAlign),
useVerticalAlignProp(verticalAlign),
useWidthProp(columns, 'column', true),
'row',
className,
)
const rest = getUnhandledProps(GridRow, props)
const ElementType = getElementType(GridRow, props)
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61942 | FormField | test | function FormField(props) {
const {
children,
className,
content,
control,
disabled,
error,
inline,
label,
required,
type,
width,
} = props
const classes = cx(
useKeyOnly(disabled, 'disabled'),
useKeyOnly(error, 'error'),
useKeyOnly(inline, 'inline'),
useKeyOnly(required, 'required'),
useWidthProp(width, 'wide'),
'field',
className,
)
const rest = getUnhandledProps(FormField, props)
const ElementType = getElementType(FormField, props)
// ----------------------------------------
// No Control
// ----------------------------------------
if (_.isNil(control)) {
if (_.isNil(label)) {
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{createHTMLLabel(label, { autoGenerateKey: false })}
</ElementType>
)
}
// ----------------------------------------
// Checkbox/Radio Control
// ----------------------------------------
const controlProps = { ...rest, content, children, disabled, required, type }
// wrap HTML checkboxes/radios in the label
if (control === 'input' && (type === 'checkbox' || type === 'radio')) {
return (
<ElementType className={classes}>
<label>
{createElement(control, controlProps)} {label}
</label>
</ElementType>
)
}
// pass label prop to controls that support it
if (control === Checkbox || control === Radio) {
return (
<ElementType className={classes}>
{createElement(control, { ...controlProps, label })}
</ElementType>
)
}
// ----------------------------------------
// Other Control
// ----------------------------------------
return (
<ElementType className={classes}>
{createHTMLLabel(label, {
defaultProps: { htmlFor: _.get(controlProps, 'id') },
autoGenerateKey: false,
})}
{createElement(control, controlProps)}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61943 | CardContent | test | function CardContent(props) {
const { children, className, content, description, extra, header, meta, textAlign } = props
const classes = cx(useKeyOnly(extra, 'extra'), useTextAlignProp(textAlign), 'content', className)
const rest = getUnhandledProps(CardContent, props)
const ElementType = getElementType(CardContent, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
if (!childrenUtils.isNil(content)) {
return (
<ElementType {...rest} className={classes}>
{content}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{createShorthand(CardHeader, val => ({ content: val }), header, { autoGenerateKey: false })}
{createShorthand(CardMeta, val => ({ content: val }), meta, { autoGenerateKey: false })}
{createShorthand(CardDescription, val => ({ content: val }), description, {
autoGenerateKey: false,
})}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61944 | Item | test | function Item(props) {
const { children, className, content, description, extra, header, image, meta } = props
const classes = cx('item', className)
const rest = getUnhandledProps(Item, props)
const ElementType = getElementType(Item, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{ItemImage.create(image, { autoGenerateKey: false })}
<ItemContent
content={content}
description={description}
extra={extra}
header={header}
meta={meta}
/>
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61945 | CommentAvatar | test | function CommentAvatar(props) {
const { className, src } = props
const classes = cx('avatar', className)
const rest = getUnhandledProps(CommentAvatar, props)
const [imageProps, rootProps] = partitionHTMLProps(rest, { htmlProps: htmlImageProps })
const ElementType = getElementType(CommentAvatar, props)
return (
<ElementType {...rootProps} className={classes}>
{createHTMLImage(src, { autoGenerateKey: false, defaultProps: imageProps })}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61946 | StatisticLabel | test | function StatisticLabel(props) {
const { children, className, content } = props
const classes = cx('label', className)
const rest = getUnhandledProps(StatisticLabel, props)
const ElementType = getElementType(StatisticLabel, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61947 | FeedMeta | test | function FeedMeta(props) {
const { children, className, content, like } = props
const classes = cx('meta', className)
const rest = getUnhandledProps(FeedMeta, props)
const ElementType = getElementType(FeedMeta, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{createShorthand(FeedLike, val => ({ content: val }), like, { autoGenerateKey: false })}
{content}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61948 | Container | test | function Container(props) {
const { children, className, content, fluid, text, textAlign } = props
const classes = cx(
'ui',
useKeyOnly(text, 'text'),
useKeyOnly(fluid, 'fluid'),
useTextAlignProp(textAlign),
'container',
className,
)
const rest = getUnhandledProps(Container, props)
const ElementType = getElementType(Container, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61949 | StepGroup | test | function StepGroup(props) {
const {
attached,
children,
className,
content,
fluid,
items,
ordered,
size,
stackable,
unstackable,
vertical,
widths,
} = props
const classes = cx(
'ui',
size,
useKeyOnly(fluid, 'fluid'),
useKeyOnly(ordered, 'ordered'),
useKeyOnly(unstackable, 'unstackable'),
useKeyOnly(vertical, 'vertical'),
useKeyOrValueAndKey(attached, 'attached'),
useValueAndKey(stackable, 'stackable'),
useWidthProp(widths),
'steps',
className,
)
const rest = getUnhandledProps(StepGroup, props)
const ElementType = getElementType(StepGroup, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
if (!childrenUtils.isNil(content)) {
return (
<ElementType {...rest} className={classes}>
{content}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{_.map(items, item => Step.create(item))}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61950 | Divider | test | function Divider(props) {
const {
children,
className,
clearing,
content,
fitted,
hidden,
horizontal,
inverted,
section,
vertical,
} = props
const classes = cx(
'ui',
useKeyOnly(clearing, 'clearing'),
useKeyOnly(fitted, 'fitted'),
useKeyOnly(hidden, 'hidden'),
useKeyOnly(horizontal, 'horizontal'),
useKeyOnly(inverted, 'inverted'),
useKeyOnly(section, 'section'),
useKeyOnly(vertical, 'vertical'),
'divider',
className,
)
const rest = getUnhandledProps(Divider, props)
const ElementType = getElementType(Divider, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61951 | Header | test | function Header(props) {
const {
attached,
block,
children,
className,
color,
content,
disabled,
dividing,
floated,
icon,
image,
inverted,
size,
sub,
subheader,
textAlign,
} = props
const classes = cx(
'ui',
color,
size,
useKeyOnly(block, 'block'),
useKeyOnly(disabled, 'disabled'),
useKeyOnly(dividing, 'dividing'),
useValueAndKey(floated, 'floated'),
useKeyOnly(icon === true, 'icon'),
useKeyOnly(image === true, 'image'),
useKeyOnly(inverted, 'inverted'),
useKeyOnly(sub, 'sub'),
useKeyOrValueAndKey(attached, 'attached'),
useTextAlignProp(textAlign),
'header',
className,
)
const rest = getUnhandledProps(Header, props)
const ElementType = getElementType(Header, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
const iconElement = Icon.create(icon, { autoGenerateKey: false })
const imageElement = Image.create(image, { autoGenerateKey: false })
const subheaderElement = HeaderSubheader.create(subheader, { autoGenerateKey: false })
if (iconElement || imageElement) {
return (
<ElementType {...rest} className={classes}>
{iconElement || imageElement}
{(content || subheaderElement) && (
<HeaderContent>
{content}
{subheaderElement}
</HeaderContent>
)}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{content}
{subheaderElement}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61952 | Grid | test | function Grid(props) {
const {
celled,
centered,
children,
className,
columns,
container,
divided,
doubling,
inverted,
padded,
relaxed,
reversed,
stackable,
stretched,
textAlign,
verticalAlign,
} = props
const classes = cx(
'ui',
useKeyOnly(centered, 'centered'),
useKeyOnly(container, 'container'),
useKeyOnly(doubling, 'doubling'),
useKeyOnly(inverted, 'inverted'),
useKeyOnly(stackable, 'stackable'),
useKeyOnly(stretched, 'stretched'),
useKeyOrValueAndKey(celled, 'celled'),
useKeyOrValueAndKey(divided, 'divided'),
useKeyOrValueAndKey(padded, 'padded'),
useKeyOrValueAndKey(relaxed, 'relaxed'),
useMultipleProp(reversed, 'reversed'),
useTextAlignProp(textAlign),
useVerticalAlignProp(verticalAlign),
useWidthProp(columns, 'column', true),
'grid',
className,
)
const rest = getUnhandledProps(Grid, props)
const ElementType = getElementType(Grid, props)
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61953 | Breadcrumb | test | function Breadcrumb(props) {
const { children, className, divider, icon, sections, size } = props
const classes = cx('ui', size, 'breadcrumb', className)
const rest = getUnhandledProps(Breadcrumb, props)
const ElementType = getElementType(Breadcrumb, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
const childElements = []
_.each(sections, (section, index) => {
// section
const breadcrumbElement = BreadcrumbSection.create(section)
childElements.push(breadcrumbElement)
// divider
if (index !== sections.length - 1) {
const key = `${breadcrumbElement.key}_divider` || JSON.stringify(section)
childElements.push(BreadcrumbDivider.create({ content: divider, icon, key }))
}
})
return (
<ElementType {...rest} className={classes}>
{childElements}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61954 | CardDescription | test | function CardDescription(props) {
const { children, className, content, textAlign } = props
const classes = cx(useTextAlignProp(textAlign), 'description', className)
const rest = getUnhandledProps(CardDescription, props)
const ElementType = getElementType(CardDescription, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61955 | ItemGroup | test | function ItemGroup(props) {
const { children, className, content, divided, items, link, relaxed, unstackable } = props
const classes = cx(
'ui',
useKeyOnly(divided, 'divided'),
useKeyOnly(link, 'link'),
useKeyOnly(unstackable, 'unstackable'),
useKeyOrValueAndKey(relaxed, 'relaxed'),
'items',
className,
)
const rest = getUnhandledProps(ItemGroup, props)
const ElementType = getElementType(ItemGroup, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
if (!childrenUtils.isNil(content)) {
return (
<ElementType {...rest} className={classes}>
{content}
</ElementType>
)
}
const itemsJSX = _.map(items, (item) => {
const { childKey, ...itemProps } = item
const finalKey =
childKey ||
[itemProps.content, itemProps.description, itemProps.header, itemProps.meta].join('-')
return <Item {...itemProps} key={finalKey} />
})
return (
<ElementType {...rest} className={classes}>
{itemsJSX}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61956 | GridColumn | test | function GridColumn(props) {
const {
children,
className,
computer,
color,
floated,
largeScreen,
mobile,
only,
stretched,
tablet,
textAlign,
verticalAlign,
widescreen,
width,
} = props
const classes = cx(
color,
useKeyOnly(stretched, 'stretched'),
useMultipleProp(only, 'only'),
useTextAlignProp(textAlign),
useValueAndKey(floated, 'floated'),
useVerticalAlignProp(verticalAlign),
useWidthProp(computer, 'wide computer'),
useWidthProp(largeScreen, 'wide large screen'),
useWidthProp(mobile, 'wide mobile'),
useWidthProp(tablet, 'wide tablet'),
useWidthProp(widescreen, 'wide widescreen'),
useWidthProp(width, 'wide'),
'column',
className,
)
const rest = getUnhandledProps(GridColumn, props)
const ElementType = getElementType(GridColumn, props)
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61957 | ItemImage | test | function ItemImage(props) {
const { size } = props
const rest = getUnhandledProps(ItemImage, props)
return <Image {...rest} size={size} ui={!!size} wrapped />
} | javascript | {
"resource": ""
} |
q61958 | CardGroup | test | function CardGroup(props) {
const {
centered,
children,
className,
content,
doubling,
items,
itemsPerRow,
stackable,
textAlign,
} = props
const classes = cx(
'ui',
useKeyOnly(centered, 'centered'),
useKeyOnly(doubling, 'doubling'),
useKeyOnly(stackable, 'stackable'),
useTextAlignProp(textAlign),
useWidthProp(itemsPerRow),
'cards',
className,
)
const rest = getUnhandledProps(CardGroup, props)
const ElementType = getElementType(CardGroup, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
if (!childrenUtils.isNil(content)) {
return (
<ElementType {...rest} className={classes}>
{content}
</ElementType>
)
}
const itemsJSX = _.map(items, (item) => {
const key = item.key || [item.header, item.description].join('-')
return <Card key={key} {...item} />
})
return (
<ElementType {...rest} className={classes}>
{itemsJSX}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61959 | TableRow | test | function TableRow(props) {
const {
active,
cellAs,
cells,
children,
className,
disabled,
error,
negative,
positive,
textAlign,
verticalAlign,
warning,
} = props
const classes = cx(
useKeyOnly(active, 'active'),
useKeyOnly(disabled, 'disabled'),
useKeyOnly(error, 'error'),
useKeyOnly(negative, 'negative'),
useKeyOnly(positive, 'positive'),
useKeyOnly(warning, 'warning'),
useTextAlignProp(textAlign),
useVerticalAlignProp(verticalAlign),
className,
)
const rest = getUnhandledProps(TableRow, props)
const ElementType = getElementType(TableRow, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{_.map(cells, cell => TableCell.create(cell, { defaultProps: { as: cellAs } }))}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61960 | FeedEvent | test | function FeedEvent(props) {
const {
content,
children,
className,
date,
extraImages,
extraText,
image,
icon,
meta,
summary,
} = props
const classes = cx('event', className)
const rest = getUnhandledProps(FeedEvent, props)
const ElementType = getElementType(FeedEvent, props)
const hasContentProp = content || date || extraImages || extraText || meta || summary
const contentProps = { content, date, extraImages, extraText, meta, summary }
return (
<ElementType {...rest} className={classes}>
{createShorthand(FeedLabel, val => ({ icon: val }), icon, { autoGenerateKey: false })}
{createShorthand(FeedLabel, val => ({ image: val }), image, { autoGenerateKey: false })}
{hasContentProp && <FeedContent {...contentProps} />}
{children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61961 | TabPane | test | function TabPane(props) {
const { active, children, className, content, loading } = props
const classes = cx(useKeyOnly(active, 'active'), useKeyOnly(loading, 'loading'), 'tab', className)
const rest = getUnhandledProps(TabPane, props)
const ElementType = getElementType(TabPane, props)
const calculatedDefaultProps = {}
if (ElementType === Segment) {
calculatedDefaultProps.attached = 'bottom'
}
return (
<ElementType {...calculatedDefaultProps} {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61962 | ListContent | test | function ListContent(props) {
const { children, className, content, description, floated, header, verticalAlign } = props
const classes = cx(
useValueAndKey(floated, 'floated'),
useVerticalAlignProp(verticalAlign),
'content',
className,
)
const rest = getUnhandledProps(ListContent, props)
const ElementType = getElementType(ListContent, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{ListHeader.create(header)}
{ListDescription.create(description)}
{content}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61963 | ButtonOr | test | function ButtonOr(props) {
const { className, text } = props
const classes = cx('or', className)
const rest = getUnhandledProps(ButtonOr, props)
const ElementType = getElementType(ButtonOr, props)
return <ElementType {...rest} className={classes} data-text={text} />
} | javascript | {
"resource": ""
} |
q61964 | TableCell | test | function TableCell(props) {
const {
active,
children,
className,
collapsing,
content,
disabled,
error,
icon,
negative,
positive,
selectable,
singleLine,
textAlign,
verticalAlign,
warning,
width,
} = props
const classes = cx(
useKeyOnly(active, 'active'),
useKeyOnly(collapsing, 'collapsing'),
useKeyOnly(disabled, 'disabled'),
useKeyOnly(error, 'error'),
useKeyOnly(negative, 'negative'),
useKeyOnly(positive, 'positive'),
useKeyOnly(selectable, 'selectable'),
useKeyOnly(singleLine, 'single line'),
useKeyOnly(warning, 'warning'),
useTextAlignProp(textAlign),
useVerticalAlignProp(verticalAlign),
useWidthProp(width, 'wide'),
className,
)
const rest = getUnhandledProps(TableCell, props)
const ElementType = getElementType(TableCell, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{Icon.create(icon)}
{content}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61965 | BreadcrumbDivider | test | function BreadcrumbDivider(props) {
const { children, className, content, icon } = props
const classes = cx('divider', className)
const rest = getUnhandledProps(BreadcrumbDivider, props)
const ElementType = getElementType(BreadcrumbDivider, props)
if (!_.isNil(icon)) {
return Icon.create(icon, {
defaultProps: { ...rest, className: classes },
autoGenerateKey: false,
})
}
if (!_.isNil(content)) {
return (
<ElementType {...rest} className={classes}>
{content}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? '/' : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61966 | MessageList | test | function MessageList(props) {
const { children, className, items } = props
const classes = cx('list', className)
const rest = getUnhandledProps(MessageList, props)
const ElementType = getElementType(MessageList, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? _.map(items, MessageItem.create) : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61967 | TableFooter | test | function TableFooter(props) {
const { as } = props
const rest = getUnhandledProps(TableFooter, props)
return <TableHeader {...rest} as={as} />
} | javascript | {
"resource": ""
} |
q61968 | CommentGroup | test | function CommentGroup(props) {
const { className, children, collapsed, content, minimal, size, threaded } = props
const classes = cx(
'ui',
size,
useKeyOnly(collapsed, 'collapsed'),
useKeyOnly(minimal, 'minimal'),
useKeyOnly(threaded, 'threaded'),
'comments',
className,
)
const rest = getUnhandledProps(CommentGroup, props)
const ElementType = getElementType(CommentGroup, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61969 | Reveal | test | function Reveal(props) {
const { active, animated, children, className, content, disabled, instant } = props
const classes = cx(
'ui',
animated,
useKeyOnly(active, 'active'),
useKeyOnly(disabled, 'disabled'),
useKeyOnly(instant, 'instant'),
'reveal',
className,
)
const rest = getUnhandledProps(Reveal, props)
const ElementType = getElementType(Reveal, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61970 | Segment | test | function Segment(props) {
const {
attached,
basic,
children,
circular,
className,
clearing,
color,
compact,
content,
disabled,
floated,
inverted,
loading,
placeholder,
padded,
piled,
raised,
secondary,
size,
stacked,
tertiary,
textAlign,
vertical,
} = props
const classes = cx(
'ui',
color,
size,
useKeyOnly(basic, 'basic'),
useKeyOnly(circular, 'circular'),
useKeyOnly(clearing, 'clearing'),
useKeyOnly(compact, 'compact'),
useKeyOnly(disabled, 'disabled'),
useKeyOnly(inverted, 'inverted'),
useKeyOnly(loading, 'loading'),
useKeyOnly(placeholder, 'placeholder'),
useKeyOnly(piled, 'piled'),
useKeyOnly(raised, 'raised'),
useKeyOnly(secondary, 'secondary'),
useKeyOnly(stacked, 'stacked'),
useKeyOnly(tertiary, 'tertiary'),
useKeyOnly(vertical, 'vertical'),
useKeyOrValueAndKey(attached, 'attached'),
useKeyOrValueAndKey(padded, 'padded'),
useTextAlignProp(textAlign),
useValueAndKey(floated, 'floated'),
'segment',
className,
)
const rest = getUnhandledProps(Segment, props)
const ElementType = getElementType(Segment, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61971 | PlaceholderLine | test | function PlaceholderLine(props) {
const { className, length } = props
const classes = cx('line', length, className)
const rest = getUnhandledProps(PlaceholderLine, props)
const ElementType = getElementType(PlaceholderLine, props)
return <ElementType {...rest} className={classes} />
} | javascript | {
"resource": ""
} |
q61972 | RevealContent | test | function RevealContent(props) {
const { children, className, content, hidden, visible } = props
const classes = cx(
'ui',
useKeyOnly(hidden, 'hidden'),
useKeyOnly(visible, 'visible'),
'content',
className,
)
const rest = getUnhandledProps(RevealContent, props)
const ElementType = getElementType(RevealContent, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61973 | FeedLike | test | function FeedLike(props) {
const { children, className, content, icon } = props
const classes = cx('like', className)
const rest = getUnhandledProps(FeedLike, props)
const ElementType = getElementType(FeedLike, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{Icon.create(icon, { autoGenerateKey: false })}
{content}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61974 | Placeholder | test | function Placeholder(props) {
const { children, className, content, fluid, inverted } = props
const classes = cx(
'ui',
useKeyOnly(fluid, 'fluid'),
useKeyOnly(inverted, 'inverted'),
'placeholder',
className,
)
const rest = getUnhandledProps(Placeholder, props)
const ElementType = getElementType(Placeholder, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61975 | Accordion | test | function Accordion(props) {
const { className, fluid, inverted, styled } = props
const classes = cx(
'ui',
useKeyOnly(fluid, 'fluid'),
useKeyOnly(inverted, 'inverted'),
useKeyOnly(styled, 'styled'),
className,
)
const rest = getUnhandledProps(Accordion, props)
return <AccordionAccordion {...rest} className={classes} />
} | javascript | {
"resource": ""
} |
q61976 | PlaceholderImage | test | function PlaceholderImage(props) {
const { className, square, rectangular } = props
const classes = cx(
useKeyOnly(square, 'square'),
useKeyOnly(rectangular, 'rectangular'),
'image',
className,
)
const rest = getUnhandledProps(PlaceholderImage, props)
const ElementType = getElementType(PlaceholderImage, props)
return <ElementType {...rest} className={classes} />
} | javascript | {
"resource": ""
} |
q61977 | DropdownMenu | test | function DropdownMenu(props) {
const { children, className, content, direction, open, scrolling } = props
const classes = cx(
direction,
useKeyOnly(open, 'visible'),
useKeyOnly(scrolling, 'scrolling'),
'menu transition',
className,
)
const rest = getUnhandledProps(DropdownMenu, props)
const ElementType = getElementType(DropdownMenu, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61978 | ListIcon | test | function ListIcon(props) {
const { className, verticalAlign } = props
const classes = cx(useVerticalAlignProp(verticalAlign), className)
const rest = getUnhandledProps(ListIcon, props)
return <Icon {...rest} className={classes} />
} | javascript | {
"resource": ""
} |
q61979 | Advertisement | test | function Advertisement(props) {
const { centered, children, className, content, test, unit } = props
const classes = cx(
'ui',
unit,
useKeyOnly(centered, 'centered'),
useKeyOnly(test, 'test'),
'ad',
className,
)
const rest = getUnhandledProps(Advertisement, props)
const ElementType = getElementType(Advertisement, props)
return (
<ElementType {...rest} className={classes} data-text={test}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61980 | StatisticGroup | test | function StatisticGroup(props) {
const { children, className, color, content, horizontal, inverted, items, size, widths } = props
const classes = cx(
'ui',
color,
size,
useKeyOnly(horizontal, 'horizontal'),
useKeyOnly(inverted, 'inverted'),
useWidthProp(widths),
'statistics',
className,
)
const rest = getUnhandledProps(StatisticGroup, props)
const ElementType = getElementType(StatisticGroup, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
if (!childrenUtils.isNil(content)) {
return (
<ElementType {...rest} className={classes}>
{content}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{_.map(items, item => Statistic.create(item))}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61981 | Statistic | test | function Statistic(props) {
const {
children,
className,
color,
content,
floated,
horizontal,
inverted,
label,
size,
text,
value,
} = props
const classes = cx(
'ui',
color,
size,
useValueAndKey(floated, 'floated'),
useKeyOnly(horizontal, 'horizontal'),
useKeyOnly(inverted, 'inverted'),
'statistic',
className,
)
const rest = getUnhandledProps(Statistic, props)
const ElementType = getElementType(Statistic, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
if (!childrenUtils.isNil(content)) {
return (
<ElementType {...rest} className={classes}>
{content}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{StatisticValue.create(value, {
defaultProps: { text },
autoGenerateKey: false,
})}
{StatisticLabel.create(label, { autoGenerateKey: false })}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61982 | SegmentGroup | test | function SegmentGroup(props) {
const { children, className, compact, content, horizontal, piled, raised, size, stacked } = props
const classes = cx(
'ui',
size,
useKeyOnly(compact, 'compact'),
useKeyOnly(horizontal, 'horizontal'),
useKeyOnly(piled, 'piled'),
useKeyOnly(raised, 'raised'),
useKeyOnly(stacked, 'stacked'),
'segments',
className,
)
const rest = getUnhandledProps(SegmentGroup, props)
const ElementType = getElementType(SegmentGroup, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61983 | TableHeaderCell | test | function TableHeaderCell(props) {
const { as, className, sorted } = props
const classes = cx(useValueAndKey(sorted, 'sorted'), className)
const rest = getUnhandledProps(TableHeaderCell, props)
return <TableCell {...rest} as={as} className={classes} />
} | javascript | {
"resource": ""
} |
q61984 | Feed | test | function Feed(props) {
const { children, className, events, size } = props
const classes = cx('ui', size, 'feed', className)
const rest = getUnhandledProps(Feed, props)
const ElementType = getElementType(Feed, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
const eventElements = _.map(events, (eventProps) => {
const { childKey, date, meta, summary, ...eventData } = eventProps
const finalKey = childKey || [date, meta, summary].join('-')
return <FeedEvent date={date} key={finalKey} meta={meta} summary={summary} {...eventData} />
})
return (
<ElementType {...rest} className={classes}>
{eventElements}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61985 | LabelGroup | test | function LabelGroup(props) {
const { children, circular, className, color, content, size, tag } = props
const classes = cx(
'ui',
color,
size,
useKeyOnly(circular, 'circular'),
useKeyOnly(tag, 'tag'),
'labels',
className,
)
const rest = getUnhandledProps(LabelGroup, props)
const ElementType = getElementType(LabelGroup, props)
return (
<ElementType {...rest} className={classes}>
{childrenUtils.isNil(children) ? content : children}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61986 | FeedExtra | test | function FeedExtra(props) {
const { children, className, content, images, text } = props
const classes = cx(
useKeyOnly(images, 'images'),
useKeyOnly(content || text, 'text'),
'extra',
className,
)
const rest = getUnhandledProps(FeedExtra, props)
const ElementType = getElementType(FeedExtra, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
// TODO need a "collection factory" to handle creating multiple image elements and their keys
const imageElements = _.map(images, (image, index) => {
const key = [index, image].join('-')
return createHTMLImage(image, { key })
})
return (
<ElementType {...rest} className={classes}>
{content}
{imageElements}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61987 | DropdownDivider | test | function DropdownDivider(props) {
const { className } = props
const classes = cx('divider', className)
const rest = getUnhandledProps(DropdownDivider, props)
const ElementType = getElementType(DropdownDivider, props)
return <ElementType {...rest} className={classes} />
} | javascript | {
"resource": ""
} |
q61988 | FeedSummary | test | function FeedSummary(props) {
const { children, className, content, date, user } = props
const classes = cx('summary', className)
const rest = getUnhandledProps(FeedSummary, props)
const ElementType = getElementType(FeedSummary, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{createShorthand(FeedUser, val => ({ content: val }), user, { autoGenerateKey: false })}
{content}
{createShorthand(FeedDate, val => ({ content: val }), date, { autoGenerateKey: false })}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61989 | StepContent | test | function StepContent(props) {
const { children, className, content, description, title } = props
const classes = cx('content', className)
const rest = getUnhandledProps(StepContent, props)
const ElementType = getElementType(StepContent, props)
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
if (!childrenUtils.isNil(content)) {
return (
<ElementType {...rest} className={classes}>
{content}
</ElementType>
)
}
return (
<ElementType {...rest} className={classes}>
{StepTitle.create(title, { autoGenerateKey: false })}
{StepDescription.create(description, { autoGenerateKey: false })}
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61990 | Image | test | function Image(props) {
const {
avatar,
bordered,
centered,
children,
circular,
className,
content,
dimmer,
disabled,
floated,
fluid,
hidden,
href,
inline,
label,
rounded,
size,
spaced,
verticalAlign,
wrapped,
ui,
} = props
const classes = cx(
useKeyOnly(ui, 'ui'),
size,
useKeyOnly(avatar, 'avatar'),
useKeyOnly(bordered, 'bordered'),
useKeyOnly(circular, 'circular'),
useKeyOnly(centered, 'centered'),
useKeyOnly(disabled, 'disabled'),
useKeyOnly(fluid, 'fluid'),
useKeyOnly(hidden, 'hidden'),
useKeyOnly(inline, 'inline'),
useKeyOnly(rounded, 'rounded'),
useKeyOrValueAndKey(spaced, 'spaced'),
useValueAndKey(floated, 'floated'),
useVerticalAlignProp(verticalAlign, 'aligned'),
'image',
className,
)
const rest = getUnhandledProps(Image, props)
const [imgTagProps, rootProps] = partitionHTMLProps(rest, { htmlProps: htmlImageProps })
const ElementType = getElementType(Image, props, () => {
if (
!_.isNil(dimmer) ||
!_.isNil(label) ||
!_.isNil(wrapped) ||
!childrenUtils.isNil(children)
) {
return 'div'
}
})
if (!childrenUtils.isNil(children)) {
return (
<ElementType {...rest} className={classes}>
{children}
</ElementType>
)
}
if (!childrenUtils.isNil(content)) {
return (
<ElementType {...rest} className={classes}>
{content}
</ElementType>
)
}
if (ElementType === 'img') {
return <ElementType {...rootProps} {...imgTagProps} className={classes} />
}
return (
<ElementType {...rootProps} className={classes} href={href}>
{Dimmer.create(dimmer, { autoGenerateKey: false })}
{Label.create(label, { autoGenerateKey: false })}
<img {...imgTagProps} />
</ElementType>
)
} | javascript | {
"resource": ""
} |
q61991 | test | function(canvas) {
var context = canvas.getContext('2d'),
devicePixelRatio = window.devicePixelRatio || 1,
backingStorePixelRatio = context.webkitBackingStorePixelRatio || context.mozBackingStorePixelRatio
|| context.msBackingStorePixelRatio || context.oBackingStorePixelRatio
|| context.backingStorePixelRatio || 1;
return devicePixelRatio / backingStorePixelRatio;
} | javascript | {
"resource": ""
} | |
q61992 | test | function(render, background) {
var cssBackground = background;
if (/(jpg|gif|png)$/.test(background))
cssBackground = 'url(' + background + ')';
render.canvas.style.background = cssBackground;
render.canvas.style.backgroundSize = "contain";
render.currentBackground = background;
} | javascript | {
"resource": ""
} | |
q61993 | test | function(render, body) {
var bodyRender = body.render,
texturePath = bodyRender.sprite.texture,
texture = _getTexture(render, texturePath),
sprite = new PIXI.Sprite(texture);
sprite.anchor.x = body.render.sprite.xOffset;
sprite.anchor.y = body.render.sprite.yOffset;
return sprite;
} | javascript | {
"resource": ""
} | |
q61994 | test | function(render, body) {
var bodyRender = body.render,
options = render.options,
primitive = new PIXI.Graphics(),
fillStyle = Common.colorToNumber(bodyRender.fillStyle),
strokeStyle = Common.colorToNumber(bodyRender.strokeStyle),
strokeStyleIndicator = Common.colorToNumber(bodyRender.strokeStyle),
strokeStyleWireframe = Common.colorToNumber('#bbb'),
strokeStyleWireframeIndicator = Common.colorToNumber('#CD5C5C'),
part;
primitive.clear();
// handle compound parts
for (var k = body.parts.length > 1 ? 1 : 0; k < body.parts.length; k++) {
part = body.parts[k];
if (!options.wireframes) {
primitive.beginFill(fillStyle, 1);
primitive.lineStyle(bodyRender.lineWidth, strokeStyle, 1);
} else {
primitive.beginFill(0, 0);
primitive.lineStyle(1, strokeStyleWireframe, 1);
}
primitive.moveTo(part.vertices[0].x - body.position.x, part.vertices[0].y - body.position.y);
for (var j = 1; j < part.vertices.length; j++) {
primitive.lineTo(part.vertices[j].x - body.position.x, part.vertices[j].y - body.position.y);
}
primitive.lineTo(part.vertices[0].x - body.position.x, part.vertices[0].y - body.position.y);
primitive.endFill();
// angle indicator
if (options.showAngleIndicator || options.showAxes) {
primitive.beginFill(0, 0);
if (options.wireframes) {
primitive.lineStyle(1, strokeStyleWireframeIndicator, 1);
} else {
primitive.lineStyle(1, strokeStyleIndicator);
}
primitive.moveTo(part.position.x - body.position.x, part.position.y - body.position.y);
primitive.lineTo(((part.vertices[0].x + part.vertices[part.vertices.length-1].x) / 2 - body.position.x),
((part.vertices[0].y + part.vertices[part.vertices.length-1].y) / 2 - body.position.y));
primitive.endFill();
}
}
return primitive;
} | javascript | {
"resource": ""
} | |
q61995 | test | function(body, options) {
options = options || {};
// init required properties (order is important)
Body.set(body, {
bounds: body.bounds || Bounds.create(body.vertices),
positionPrev: body.positionPrev || Vector.clone(body.position),
anglePrev: body.anglePrev || body.angle,
vertices: body.vertices,
parts: body.parts || [body],
isStatic: body.isStatic,
isSleeping: body.isSleeping,
parent: body.parent || body
});
Vertices.rotate(body.vertices, body.angle, body.position);
Axes.rotate(body.axes, body.angle);
Bounds.update(body.bounds, body.vertices, body.velocity);
// allow options to override the automatically calculated properties
Body.set(body, {
axes: options.axes || body.axes,
area: options.area || body.area,
mass: options.mass || body.mass,
inertia: options.inertia || body.inertia
});
// render properties
var defaultFillStyle = (body.isStatic ? '#2e2b44' : Common.choose(['#006BA6', '#0496FF', '#FFBC42', '#D81159', '#8F2D56'])),
defaultStrokeStyle = '#000';
body.render.fillStyle = body.render.fillStyle || defaultFillStyle;
body.render.strokeStyle = body.render.strokeStyle || defaultStrokeStyle;
body.render.sprite.xOffset += -(body.bounds.min.x - body.position.x) / (body.bounds.max.x - body.bounds.min.x);
body.render.sprite.yOffset += -(body.bounds.min.y - body.position.y) / (body.bounds.max.y - body.bounds.min.y);
} | javascript | {
"resource": ""
} | |
q61996 | createPages | test | async function createPages({ actions, graphql }) {
const retrieveMarkdownPages = () =>
graphql(`
{
allMarkdownRemark(limit: 1000) {
edges {
node {
frontmatter {
path
}
}
}
}
}
`)
const exampleTemplate = path.resolve(`src/templates/exampleTemplate.tsx`)
const docTemplate = path.resolve(`src/templates/docTemplate.tsx`)
const result = await retrieveMarkdownPages()
if (result.errors) {
console.error('graphql error', result.errors)
throw new Error('Error invoking graphql for pages')
}
result.data.allMarkdownRemark.edges.forEach(({ node }) => {
const {
frontmatter: { path: pagePath },
} = node
const category = (pagePath || '/').split('/').filter(t => !!t)[0]
const isExample = category === 'examples'
console.log(`create page for ${pagePath} - type is ${category}`)
actions.createPage({
path: pagePath,
component: isExample ? exampleTemplate : docTemplate,
context: {}, // additional data can be passed via context
})
})
} | javascript | {
"resource": ""
} |
q61997 | isWindow | test | function isWindow(val) {
if (typeof val !== "object") {
return false;
}
const wrapper = idlUtils.wrapperForImpl(val);
if (typeof wrapper === "object") {
return wrapper === wrapper._globalProxy;
}
// `val` may be either impl or wrapper currently, because webidl2js currently unwraps Window objects (and their global
// proxies) to their underlying EventTargetImpl during conversion, which is not what we want. But at the same time,
// some internal usage call this constructor with the actual global proxy.
return isWindow(idlUtils.implForWrapper(val));
} | javascript | {
"resource": ""
} |
q61998 | normalizeEventHandlerOptions | test | function normalizeEventHandlerOptions(options, defaultBoolKeys) {
const returnValue = {};
// no need to go further here
if (typeof options === "boolean" || options === null || typeof options === "undefined") {
returnValue.capture = Boolean(options);
return returnValue;
}
// non objects options so we typecast its value as "capture" value
if (typeof options !== "object") {
returnValue.capture = Boolean(options);
// at this point we don't need to loop the "capture" key anymore
defaultBoolKeys = defaultBoolKeys.filter(k => k !== "capture");
}
for (const key of defaultBoolKeys) {
returnValue[key] = Boolean(options[key]);
}
return returnValue;
} | javascript | {
"resource": ""
} |
q61999 | sammary | test | function sammary() {
const nodeFn = function ({ parentPaths, lang, item, isDir, result }) {
const navTitle = generateNavTitle({ parentPaths, item, sign: isDir ? '-' : '*', lang });
result.push(navTitle);
};
langs.forEach(dir => {
const SUMMARY = 'SUMMARY.md';
const targetFile = path.join(docsDir, `${dir}/${SUMMARY}`);
const result = walk({
catalog: docConfig.catalog,
lang: dir,
result: [],
parentPaths: [],
fn: nodeFn
});
if (result && result.length) {
result.unshift('# whistle\n');
fs.writeFileSync(targetFile, result.join('\n'));
}
});
} | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.