text stringlengths 9 39.2M | dir stringlengths 26 295 | lang stringclasses 185
values | created_date timestamp[us] | updated_date timestamp[us] | repo_name stringlengths 1 97 | repo_full_name stringlengths 7 106 | star int64 1k 183k | len_tokens int64 1 13.8M |
|---|---|---|---|---|---|---|---|---|
```xml
import {
ref,
Ref,
unref,
computed,
watch,
onServerPrefetch,
getCurrentScope,
onScopeDispose,
nextTick,
shallowRef,
} from 'vue-demi'
import { DocumentNode } from 'graphql'
import type {
OperationVariables,
WatchQueryOptions,
ObservableQuery,
ApolloQueryResult,
SubscribeToMoreOptions,
FetchMoreQueryOptions,
FetchMoreOptions,
ObservableSubscription,
TypedDocumentNode,
ApolloError,
ApolloClient,
} from '@apollo/client/core/index.js'
import { throttle, debounce } from 'throttle-debounce'
import { useApolloClient } from './useApolloClient'
import { ReactiveFunction } from './util/ReactiveFunction'
import { paramToRef } from './util/paramToRef'
import { paramToReactive } from './util/paramToReactive'
import { useEventHook } from './util/useEventHook'
import { trackQuery } from './util/loadingTracking'
import { resultErrorsToApolloError, toApolloError } from './util/toApolloError'
import { isServer } from './util/env'
export interface UseQueryOptions<
// eslint-disable-next-line @typescript-eslint/no-unused-vars
TResult = any,
TVariables extends OperationVariables = OperationVariables
> extends Omit<WatchQueryOptions<TVariables>, 'query' | 'variables'> {
clientId?: string
enabled?: boolean | Ref<boolean>
throttle?: number
debounce?: number
prefetch?: boolean
keepPreviousResult?: boolean
}
interface SubscribeToMoreItem {
options: any
unsubscribeFns: (() => void)[]
}
// Parameters
export type DocumentParameter<TResult, TVariables> = DocumentNode | Ref<DocumentNode | null | undefined> | ReactiveFunction<DocumentNode | null | undefined> | TypedDocumentNode<TResult, TVariables> | Ref<TypedDocumentNode<TResult, TVariables> | null | undefined> | ReactiveFunction<TypedDocumentNode<TResult, TVariables> | null | undefined>
export type VariablesParameter<TVariables> = TVariables | Ref<TVariables> | ReactiveFunction<TVariables>
export type OptionsParameter<TResult, TVariables extends OperationVariables> = UseQueryOptions<TResult, TVariables> | Ref<UseQueryOptions<TResult, TVariables>> | ReactiveFunction<UseQueryOptions<TResult, TVariables>>
export interface OnResultContext {
client: ApolloClient<any>
}
export interface OnErrorContext {
client: ApolloClient<any>
}
// Return
export interface UseQueryReturn<TResult, TVariables extends OperationVariables> {
result: Ref<TResult | undefined>
loading: Ref<boolean>
networkStatus: Ref<number | undefined>
error: Ref<ApolloError | null>
start: () => void
stop: () => void
restart: () => void
forceDisabled: Ref<boolean>
document: Ref<DocumentNode | null | undefined>
variables: Ref<TVariables | undefined>
options: UseQueryOptions<TResult, TVariables> | Ref<UseQueryOptions<TResult, TVariables>>
query: Ref<ObservableQuery<TResult, TVariables> | null | undefined>
refetch: (variables?: TVariables) => Promise<ApolloQueryResult<TResult>> | undefined
fetchMore: (options: FetchMoreQueryOptions<TVariables, TResult> & FetchMoreOptions<TResult, TVariables>) => Promise<ApolloQueryResult<TResult>> | undefined
updateQuery: (mapFn: (previousQueryResult: TResult, options: Pick<WatchQueryOptions<TVariables, TResult>, 'variables'>) => TResult) => void
subscribeToMore: <TSubscriptionVariables = OperationVariables, TSubscriptionData = TResult>(options: SubscribeToMoreOptions<TResult, TSubscriptionVariables, TSubscriptionData> | Ref<SubscribeToMoreOptions<TResult, TSubscriptionVariables, TSubscriptionData>> | ReactiveFunction<SubscribeToMoreOptions<TResult, TSubscriptionVariables, TSubscriptionData>>) => void
onResult: (fn: (param: ApolloQueryResult<TResult>, context: OnResultContext) => void) => {
off: () => void
}
onError: (fn: (param: ApolloError, context: OnErrorContext) => void) => {
off: () => void
}
}
/**
* Use a query that does not require variables or options.
* */
export function useQuery<TResult = any> (
document: DocumentParameter<TResult, undefined>
): UseQueryReturn<TResult, Record<string, never>>
/**
* Use a query that has optional variables but not options
*/
export function useQuery<TResult = any, TVariables extends OperationVariables = OperationVariables> (
document: DocumentParameter<TResult, TVariables>
): UseQueryReturn<TResult, TVariables>
/**
* Use a query that has required variables but not options
*/
export function useQuery<TResult = any, TVariables extends OperationVariables = OperationVariables> (
document: DocumentParameter<TResult, TVariables>,
variables: VariablesParameter<TVariables>
): UseQueryReturn<TResult, TVariables>
/**
* Use a query that requires options but not variables.
*/
export function useQuery<TResult = any> (
document: DocumentParameter<TResult, undefined>,
variables: undefined | null,
options: OptionsParameter<TResult, Record<string, never>>,
): UseQueryReturn<TResult, Record<string, never>>
/**
* Use a query that requires variables and options.
*/
export function useQuery<TResult = any, TVariables extends OperationVariables = OperationVariables> (
document: DocumentParameter<TResult, TVariables>,
variables: VariablesParameter<TVariables>,
options: OptionsParameter<TResult, TVariables>,
): UseQueryReturn<TResult, TVariables>
export function useQuery<
TResult,
TVariables extends OperationVariables
> (
document: DocumentParameter<TResult, TVariables>,
variables?: VariablesParameter<TVariables>,
options?: OptionsParameter<TResult, TVariables>,
): UseQueryReturn<TResult, TVariables> {
return useQueryImpl<TResult, TVariables>(document, variables, options)
}
export function useQueryImpl<
TResult,
TVariables extends OperationVariables
> (
document: DocumentParameter<TResult, TVariables>,
variables?: VariablesParameter<TVariables>,
options: OptionsParameter<TResult, TVariables> = {},
lazy = false,
): UseQueryReturn<TResult, TVariables> {
const currentScope = getCurrentScope()
const currentOptions = ref<UseQueryOptions<TResult, TVariables>>()
const documentRef = paramToRef(document)
const variablesRef = paramToRef(variables)
const optionsRef = paramToReactive(options)
// Result
/**
* Result from the query
*/
const result = shallowRef<TResult | undefined>()
const resultEvent = useEventHook<[ApolloQueryResult<TResult>, OnResultContext]>()
const error = shallowRef<ApolloError | null>(null)
const errorEvent = useEventHook<[ApolloError, OnErrorContext]>()
// Loading
/**
* Indicates if a network request is pending
*/
const loading = ref(false)
currentScope && trackQuery(loading)
const networkStatus = ref<number>()
// SSR
let firstResolve: (() => void) | undefined
let firstResolveTriggered = false
let firstReject: ((apolloError: ApolloError) => void) | undefined
let firstRejectError: undefined | ApolloError
const tryFirstResolve = () => {
firstResolveTriggered = true
if (firstResolve) firstResolve()
}
const tryFirstReject = (apolloError: ApolloError) => {
firstRejectError = apolloError
if (firstReject) firstReject(apolloError)
}
const resetFirstResolveReject = () => {
firstResolve = undefined
firstReject = undefined
firstResolveTriggered = false
firstRejectError = undefined
}
currentScope && onServerPrefetch?.(() => {
if (!isEnabled.value || (isServer && currentOptions.value?.prefetch === false)) return
return new Promise<void>((resolve, reject) => {
firstResolve = () => {
resetFirstResolveReject()
resolve()
}
firstReject = (apolloError: ApolloError) => {
resetFirstResolveReject()
reject(apolloError)
}
if (firstResolveTriggered) {
firstResolve()
} else if (firstRejectError) {
firstReject(firstRejectError)
}
}).finally(stop)
})
// Apollo Client
const { resolveClient } = useApolloClient()
function getClient () {
return resolveClient(currentOptions.value?.clientId)
}
// Query
const query: Ref<ObservableQuery<TResult, TVariables> | null | undefined> = shallowRef()
let observer: ObservableSubscription | undefined
let started = false
let ignoreNextResult = false
let firstStart = true
/**
* Starts watching the query
*/
function start () {
if (
started || !isEnabled.value ||
(isServer && currentOptions.value?.prefetch === false) ||
!currentDocument
) {
tryFirstResolve()
return
}
// On server the watchers on document, variables and options are not triggered
if (isServer) {
applyDocument(documentRef.value)
applyVariables(variablesRef.value)
applyOptions(unref(optionsRef))
}
started = true
error.value = null
loading.value = true
const client = getClient()
query.value = client.watchQuery<TResult, TVariables>({
query: currentDocument,
variables: currentVariables ?? {} as TVariables,
...currentOptions.value,
...(isServer && currentOptions.value?.fetchPolicy !== 'no-cache')
? {
fetchPolicy: 'network-only',
}
: {},
})
startQuerySubscription()
// Make the cache data available to the component immediately
// This prevents SSR hydration mismatches
if (!isServer && (firstStart || !currentOptions.value?.keepPreviousResult) && (currentOptions.value?.fetchPolicy !== 'no-cache' || currentOptions.value.notifyOnNetworkStatusChange)) {
const currentResult = query.value.getCurrentResult(false)
if (!currentResult.loading || currentResult.partial || currentOptions.value?.notifyOnNetworkStatusChange) {
onNextResult(currentResult)
ignoreNextResult = !currentResult.loading
} else if (currentResult.error) {
onError(currentResult.error)
ignoreNextResult = true
}
}
if (!isServer) {
for (const item of subscribeToMoreItems) {
addSubscribeToMore(item)
}
}
firstStart = false
}
function startQuerySubscription () {
if (observer && !observer.closed) return
if (!query.value) return
// Create subscription
ignoreNextResult = false
observer = query.value.subscribe({
next: onNextResult,
error: onError,
})
}
function getErrorPolicy () {
const client = resolveClient(currentOptions.value?.clientId)
return currentOptions.value?.errorPolicy || client.defaultOptions?.watchQuery?.errorPolicy
}
function onNextResult (queryResult: ApolloQueryResult<TResult>) {
if (ignoreNextResult) {
ignoreNextResult = false
return
}
// Remove any previous error that may still be present from the last fetch (so result handlers
// don't receive old errors that may not even be applicable anymore).
error.value = null
processNextResult(queryResult)
// When `errorPolicy` is `all`, `onError` will not get called and
// ApolloQueryResult.errors may be set at the same time as we get a result.
// The code is only relevant when `errorPolicy` is `all`, because for other situations it
// could hapen that next and error are called at the same time and then it will lead to multiple
// onError calls.
const errorPolicy = getErrorPolicy()
if (errorPolicy && errorPolicy === 'all' && !queryResult.error && queryResult.errors?.length) {
processError(resultErrorsToApolloError(queryResult.errors))
}
tryFirstResolve()
}
function processNextResult (queryResult: ApolloQueryResult<TResult>) {
result.value = queryResult.data && Object.keys(queryResult.data).length === 0
? queryResult.error &&
!currentOptions.value?.returnPartialData &&
currentOptions.value?.errorPolicy === 'none'
? undefined
: result.value
: queryResult.data
loading.value = queryResult.loading
networkStatus.value = queryResult.networkStatus
// Wait for handlers to be registered
nextTick(() => {
resultEvent.trigger(queryResult, {
client: getClient(),
})
})
}
function onError (queryError: unknown) {
if (ignoreNextResult) {
ignoreNextResult = false
return
}
// any error should already be an ApolloError, but we make sure
const apolloError = toApolloError(queryError)
const errorPolicy = getErrorPolicy()
if (errorPolicy && errorPolicy !== 'none') {
processNextResult((query.value as ObservableQuery<TResult, TVariables>).getCurrentResult())
}
processError(apolloError)
tryFirstReject(apolloError)
// The observable closes the sub if an error occurs
resubscribeToQuery()
}
function processError (apolloError: ApolloError) {
error.value = apolloError
loading.value = false
networkStatus.value = 8
// Wait for handlers to be registered
nextTick(() => {
errorEvent.trigger(apolloError, {
client: getClient(),
})
})
}
function resubscribeToQuery () {
if (!query.value) return
const lastError = query.value.getLastError()
const lastResult = query.value.getLastResult()
query.value.resetLastResults()
startQuerySubscription()
Object.assign(query.value, { lastError, lastResult })
}
let onStopHandlers: Array<() => void> = []
/**
* Stop watching the query
*/
function stop () {
tryFirstResolve()
if (!started) return
started = false
loading.value = false
onStopHandlers.forEach(handler => handler())
onStopHandlers = []
if (query.value) {
query.value.stopPolling()
query.value = null
}
if (observer) {
observer.unsubscribe()
observer = undefined
}
}
// Restart
let restarting = false
/**
* Queue a restart of the query (on next tick) if it is already active
*/
function baseRestart () {
if (!started || restarting) return
restarting = true
// eslint-disable-next-line @typescript-eslint/no-floating-promises
nextTick(() => {
if (started) {
stop()
start()
}
restarting = false
})
}
let debouncedRestart: typeof baseRestart
let isRestartDebounceSetup = false
function updateRestartFn () {
// On server, will be called before currentOptions is initialized
// @TODO investigate
if (!currentOptions.value) {
debouncedRestart = baseRestart
} else {
if (currentOptions.value?.throttle) {
debouncedRestart = throttle(currentOptions.value.throttle, baseRestart)
} else if (currentOptions.value?.debounce) {
debouncedRestart = debounce(currentOptions.value.debounce, baseRestart)
} else {
debouncedRestart = baseRestart
}
isRestartDebounceSetup = true
}
}
function restart () {
if (!started || restarting) return
if (!isRestartDebounceSetup) updateRestartFn()
debouncedRestart()
}
// Applying document
let currentDocument: DocumentNode | null | undefined = documentRef.value
// Enabled state
const forceDisabled = ref(lazy)
const enabledOption = computed(() => !currentOptions.value || currentOptions.value.enabled == null || currentOptions.value.enabled)
const isEnabled = computed(() => enabledOption.value && !forceDisabled.value && !!documentRef.value)
// Applying options first (in case it disables the query)
watch(() => unref(optionsRef), applyOptions, {
deep: true,
immediate: true,
})
function applyOptions (value: UseQueryOptions<TResult, TVariables>) {
if (currentOptions.value && (
currentOptions.value.throttle !== value.throttle ||
currentOptions.value.debounce !== value.debounce
)) {
updateRestartFn()
}
currentOptions.value = value
restart()
}
// Applying document
watch(documentRef, applyDocument)
function applyDocument (value: DocumentNode | null | undefined) {
currentDocument = value
restart()
}
// Applying variables
let currentVariables: TVariables | undefined
let currentVariablesSerialized: string
watch(() => {
if (isEnabled.value) {
return variablesRef.value
} else {
return undefined
}
}, applyVariables, {
deep: true,
immediate: true,
})
function applyVariables (value?: TVariables) {
const serialized = JSON.stringify([value, isEnabled.value])
if (serialized !== currentVariablesSerialized) {
currentVariables = value
restart()
}
currentVariablesSerialized = serialized
}
// Refetch
function refetch (variables: TVariables | undefined = undefined) {
if (query.value) {
if (variables) {
currentVariables = variables
}
error.value = null
loading.value = true
return query.value.refetch(variables)
.then((refetchResult) => {
const currentResult = query.value?.getCurrentResult()
currentResult && processNextResult(currentResult)
return refetchResult
})
}
}
// Update Query
function updateQuery (mapFn: (previousQueryResult: TResult, options: Pick<WatchQueryOptions<TVariables, TResult>, 'variables'>) => TResult) {
if (query.value) {
query.value.updateQuery(mapFn)
}
}
// Fetch more
function fetchMore (options: FetchMoreQueryOptions<TVariables, TResult> & FetchMoreOptions<TResult, TVariables>) {
if (query.value) {
error.value = null
loading.value = true
return query.value.fetchMore(options)
.then((fetchMoreResult) => {
const currentResult = query.value?.getCurrentResult()
currentResult && processNextResult(currentResult)
return fetchMoreResult
})
}
}
// Subscribe to more
const subscribeToMoreItems: SubscribeToMoreItem[] = []
function subscribeToMore<
TSubscriptionVariables = OperationVariables,
TSubscriptionData = TResult
> (
options: SubscribeToMoreOptions<TResult, TSubscriptionVariables, TSubscriptionData> |
Ref<SubscribeToMoreOptions<TResult, TSubscriptionVariables, TSubscriptionData>> |
ReactiveFunction<SubscribeToMoreOptions<TResult, TSubscriptionVariables, TSubscriptionData>>,
) {
if (isServer) return
const optionsRef = paramToRef(options)
watch(optionsRef, (value, oldValue, onCleanup) => {
const index = subscribeToMoreItems.findIndex(item => item.options === oldValue)
if (index !== -1) {
subscribeToMoreItems.splice(index, 1)
}
const item: SubscribeToMoreItem = {
options: value,
unsubscribeFns: [],
}
subscribeToMoreItems.push(item)
addSubscribeToMore(item)
onCleanup(() => {
item.unsubscribeFns.forEach(fn => fn())
item.unsubscribeFns = []
})
}, {
immediate: true,
})
}
function addSubscribeToMore (item: SubscribeToMoreItem) {
if (!started) return
if (!query.value) {
throw new Error('Query is not defined')
}
const unsubscribe = query.value.subscribeToMore(item.options)
onStopHandlers.push(unsubscribe)
item.unsubscribeFns.push(unsubscribe)
}
// Auto start & stop
watch(isEnabled, value => {
if (value) {
nextTick(() => {
start()
})
} else {
stop()
}
})
if (isEnabled.value) {
start()
}
// Teardown
if (currentScope) {
onScopeDispose(() => {
stop()
subscribeToMoreItems.length = 0
})
} else {
console.warn('[Vue apollo] useQuery() is called outside of an active effect scope and the query will not be automatically stopped.')
}
return {
result,
loading,
networkStatus,
error,
start,
stop,
restart,
forceDisabled,
document: documentRef,
variables: variablesRef,
options: optionsRef,
query,
refetch,
fetchMore,
subscribeToMore,
updateQuery,
onResult: resultEvent.on,
onError: errorEvent.on,
}
}
``` | /content/code_sandbox/packages/vue-apollo-composable/src/useQuery.ts | xml | 2016-09-18T18:44:06 | 2024-08-14T21:22:24 | apollo | vuejs/apollo | 6,009 | 4,491 |
```xml
import { getStorybookVersionSpecifier } from 'storybook/internal/cli';
import {
JsPackageManagerFactory,
getCoercedStorybookVersion,
getStorybookInfo,
} from 'storybook/internal/common';
import { listCodemods, runCodemod } from '@storybook/codemod';
import { runFixes } from './automigrate';
import { mdxToCSF } from './automigrate/fixes/mdx-to-csf';
const logger = console;
type CLIOptions = {
glob: string;
configDir?: string;
dryRun?: boolean;
list?: string[];
/** Rename suffix of matching files after codemod has been applied, e.g. `".js:.ts"` */
rename?: string;
/** `jscodeshift` parser */
parser?: 'babel' | 'babylon' | 'flow' | 'ts' | 'tsx';
};
export async function migrate(
migration: any,
{ glob, dryRun, list, rename, parser, configDir: userSpecifiedConfigDir }: CLIOptions
) {
if (list) {
listCodemods().forEach((key: any) => logger.log(key));
} else if (migration) {
if (migration === 'mdx-to-csf' && !dryRun) {
const packageManager = JsPackageManagerFactory.getPackageManager();
const [packageJson, storybookVersion] = await Promise.all([
packageManager.retrievePackageJson(),
getCoercedStorybookVersion(packageManager),
]);
const { configDir: inferredConfigDir, mainConfig: mainConfigPath } = getStorybookInfo(
packageJson,
userSpecifiedConfigDir
);
const configDir = userSpecifiedConfigDir || inferredConfigDir || '.storybook';
// GUARDS
if (!storybookVersion) {
throw new Error('Could not determine Storybook version');
}
if (!mainConfigPath) {
throw new Error('Could not determine main config path');
}
await runFixes({
fixes: [mdxToCSF],
configDir,
mainConfigPath,
packageManager,
storybookVersion,
beforeVersion: storybookVersion,
isUpgrade: false,
});
await addStorybookBlocksPackage();
}
await runCodemod(migration, { glob, dryRun, logger, rename, parser });
} else {
throw new Error('Migrate: please specify a migration name or --list');
}
}
export async function addStorybookBlocksPackage() {
const packageManager = JsPackageManagerFactory.getPackageManager();
const packageJson = await packageManager.retrievePackageJson();
const versionToInstall = getStorybookVersionSpecifier(await packageManager.retrievePackageJson());
logger.info(` Adding "@storybook/blocks" package`);
await packageManager.addDependencies({ installAsDevDependencies: true, packageJson }, [
`@storybook/blocks@${versionToInstall}`,
]);
}
``` | /content/code_sandbox/code/lib/cli-storybook/src/migrate.ts | xml | 2016-03-18T04:23:44 | 2024-08-16T19:22:08 | storybook | storybookjs/storybook | 83,755 | 625 |
```xml
<?xml version="1.0" encoding="utf-8"?>
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-->
<inset xmlns:android="path_to_url"
android:insetLeft="@dimen/round_button_inset"
android:insetTop="@dimen/round_button_inset"
android:insetRight="@dimen/round_button_inset"
android:insetBottom="@dimen/round_button_inset">
<ripple android:color="?android:attr/colorControlHighlight">
<item>
<!-- As we can't use themed ColorStateLists in L, we'll use a Drawable selector which
changes the shape's fill color. -->
<selector>
<item android:state_enabled="false">
<shape android:shape="rectangle">
<corners android:radius="@dimen/round_button_radius" />
<solid android:color="?android:attr/colorButtonNormal"/>
<padding android:left="@dimen/round_button_padding"
android:top="@dimen/round_button_padding"
android:right="@dimen/round_button_padding"
android:bottom="@dimen/round_button_padding"/>
</shape>
</item>
<item>
<shape android:shape="rectangle">
<corners android:radius="@dimen/round_button_radius" />
<solid android:color="@color/button_white"/>
<padding android:left="@dimen/round_button_padding"
android:top="@dimen/round_button_padding"
android:right="@dimen/round_button_padding"
android:bottom="@dimen/round_button_padding"/>
</shape>
</item>
</selector>
</item>
</ripple>
</inset>
``` | /content/code_sandbox/app/src/main/res/drawable/round_white_button.xml | xml | 2016-07-02T10:44:04 | 2024-08-16T18:55:54 | StreetComplete | streetcomplete/StreetComplete | 3,781 | 390 |
```xml
/**
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/**
* Client-side logging
* TODO: use a real logging system. Logging to the console is good enough for now.
*/
export const logger = console;
``` | /content/code_sandbox/addons/isl/src/logger.ts | xml | 2016-05-05T16:53:47 | 2024-08-16T19:12:02 | sapling | facebook/sapling | 5,987 | 62 |
```xml
import * as React from 'react';
import { IUnknownBlobDiff } from 'shared/models/Versioning/Blob/Diff';
import matchBy from 'shared/utils/matchBy';
import { JsonView } from 'shared/view/elements/JsonView/JsonView';
import styles from './UnknownDiffView.module.css';
const UnknownDiffView = ({ diff }: { diff: IUnknownBlobDiff }) => {
return (
<div className={styles.diff}>
<div className={styles.diffLeft}>
{matchBy(diff, 'diffType')({
added: d => null,
deleted: d => <JsonView object={d.data.data} />,
modified: d => <JsonView object={d.data.data} />,
conflicted: d => <JsonView object={d.data.data} />,
})}
</div>
<div className={styles.diffRight}>
{matchBy(diff, 'diffType')({
deleted: d => null,
added: d => <JsonView object={d.data.data} />,
modified: d => <JsonView object={d.data.data} />,
conflicted: d => <JsonView object={d.data.data} />,
})}
</div>
</div>
);
};
export default UnknownDiffView;
``` | /content/code_sandbox/webapp/client/src/features/versioning/compareCommits/view/DiffView/UnknownDiffView/UnknownDiffView.tsx | xml | 2016-10-19T01:07:26 | 2024-08-14T03:53:55 | modeldb | VertaAI/modeldb | 1,689 | 267 |
```xml
import { observe } from "mobx";
import _ from "lodash";
import Options from "./Options";
import Bindings from "./Bindings";
import {
props,
hasUnifiedProps,
hasSeparatedProps,
checkObserve,
isArrayOfStrings,
$try,
} from "./utils";
import { RuntimeMode } from "./models/StateInterface";
import { StateInterface } from "./models/StateInterface";
import { OptionsInterface } from "./models/OptionsInterface";
import { BindingsInterface } from "./models/BindingsInterface";
import { FormInterface } from "./models/FormInterface";
import { OptionsEnum } from "./models/OptionsModel";
import { FieldInterface } from "./models/FieldInterface";
export default class State implements StateInterface {
mode = RuntimeMode.mixed;
strict = false;
form: FormInterface;
options: OptionsInterface;
bindings: BindingsInterface;
$extra: any;
$struct: string[] = [];
disposers = {
interceptor: {},
observer: {},
};
initial = {
props: {},
fields: {},
};
current = {
props: {},
fields: {},
};
constructor({ form, initial, options, bindings }: any) {
this.set("form", form);
this.initProps(initial);
this.options = new Options();
this.options.set(options);
this.bindings = new Bindings();
this.bindings.register(bindings);
this.observeOptions();
}
initProps(initial: any = {}) {
const initialProps: any = _.pick(initial, [
...props.editable,
...props.separated,
...props.validation,
...props.functions,
...props.handlers,
]);
this.set("initial", "props", initialProps);
const $unified: boolean = hasUnifiedProps(initial);
const $separated: boolean = hasSeparatedProps(initial);
if (($separated || isArrayOfStrings(initial.fields)) && !$unified) {
const struct: any = $try(initial.struct, initial.fields);
this.struct(struct);
this.strict = true;
this.mode = RuntimeMode.separated;
return;
}
this.struct(initial.struct);
this.mode = RuntimeMode.unified;
}
/**
Get/Set Fields Structure
*/
struct(data: any = null): any {
if (data) this.$struct = data;
return this.$struct;
}
/**
Get Props/Fields
*/
get(type: string, subtype: string) {
return (this as any)[type][subtype];
}
/**
Set Props/Fields
*/
set(type: string, subtype: any, state: any = null) {
if (type === "form") {
// subtype is the form here
this.form = subtype;
}
if (type === "initial") {
Object.assign((this.initial as any)[subtype], state);
Object.assign((this.current as any)[subtype], state);
}
if (type === "current") {
Object.assign((this.current as any)[subtype], state);
}
}
extra(data: any | null = null): any | null {
if (_.isString(data)) return _.get(this.$extra, data);
if (data === null) return this.$extra;
this.$extra = data;
return null;
}
observeOptions(): void {
// Fix Issue #201
observe(
this.options.options,
checkObserve([
{
// start observing fields validateOnChange
type: "update",
key: OptionsEnum.validateOnChange,
to: true,
exec: () =>
this.form.each((field: FieldInterface) =>
field.observeValidationOnChange()
),
},
{
// stop observing fields validateOnChange
type: "update",
key: OptionsEnum.validateOnChange,
to: false,
exec: () =>
this.form.each((field: FieldInterface) =>
field.disposeValidationOnChange()
),
},
{
// start observing fields validateOnBlur
type: "update",
key: OptionsEnum.validateOnBlur,
to: true,
exec: () =>
this.form.each((field: FieldInterface) =>
field.observeValidationOnBlur()
),
},
{
// stop observing fields validateOnBlur
type: "update",
key: OptionsEnum.validateOnBlur,
to: false,
exec: () =>
this.form.each((field: FieldInterface) =>
field.disposeValidationOnBlur()
),
},
])
);
}
}
``` | /content/code_sandbox/src/State.ts | xml | 2016-06-20T22:10:41 | 2024-08-10T13:14:33 | mobx-react-form | foxhound87/mobx-react-form | 1,093 | 972 |
```xml
import React, { useState } from 'react';
// @ts-ignore ts-migrate(2305) FIXME: Module '"react"' has no exported member 'Node'.
import type { Node } from 'react';
import { merge } from 'lodash/fp';
import { getFeatureFromContext } from '../../utils/mobx-features/hooks';
import type { LocalStorageApi } from './types';
export const localStorageContext = React.createContext<LocalStorageApi | null>(
null
);
interface Props {
children: Node;
localStorage: LocalStorageApi;
}
export function LocalStorageFeatureProvider({ children, localStorage }: Props) {
const [localStorageFeature] = useState<LocalStorageApi>(() => {
// @ts-ignore ts-migrate(2339) FIXME: Property 'daedalus' does not exist on type 'Window... Remove this comment to see the full error message
window.daedalus = merge(window.daedalus, {
features: {
localStorage,
},
});
return localStorage;
});
return (
<localStorageContext.Provider value={localStorageFeature}>
{children}
</localStorageContext.Provider>
);
}
export function useLocalStorageFeature(): LocalStorageApi {
return getFeatureFromContext(localStorageContext);
}
``` | /content/code_sandbox/source/renderer/app/features/local-storage/context.tsx | xml | 2016-10-05T13:48:54 | 2024-08-13T22:03:19 | daedalus | input-output-hk/daedalus | 1,230 | 258 |
```xml
import { IStyle, ITheme } from '@fluentui/react/lib/Styling';
import { IStyleFunctionOrObject } from '@fluentui/react/lib/Utilities';
import { IMargins } from '../../types/index';
/**
* {@docCategory TreeChart}
*/
export interface ITreeChartDataPoint {
/**
* Node main text
*/
name: string;
/**
* Subtext value (optional)
*/
subname?: string;
/**
* Bodytext value (optional)
*/
bodytext?: string;
/**
* Metric text value (optional)
*/
metric?: string;
/**
* Color of the rectangular box
*/
fill: string;
/**
* Recursive datastructure for child node object
*/
children?: Array<ITreeChartDataPoint>;
}
/**
* {@docCategory TreeChart}
*/
export enum NodesComposition {
/**
* NodeComposition enum val for long: number = 1
*/
long = 1,
/**
* NodeComposition enum val for compact: number = 0
*/
compact = 0,
}
/**
* {@docCategory TreeChart}
*/
export enum TreeTraverse {
/**
* TreeTraverse enum val for preOrder: number = 1
*/
preOrder = 1,
/**
* TreeTraverse enum val for levelOrder: number = 0
*/
levelOrder = 0,
}
/**
* Tree Chart properties
* {@docCategory TreeChart}
*/
export interface ITreeProps {
/**
* An object of chart data points for the Tree chart
*/
treeData: ITreeChartDataPoint;
/**
* compostion for three layer chart, long: composition = 1; compact: composition = 0
*/
composition?: NodesComposition.long | NodesComposition.compact;
/**
* Node Width Size for the Tree Layout
* * @default 75
*/
layoutWidth?: number;
/**
* traversal order for tree chart, preOrder = 1, levelOrder = 0
*/
treeTraversal?: TreeTraverse.preOrder | TreeTraverse.levelOrder;
/**
* Width of SVG tree chart
* * @default 1500
*/
width?: number;
/**
* Height of SVG tree chart
* * @default 700
*/
height?: number;
/**
* Margins for the chart
* @default `{ top: 30, bottom: 30, left: 50, right: 20 }`
* To avoid edge cuttings to the chart, we recommend you use default values or greater then default values
*/
margins?: IMargins;
/**
* Call to provide customized styling that will layer on top of the variant rules.
*/
styles?: IStyleFunctionOrObject<ITreeStyleProps, ITreeStyles>;
/**
* Additional CSS class(es) to apply to the TreeChart.
*/
className?: string;
/**
* Theme (provided through customization.)
*/
theme?: ITheme;
}
export interface ITreeState {
/**
* Width of SVG tree chart
* * @default 1500
*/
_width: number;
/**
* Height of SVG tree chart
* * @default 700
*/
_height: number;
/**
* Layout Width of SVG tree chart
* * @default 75
*/
_layoutWidth?: number;
}
export interface ITreeDataStructure {
/**
* Node id of each node
*/
id: number;
/**
* Children node object
*/
children: Array<ITreeDataStructure>;
/**
* Node main text
*/
dataName: string;
/**
* Subtext value (optional)
*/
subName?: string;
/**
* Bodytext value (optional)
*/
bodyText?: string;
/**
* Metric text value (optional)
*/
metricName?: string;
/**
* Color of the rectangular box
*/
fill: string;
/**
* X-coordindate of node
*/
x: number;
/**
* Y-coordindate of node
*/
y: number;
/**
* Node id of each node's parent
*/
parentID: number;
}
/**
* Tree Chart style properties
* {@docCategory TreeChart}
*/
export interface ITreeStyleProps {
/**
* Theme (provided through customization.)
*/
theme: ITheme;
/**
* Additional CSS class(es) to apply to the TreeChart.
*/
className?: string;
}
/**
* Tree Chart styles
* {@docCategory TreeChart}
*/
export interface ITreeStyles {
/**
* Style for the root element.
*/
root: IStyle;
/**
* Style for the Link/Path element.
*/
link: IStyle;
/**
* Style for rectangular Node
*/
rectNode: IStyle;
/**
* Style for the node main Text
*/
rectText: IStyle;
/**
* Style for the node sub Text
*/
rectSubText: IStyle;
/**
* Style for the node body Text
*/
rectBodyText: IStyle;
/**
* Style for the node metric value Text
*/
rectMetricText: IStyle;
}
``` | /content/code_sandbox/packages/react-charting/src/components/TreeChart/TreeChart.types.ts | xml | 2016-06-06T15:03:44 | 2024-08-16T18:49:29 | fluentui | microsoft/fluentui | 18,221 | 1,168 |
```xml
import { TFabricPlatformPageProps } from '../../../interfaces/Platforms';
import { FacepilePageProps as ExternalProps } from '@fluentui/react-examples/lib/react/Facepile/Facepile.doc';
import { ISideRailLink } from '@fluentui/react-docsite-components/lib/index2';
const related: ISideRailLink[] = [];
export const FacepilePageProps: TFabricPlatformPageProps = {
web: {
...(ExternalProps as any),
related,
},
};
``` | /content/code_sandbox/apps/public-docsite/src/pages/Controls/FacepilePage/FacepilePage.doc.ts | xml | 2016-06-06T15:03:44 | 2024-08-16T18:49:29 | fluentui | microsoft/fluentui | 18,221 | 104 |
```xml
/*
*
* See the LICENSE file at the top-level directory of this distribution
* for licensing information.
*
* Unless otherwise agreed in a custom licensing agreement with the Lisk Foundation,
* no part of this software, including this file, may be copied, modified,
* propagated, or distributed except according to the terms contained in the
* LICENSE file.
*
* Removal or modification of this copyright notice is prohibited.
*/
import { Modules } from 'lisk-sdk';
export const getSampleCCM = (
nonce = 1,
ccmSizeInBytes?: number,
): Modules.Interoperability.CCMsg => {
return {
nonce: BigInt(nonce),
module: Modules.Interoperability.MODULE_NAME_INTEROPERABILITY,
crossChainCommand: Modules.Token.CROSS_CHAIN_COMMAND_NAME_TRANSFER,
sendingChainID: Buffer.from([0, 0, 0, 3]),
receivingChainID: Buffer.from('04000000', 'hex'),
fee: BigInt(nonce),
status: 0,
params: Buffer.alloc(ccmSizeInBytes ?? 10),
};
};
``` | /content/code_sandbox/framework-plugins/lisk-framework-chain-connector-plugin/test/utils/sampleCCM.ts | xml | 2016-02-01T21:45:35 | 2024-08-15T19:16:48 | lisk-sdk | LiskArchive/lisk-sdk | 2,721 | 234 |
```xml
import { ExportData } from "../../../src/importers/onepassword/types/onepassword-1pux-importer-types";
export const LoginData: ExportData = {
accounts: [
{
attrs: {
accountName: "Wendy Appleseed",
name: "Wendy Appleseed",
avatar: "profile-pic.png",
email: "wendy.c.appleseed@gmail.com",
uuid: "D4RI47B7BJDT25C2LWA7LEJLHZ",
domain: "path_to_url",
},
vaults: [
{
attrs: {
uuid: "rr3lr6c2opoggvrete23q72ahi",
desc: "",
avatar: "pic.png",
name: "Personal",
type: "P",
},
items: [
{
uuid: "2b3hr6p5hinr7prtrj65bwmxqu",
favIndex: 0,
createdAt: 1635522833,
updatedAt: 1635522872,
trashed: false,
categoryUuid: "001",
details: {
loginFields: [
{
value: "username123123123@gmail.com",
id: "",
name: "email",
fieldType: "E",
designation: "username",
},
{
value: "password!",
id: "",
name: "password",
fieldType: "P",
designation: "password",
},
{
value: "",
id: "terms",
name: "terms",
fieldType: "C",
},
{
value: "",
id: "policies",
name: "policies",
fieldType: "C",
},
],
sections: [
{
title: "Saved on www.fakesite.com",
name: "Section_mlvk6wzoifml4rbs4c3rfu4e2a",
fields: [
{
title: "Create an account",
id: "cyqyggt2otns6tbbqtsl6w2ceu",
value: {
string: "username123123",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "one-time password",
id: "TOTP_564mvwqapphpsjetnnuovmuxum",
value: {
totp: "otpseed777",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [
{
value: "123uio123oiu123uiopassword",
time: 1635522872,
},
{
value: "123uio123oiu123uiopassword123",
time: 1635522854,
},
{
value: "123uio123oiu123uiopassword123123",
time: 1635522848,
},
],
},
overview: {
subtitle: "username123123@gmail.com",
urls: [
{
label: "website",
url: "path_to_url",
},
],
title: "eToro",
url: "path_to_url",
ps: 54,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};
``` | /content/code_sandbox/libs/importer/spec/test-data/onepassword-1pux/login-data.ts | xml | 2016-03-09T23:14:01 | 2024-08-16T15:07:51 | clients | bitwarden/clients | 8,877 | 811 |
```xml
import { StateRegistry } from '@uirouter/angularjs';
import angular from 'angular';
import { r2a } from '@/react-tools/react2angular';
import { ListView } from '@/react/docker/containers/ListView';
import { withCurrentUser } from '@/react-tools/withCurrentUser';
import { withReactQuery } from '@/react-tools/withReactQuery';
import { withUIRouter } from '@/react-tools/withUIRouter';
import { LogView } from '@/react/docker/containers/LogView';
import { CreateView } from '@/react/docker/containers/CreateView';
import { InspectView } from '@/react/docker/containers/InspectView/InspectView';
export const containersModule = angular
.module('portainer.docker.react.views.containers', [])
.component(
'createContainerView',
r2a(withUIRouter(withCurrentUser(CreateView)), [])
)
.component(
'containersView',
r2a(withUIRouter(withReactQuery(withCurrentUser(ListView))), ['endpoint'])
)
// the view only contains the information panel when logging is disabled
// this is a temporary solution to avoid creating a publicly exposed component
// or an AngularJS component until the logs view is migrated to React
.component(
'containerLogView',
r2a(withUIRouter(withReactQuery(withCurrentUser(LogView))), [])
)
.component(
'dockerContainerInspectView',
r2a(withUIRouter(withReactQuery(withCurrentUser(InspectView))), [])
)
.config(config).name;
/* @ngInject */
function config($stateRegistryProvider: StateRegistry) {
$stateRegistryProvider.register({
name: 'docker.containers',
url: '/containers',
views: {
'content@': {
component: 'containersView',
},
},
data: {
docs: '/user/docker/containers',
},
});
$stateRegistryProvider.register({
name: 'docker.containers.container',
url: '/:id?nodeName',
views: {
'content@': {
templateUrl: '~@/docker/views/containers/edit/container.html',
controller: 'ContainerController',
},
},
});
$stateRegistryProvider.register({
name: 'docker.containers.container.attach',
url: '/attach',
views: {
'content@': {
templateUrl: '~@/docker/views/containers/console/attach.html',
controller: 'ContainerConsoleController',
},
},
});
$stateRegistryProvider.register({
name: 'docker.containers.container.exec',
url: '/exec',
views: {
'content@': {
templateUrl: '~@/docker/views/containers/console/exec.html',
controller: 'ContainerConsoleController',
},
},
});
$stateRegistryProvider.register({
name: 'docker.containers.new',
url: '/new?nodeName&from',
views: {
'content@': {
component: 'createContainerView',
},
},
data: {
docs: '/user/docker/containers/add',
},
});
$stateRegistryProvider.register({
name: 'docker.containers.container.inspect',
url: '/inspect',
views: {
'content@': {
component: 'dockerContainerInspectView',
},
},
});
$stateRegistryProvider.register({
name: 'docker.containers.container.logs',
url: '/logs',
views: {
'content@': {
templateUrl: '~@/docker/views/containers/logs/containerlogs.html',
controller: 'ContainerLogsController',
},
},
});
$stateRegistryProvider.register({
name: 'docker.containers.container.stats',
url: '/stats',
views: {
'content@': {
templateUrl: '~@/docker/views/containers/stats/containerstats.html',
controller: 'ContainerStatsController',
},
},
});
}
``` | /content/code_sandbox/app/docker/react/views/containers.ts | xml | 2016-05-19T20:15:28 | 2024-08-16T19:15:14 | portainer | portainer/portainer | 30,083 | 820 |
```xml
/**
* Test script for the Oni Layers API, tests the adding of new files and splits.
*/
import * as React from "react"
import * as assert from "assert"
import * as os from "os"
import * as path from "path"
import * as Oni from "oni-api"
import { createNewFile } from "./Common"
export class TestLayer implements Oni.BufferLayer {
public get id(): string {
return "automation.test.layer"
}
public render(context: Oni.BufferLayerRenderContext): JSX.Element {
let className = "test-automation-layer "
if (context.isActive) {
className += "active"
} else {
className += "inactive"
}
return <div className={className}>{context.visibleLines.join(os.EOL)}</div>
}
}
const getLayerElements = () => {
return document.querySelectorAll(".test-automation-layer")
}
const getActiveLayerElements = () => {
return document.querySelectorAll(".test-automation-layer.active")
}
const getInactiveLayerElements = () => {
return document.querySelectorAll(".test-automation-layer.inactive")
}
export const test = async (oni: Oni.Plugin.Api) => {
await oni.automation.waitForEditors()
await createNewFile("js", oni, "line1\nline2")
oni.editors.activeEditor.activeBuffer.addLayer(new TestLayer())
// Wait for layer to appear
await oni.automation.waitFor(() => getLayerElements().length === 1)
// Validate the buffer layer has rendered the 'visibleLines'
const element = getLayerElements()[0]
assert.ok(element.textContent.indexOf("line1") >= 0, "Validate line1 is present in the layer")
assert.ok(element.textContent.indexOf("line2") >= 0, "Validate line2 is present in the layer")
// Validate elements
assert.strictEqual(getActiveLayerElements().length, 1)
assert.strictEqual(getInactiveLayerElements().length, 0)
oni.automation.sendKeys(":vsp<CR>")
await oni.automation.waitFor(() => getLayerElements().length === 2)
assert.strictEqual(getActiveLayerElements().length, 1)
assert.strictEqual(getInactiveLayerElements().length, 1)
}
``` | /content/code_sandbox/test/ci/Api.Buffer.AddLayer.tsx | xml | 2016-11-16T14:42:55 | 2024-08-14T11:48:05 | oni | onivim/oni | 11,355 | 475 |
```xml
/*
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
import zeros = require( '@stdlib/array/zeros' );
import random = require( './index' );
// TESTS //
// The function returns an array...
{
random( 10, 2, 5.0 ); // $ExpectType RandomArray
random( 10, 2, 5.0, {} ); // $ExpectType RandomArray
}
// The compiler throws an error if the function is provided a first argument which is not a number...
{
random( '5', 2, 5.0 ); // $ExpectError
random( true, 2, 5.0 ); // $ExpectError
random( false, 2, 5.0 ); // $ExpectError
random( null, 2, 5.0 ); // $ExpectError
random( [], 2, 5.0 ); // $ExpectError
random( {}, 2, 5.0 ); // $ExpectError
random( ( x: number ): number => x, 2, 5.0 ); // $ExpectError
random( '5', 2, 5.0, {} ); // $ExpectError
random( true, 2, 5.0, {} ); // $ExpectError
random( false, 2, 5.0, {} ); // $ExpectError
random( null, 2, 5.0, {} ); // $ExpectError
random( [], 2, 5.0, {} ); // $ExpectError
random( {}, 2, 5.0, {} ); // $ExpectError
random( ( x: number ): number => x, 2, 5.0, {} ); // $ExpectError
}
// The compiler throws an error if the function is provided a second argument which is not a number...
{
random( 10, '5', 5.0 ); // $ExpectError
random( 10, true, 5.0 ); // $ExpectError
random( 10, false, 5.0 ); // $ExpectError
random( 10, null, 5.0 ); // $ExpectError
random( 10, [], 5.0 ); // $ExpectError
random( 10, {}, 5.0 ); // $ExpectError
random( 10, ( x: number ): number => x, 5.0 ); // $ExpectError
random( 10, '5', 5.0, {} ); // $ExpectError
random( 10, true, 5.0, {} ); // $ExpectError
random( 10, false, 5.0, {} ); // $ExpectError
random( 10, null, 5.0, {} ); // $ExpectError
random( 10, [], 5.0, {} ); // $ExpectError
random( 10, {}, 5.0, {} ); // $ExpectError
random( 10, ( x: number ): number => x, 5.0, {} ); // $ExpectError
}
// The compiler throws an error if the function is provided a third argument which is not a number...
{
random( 10, 2, '5' ); // $ExpectError
random( 10, 2, true ); // $ExpectError
random( 10, 2, false ); // $ExpectError
random( 10, 2, null ); // $ExpectError
random( 10, 2, [] ); // $ExpectError
random( 10, 2, {} ); // $ExpectError
random( 10, 2, ( x: number ): number => x ); // $ExpectError
random( 10, 2, '5', {} ); // $ExpectError
random( 10, 2, true, {} ); // $ExpectError
random( 10, 2, false, {} ); // $ExpectError
random( 10, 2, null, {} ); // $ExpectError
random( 10, 2, [], {} ); // $ExpectError
random( 10, 2, {}, {} ); // $ExpectError
random( 10, 2, ( x: number ): number => x, {} ); // $ExpectError
}
// The compiler throws an error if the function is provided an options argument which is not a valid object...
{
random( 10, 2, 5.0, '5' ); // $ExpectError
random( 10, 2, 5.0, 5 ); // $ExpectError
random( 10, 2, 5.0, true ); // $ExpectError
random( 10, 2, 5.0, false ); // $ExpectError
random( 10, 2, 5.0, [] ); // $ExpectError
random( 10, 2, 5.0, ( x: number ): number => x ); // $ExpectError
}
// The compiler throws an error if the function is provided a `dtype` option which is not a supported data type...
{
random( 10, 2, 5.0, { 'dtype': 123 } ); // $ExpectError
random( 10, 2, 5.0, { 'dtype': 'abc' } ); // $ExpectError
random( 10, 2, 5.0, { 'dtype': null } ); // $ExpectError
random( 10, 2, 5.0, { 'dtype': [] } ); // $ExpectError
random( 10, 2, 5.0, { 'dtype': {} } ); // $ExpectError
random( 10, 2, 5.0, { 'dtype': ( x: number ): number => x } ); // $ExpectError
}
// The compiler throws an error if the function is provided an unsupported number of arguments...
{
random(); // $ExpectError
random( 10 ); // $ExpectError
random( 10, 2 ); // $ExpectError
random( 10, 2, 5.0, {}, {} ); // $ExpectError
}
// Attached to the main export is an `assign` method which returns an array...
{
const x = zeros( 10, 'float64' );
random.assign( 2, 5.0, x ); // $ExpectType RandomArray
}
// The compiler throws an error if the `assign` method is provided a first argument which is not a number...
{
const x = zeros( 10, 'float64' );
random.assign( '5', 5.0, x ); // $ExpectError
random.assign( true, 5.0, x ); // $ExpectError
random.assign( false, 5.0, x ); // $ExpectError
random.assign( null, 5.0, x ); // $ExpectError
random.assign( [], 5.0, x ); // $ExpectError
random.assign( {}, 5.0, x ); // $ExpectError
random.assign( ( x: number ): number => x, 5.0, x ); // $ExpectError
}
// The compiler throws an error if the `assign` method is provided a second argument which is not a number...
{
const x = zeros( 10, 'float64' );
random.assign( 2, '5', x ); // $ExpectError
random.assign( 2, true, x ); // $ExpectError
random.assign( 2, false, x ); // $ExpectError
random.assign( 2, null, x ); // $ExpectError
random.assign( 2, [], x ); // $ExpectError
random.assign( 2, {}, x ); // $ExpectError
random.assign( 2, ( x: number ): number => x, x ); // $ExpectError
}
// The compiler throws an error if the function is provided a third argument which is not a valid output array...
{
random.assign( 2, 5.0, '5' ); // $ExpectError
random.assign( 2, 5.0, 5 ); // $ExpectError
random.assign( 2, 5.0, true ); // $ExpectError
random.assign( 2, 5.0, false ); // $ExpectError
random.assign( 2, 5.0, null ); // $ExpectError
random.assign( 2, 5.0, {} ); // $ExpectError
random.assign( 2, 5.0, ( x: number ): number => x ); // $ExpectError
}
// The compiler throws an error if the `assign` method is provided an unsupported number of arguments...
{
const x = zeros( 10, 'float64' );
random.assign(); // $ExpectError
random.assign( x ); // $ExpectError
random.assign( x, 2 ); // $ExpectError
random.assign( x, 2, 5.0, {} ); // $ExpectError
}
// Attached to main export is a `factory` method which returns a function...
{
random.factory( 2, 5.0 ); // $ExpectType UnaryFunction
random.factory( 2, 5.0, { 'copy': false } ); // $ExpectType UnaryFunction
random.factory(); // $ExpectType TernaryFunction
random.factory( { 'copy': false } ); // $ExpectType TernaryFunction
}
// The `factory` method returns a function which returns an array...
{
const fcn1 = random.factory( 2, 5.0 );
fcn1( 10 ); // $ExpectType RandomArray
const fcn2 = random.factory();
fcn2( 10, 2, 5.0 ); // $ExpectType RandomArray
}
// The compiler throws an error if the `factory` method is provided invalid arguments...
{
random.factory( '5', 5.0 ); // $ExpectError
random.factory( true, 5.0 ); // $ExpectError
random.factory( false, 5.0 ); // $ExpectError
random.factory( [], 5.0 ); // $ExpectError
random.factory( {}, 5.0 ); // $ExpectError
random.factory( ( x: number ): number => x, 5.0 ); // $ExpectError
random.factory( '5', 5.0, {} ); // $ExpectError
random.factory( true, 5.0, {} ); // $ExpectError
random.factory( false, 5.0, {} ); // $ExpectError
random.factory( [], 5.0, {} ); // $ExpectError
random.factory( {}, 5.0, {} ); // $ExpectError
random.factory( ( x: number ): number => x, 5.0, {} ); // $ExpectError
random.factory( 2, '5' ); // $ExpectError
random.factory( 2, true ); // $ExpectError
random.factory( 2, false ); // $ExpectError
random.factory( 2, [] ); // $ExpectError
random.factory( 2, {} ); // $ExpectError
random.factory( 2, ( x: number ): number => x ); // $ExpectError
random.factory( 2, '5', {} ); // $ExpectError
random.factory( 2, true, {} ); // $ExpectError
random.factory( 2, false, {} ); // $ExpectError
random.factory( 2, [], {} ); // $ExpectError
random.factory( 2, {}, {} ); // $ExpectError
random.factory( 2, ( x: number ): number => x, {} ); // $ExpectError
}
// The compiler throws an error if the `factory` method is provided an options argument which is not a valid object...
{
random.factory( null ); // $ExpectError
random.factory( 2, 5.0, null ); // $ExpectError
}
// The compiler throws an error if the `factory` method is provided a `prng` option which is not a pseudorandom number generator...
{
random.factory( 2, 5.0, { 'prng': 123 } ); // $ExpectError
random.factory( 2, 5.0, { 'prng': 'abc' } ); // $ExpectError
random.factory( 2, 5.0, { 'prng': null } ); // $ExpectError
random.factory( 2, 5.0, { 'prng': [] } ); // $ExpectError
random.factory( 2, 5.0, { 'prng': {} } ); // $ExpectError
random.factory( 2, 5.0, { 'prng': true } ); // $ExpectError
random.factory( { 'prng': 123 } ); // $ExpectError
random.factory( { 'prng': 'abc' } ); // $ExpectError
random.factory( { 'prng': null } ); // $ExpectError
random.factory( { 'prng': [] } ); // $ExpectError
random.factory( { 'prng': {} } ); // $ExpectError
random.factory( { 'prng': true } ); // $ExpectError
}
// The compiler throws an error if the `factory` method is provided a `seed` option which is not a valid seed...
{
random.factory( 2, 5.0, { 'seed': true } ); // $ExpectError
random.factory( 2, 5.0, { 'seed': 'abc' } ); // $ExpectError
random.factory( 2, 5.0, { 'seed': null } ); // $ExpectError
random.factory( 2, 5.0, { 'seed': [ 'a' ] } ); // $ExpectError
random.factory( 2, 5.0, { 'seed': {} } ); // $ExpectError
random.factory( 2, 5.0, { 'seed': ( x: number ): number => x } ); // $ExpectError
random.factory( { 'seed': true } ); // $ExpectError
random.factory( { 'seed': 'abc' } ); // $ExpectError
random.factory( { 'seed': null } ); // $ExpectError
random.factory( { 'seed': [ 'a' ] } ); // $ExpectError
random.factory( { 'seed': {} } ); // $ExpectError
random.factory( { 'seed': ( x: number ): number => x } ); // $ExpectError
}
// The compiler throws an error if the `factory` method is provided a `state` option which is not a valid state...
{
random.factory( 2, 5.0, { 'state': 123 } ); // $ExpectError
random.factory( 2, 5.0, { 'state': 'abc' } ); // $ExpectError
random.factory( 2, 5.0, { 'state': null } ); // $ExpectError
random.factory( 2, 5.0, { 'state': [] } ); // $ExpectError
random.factory( 2, 5.0, { 'state': {} } ); // $ExpectError
random.factory( 2, 5.0, { 'state': true } ); // $ExpectError
random.factory( 2, 5.0, { 'state': ( x: number ): number => x } ); // $ExpectError
random.factory( { 'state': 123 } ); // $ExpectError
random.factory( { 'state': 'abc' } ); // $ExpectError
random.factory( { 'state': null } ); // $ExpectError
random.factory( { 'state': [] } ); // $ExpectError
random.factory( { 'state': {} } ); // $ExpectError
random.factory( { 'state': true } ); // $ExpectError
random.factory( { 'state': ( x: number ): number => x } ); // $ExpectError
}
// The compiler throws an error if the `factory` method is provided a `copy` option which is not a boolean...
{
random.factory( 2, 5.0, { 'copy': 123 } ); // $ExpectError
random.factory( 2, 5.0, { 'copy': 'abc' } ); // $ExpectError
random.factory( 2, 5.0, { 'copy': null } ); // $ExpectError
random.factory( 2, 5.0, { 'copy': [] } ); // $ExpectError
random.factory( 2, 5.0, { 'copy': {} } ); // $ExpectError
random.factory( 2, 5.0, { 'copy': ( x: number ): number => x } ); // $ExpectError
random.factory( { 'copy': 123 } ); // $ExpectError
random.factory( { 'copy': 'abc' } ); // $ExpectError
random.factory( { 'copy': null } ); // $ExpectError
random.factory( { 'copy': [] } ); // $ExpectError
random.factory( { 'copy': {} } ); // $ExpectError
random.factory( { 'copy': ( x: number ): number => x } ); // $ExpectError
}
// The compiler throws an error if the `factory` method is provided a `dtype` option which is not a supported data type...
{
random.factory( 2, 5.0, { 'dtype': 123 } ); // $ExpectError
random.factory( 2, 5.0, { 'dtype': 'abc' } ); // $ExpectError
random.factory( 2, 5.0, { 'dtype': null } ); // $ExpectError
random.factory( 2, 5.0, { 'dtype': [] } ); // $ExpectError
random.factory( 2, 5.0, { 'dtype': {} } ); // $ExpectError
random.factory( 2, 5.0, { 'dtype': ( x: number ): number => x } ); // $ExpectError
random.factory( { 'dtype': 123 } ); // $ExpectError
random.factory( { 'dtype': 'abc' } ); // $ExpectError
random.factory( { 'dtype': null } ); // $ExpectError
random.factory( { 'dtype': [] } ); // $ExpectError
random.factory( { 'dtype': {} } ); // $ExpectError
random.factory( { 'dtype': ( x: number ): number => x } ); // $ExpectError
}
// The compiler throws an error if the `factory` method is provided more than three arguments...
{
random.factory( 2, 5.0, {}, {} ); // $ExpectError
}
// The compiler throws an error if the function returned by the `factory` method is provided invalid arguments...
{
const fcn1 = random.factory( 2, 5.0 );
fcn1( '5' ); // $ExpectError
fcn1( true ); // $ExpectError
fcn1( false ); // $ExpectError
fcn1( null ); // $ExpectError
fcn1( [] ); // $ExpectError
fcn1( {} ); // $ExpectError
fcn1( ( x: number ): number => x ); // $ExpectError
fcn1( '5', {} ); // $ExpectError
fcn1( true, {} ); // $ExpectError
fcn1( false, {} ); // $ExpectError
fcn1( null, {} ); // $ExpectError
fcn1( [], {} ); // $ExpectError
fcn1( {}, {} ); // $ExpectError
fcn1( ( x: number ): number => x, {} ); // $ExpectError
const fcn2 = random.factory();
fcn2( true, 2, 5.0 ); // $ExpectError
fcn2( false, 2, 5.0 ); // $ExpectError
fcn2( '5', 2, 5.0 ); // $ExpectError
fcn2( [], 2, 5.0 ); // $ExpectError
fcn2( {}, 2, 5.0 ); // $ExpectError
fcn2( ( x: number ): number => x, 2, 5.0 ); // $ExpectError
fcn2( true, 2, 5.0, {} ); // $ExpectError
fcn2( false, 2, 5.0, {} ); // $ExpectError
fcn2( '5', 2, 5.0, {} ); // $ExpectError
fcn2( [], 2, 5.0, {} ); // $ExpectError
fcn2( {}, 2, 5.0, {} ); // $ExpectError
fcn2( ( x: number ): number => x, 2, 5.0, {} ); // $ExpectError
fcn2( 10, true, 5.0 ); // $ExpectError
fcn2( 10, false, 5.0 ); // $ExpectError
fcn2( 10, '5', 5.0 ); // $ExpectError
fcn2( 10, [], 5.0 ); // $ExpectError
fcn2( 10, {}, 5.0 ); // $ExpectError
fcn2( 10, ( x: number ): number => x, 5.0 ); // $ExpectError
fcn2( 10, true, 5.0, {} ); // $ExpectError
fcn2( 10, false, 5.0, {} ); // $ExpectError
fcn2( 10, '5', 5.0, {} ); // $ExpectError
fcn2( 10, [], 5.0, {} ); // $ExpectError
fcn2( 10, {}, 5.0, {} ); // $ExpectError
fcn2( 10, ( x: number ): number => x, 5.0, {} ); // $ExpectError
fcn2( 10, 2, true ); // $ExpectError
fcn2( 10, 2, false ); // $ExpectError
fcn2( 10, 2, '5' ); // $ExpectError
fcn2( 10, 2, [] ); // $ExpectError
fcn2( 10, 2, {} ); // $ExpectError
fcn2( 10, 2, ( x: number ): number => x ); // $ExpectError
fcn2( 10, 2, true, {} ); // $ExpectError
fcn2( 10, 2, false, {} ); // $ExpectError
fcn2( 10, 2, '5', {} ); // $ExpectError
fcn2( 10, 2, [], {} ); // $ExpectError
fcn2( 10, 2, {}, {} ); // $ExpectError
fcn2( 10, 2, ( x: number ): number => x, {} ); // $ExpectError
}
// The compiler throws an error if the function returned by the `factory` method is provided a `dtype` option which is not a supported data type...
{
const fcn1 = random.factory();
fcn1( 2, 5.0, { 'dtype': 123 } ); // $ExpectError
fcn1( 2, 5.0, { 'dtype': 'abc' } ); // $ExpectError
fcn1( 2, 5.0, { 'dtype': null } ); // $ExpectError
fcn1( 2, 5.0, { 'dtype': [] } ); // $ExpectError
fcn1( 2, 5.0, { 'dtype': {} } ); // $ExpectError
fcn1( 2, 5.0, { 'dtype': ( x: number ): number => x } ); // $ExpectError
const fcn2 = random.factory( 2, 5.0 );
fcn2( { 'dtype': 123 } ); // $ExpectError
fcn2( { 'dtype': 'abc' } ); // $ExpectError
fcn2( { 'dtype': null } ); // $ExpectError
fcn2( { 'dtype': [] } ); // $ExpectError
fcn2( { 'dtype': {} } ); // $ExpectError
fcn2( { 'dtype': ( x: number ): number => x } ); // $ExpectError
}
// The compiler throws an error if the function returned by the `factory` method is provided an unsupported number of arguments...
{
const fcn1 = random.factory( 2, 5.0 );
fcn1(); // $ExpectError
fcn1( 1, 1, 1 ); // $ExpectError
const fcn2 = random.factory();
fcn2(); // $ExpectError
fcn2( 1 ); // $ExpectError
fcn2( 1, 1, 1, 1 ); // $ExpectError
}
``` | /content/code_sandbox/lib/node_modules/@stdlib/random/array/erlang/docs/types/test.ts | xml | 2016-03-24T04:19:52 | 2024-08-16T09:03:19 | stdlib | stdlib-js/stdlib | 4,266 | 5,473 |
```xml
<?xml version="1.0" encoding="utf-8"?>
Use of this source code is governed by a BSD-style license that can be
found in the LICENSE file. -->
<PreferenceScreen
xmlns:android="path_to_url"
xmlns:chrome="path_to_url">
<org.chromium.chrome.browser.preferences.ChromeSwitchPreference
android:key="do_not_track_switch"
android:summaryOn="@string/text_on"
android:summaryOff="@string/text_off"
chrome:drawDivider="true" />
<org.chromium.chrome.browser.preferences.TextMessagePreference
android:title="@string/do_not_track_description" />
</PreferenceScreen>
``` | /content/code_sandbox/libraries_res/chrome_res/src/main/res/xml/do_not_track_preferences.xml | xml | 2016-07-04T07:28:36 | 2024-08-15T05:20:42 | AndroidChromium | JackyAndroid/AndroidChromium | 3,090 | 139 |
```xml
<testsuites>
</testsuites>
``` | /content/code_sandbox/build-support/build-support-test-data/success-out.xml | xml | 2016-01-29T08:00:06 | 2024-08-16T11:13:40 | kudu | apache/kudu | 1,833 | 11 |
```xml
import { PostMessageService } from "./postMessage";
it("post and subscribe to a message", (done) => {
const postMessage = new PostMessageService(window, "coral", window, "*");
const cancel = postMessage.on("test", (value) => {
expect(value).toBe("value");
done();
cancel();
});
postMessage.send("test", "value", window);
});
it("should support complex value", (done) => {
const complex = { foo: "bar" };
const postMessage = new PostMessageService(window, "coral", window, "*");
const cancel = postMessage.on("test", (value) => {
expect(value).toBe(complex);
done();
cancel();
});
postMessage.send("test", complex, window);
});
it("send to a different origin", (done) => {
const postMessage = new PostMessageService(window, "coral", window, "*");
const cancelA = postMessage.on("testA", (value) => {
throw new Error("Should not reach this");
});
const cancelB = postMessage.on("testB", (value) => {
done();
cancelA();
cancelB();
});
postMessage.send("testA", "value", window, "path_to_url");
postMessage.send("testB", "value", window);
});
it("should cancel", (done) => {
const postMessage = new PostMessageService(window, "coral", window, "*");
const cancelA = postMessage.on("testA", (value) => {
throw new Error("Should not reach this");
});
const cancelB = postMessage.on("testB", (value) => {
done();
cancelB();
});
cancelA();
postMessage.send("testA", "value", window);
postMessage.send("testB", "value", window);
});
it("different message names are isolated", (done) => {
const postMessage = new PostMessageService(window, "coral", window, "*");
const cancelA = postMessage.on("testA", (value) => {
expect(value).toBe("valueA");
});
const cancelB = postMessage.on("testB", (value) => {
expect(value).toBe("valueB");
done();
cancelA();
cancelB();
});
postMessage.send("testA", "valueA", window);
postMessage.send("testB", "valueB", window);
});
``` | /content/code_sandbox/client/src/core/client/framework/lib/postMessage.spec.ts | xml | 2016-10-31T16:14:05 | 2024-08-06T16:15:57 | talk | coralproject/talk | 1,881 | 540 |
```xml
import { Component, EventEmitter, OnInit, Output } from '@angular/core';
import { Artifact } from '../../../../../../ng-swagger-gen/models/artifact';
import { Label } from '../../../../../../ng-swagger-gen/models/label';
import { ActivatedRoute, Router } from '@angular/router';
import { Project } from '../../project';
import { artifactDefault } from './artifact';
import { SafeUrl } from '@angular/platform-browser';
import { ArtifactService } from './artifact.service';
import {
EventService,
HarborEvent,
} from '../../../../services/event-service/event.service';
@Component({
selector: 'artifact-summary',
templateUrl: './artifact-summary.component.html',
styleUrls: ['./artifact-summary.component.scss'],
providers: [],
})
export class ArtifactSummaryComponent implements OnInit {
tagId: string;
artifactDigest: string;
sbomDigest?: string;
activeTab?: string;
repositoryName: string;
projectId: string | number;
referArtifactNameArray: string[] = [];
labels: Label;
artifact: Artifact;
@Output()
backEvt: EventEmitter<any> = new EventEmitter<any>();
projectName: string;
isProxyCacheProject: boolean = false;
loading: boolean = false;
constructor(
private route: ActivatedRoute,
private router: Router,
private frontEndArtifactService: ArtifactService,
private event: EventService
) {}
goBack(): void {
this.router.navigate([
'harbor',
'projects',
this.projectId,
'repositories',
this.repositoryName,
]);
}
goBackRep(): void {
this.router.navigate([
'harbor',
'projects',
this.projectId,
'repositories',
]);
}
goBackPro(): void {
this.router.navigate(['harbor', 'projects']);
}
jumpDigest(index: number) {
const arr: string[] = this.referArtifactNameArray.slice(0, index + 1);
if (arr && arr.length) {
this.router.navigate([
'harbor',
'projects',
this.projectId,
'repositories',
this.repositoryName,
'artifacts-tab',
'depth',
arr.join('-'),
]);
} else {
this.router.navigate([
'harbor',
'projects',
this.projectId,
'repositories',
this.repositoryName,
]);
}
}
ngOnInit(): void {
let depth = this.route.snapshot.params['depth'];
if (depth) {
this.referArtifactNameArray = depth.split('-');
}
this.repositoryName = this.route.snapshot.params['repo'];
this.artifactDigest = this.route.snapshot.params['digest'];
this.projectId = this.route.snapshot.parent.params['id'];
this.sbomDigest = this.route.snapshot.queryParams['sbomDigest'];
this.activeTab = this.route.snapshot.queryParams['tab'];
if (this.repositoryName && this.artifactDigest) {
const resolverData = this.route.snapshot.data;
if (resolverData) {
const pro: Project = <Project>(
resolverData['artifactResolver'][1]
);
this.projectName = pro.name;
if (pro.registry_id) {
this.isProxyCacheProject = true;
}
this.artifact = <Artifact>resolverData['artifactResolver'][0];
this.getIconFromBackEnd();
}
}
// scroll to the top for harbor container HTML element
this.event.publish(HarborEvent.SCROLL_TO_POSITION, 0);
}
onBack(): void {
this.backEvt.emit(this.repositoryName);
}
showDefaultIcon(event: any) {
if (event && event.target) {
event.target.src = artifactDefault;
}
}
getIcon(icon: string): SafeUrl {
return this.frontEndArtifactService.getIcon(icon);
}
getIconFromBackEnd() {
if (this.artifact && this.artifact.icon) {
this.frontEndArtifactService.getIconsFromBackEnd([this.artifact]);
}
}
}
``` | /content/code_sandbox/src/portal/src/app/base/project/repository/artifact/artifact-summary.component.ts | xml | 2016-01-28T21:10:28 | 2024-08-16T15:28:34 | harbor | goharbor/harbor | 23,335 | 849 |
```xml
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<document type="com.apple.InterfaceBuilder.AppleTV.Storyboard" version="3.0" toolsVersion="13771" targetRuntime="AppleTV" propertyAccessControl="none" useAutolayout="YES" colorMatched="YES" initialViewController="BYZ-38-t0r">
<dependencies>
<plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13772"/>
<capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
</dependencies>
<scenes>
<!--View Controller-->
<scene sceneID="tne-QT-ifu">
<objects>
<viewController id="BYZ-38-t0r" customClass="ViewController" sceneMemberID="viewController">
<layoutGuides>
<viewControllerLayoutGuide type="top" id="y3c-jy-aDJ"/>
<viewControllerLayoutGuide type="bottom" id="wfy-db-euE"/>
</layoutGuides>
<view key="view" contentMode="scaleToFill" id="8bC-Xf-vdC">
<rect key="frame" x="0.0" y="0.0" width="1920" height="1080"/>
<autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
<color key="backgroundColor" red="0.0" green="0.0" blue="0.0" alpha="0.0" colorSpace="custom" customColorSpace="sRGB"/>
<subviews>
<view contentMode="scaleToFill" id="166" customClass="SKCanvasView" translatesAutoresizingMaskIntoConstraints="NO" fixedFrame="YES">
<rect key="frame" x="0.0" y="0.0" width="1920" height="1080"/>
<autoresizingMask key="autoresizingMask" heightSizable="YES" widthSizable="YES"/>
<color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
</view>
</subviews>
</view>
<connections>
<outlet property="skiaView" destination="166" id="name-outlet-166"/>
</connections>
</viewController>
<placeholder placeholderIdentifier="IBFirstResponder" id="dkx-z0-nzr" sceneMemberID="firstResponder"/>
</objects>
<point key="canvasLocation" x="0.0" y="0.0"/>
</scene>
</scenes>
</document>
``` | /content/code_sandbox/samples/Basic/tvOS/SkiaSharpSample/Main.storyboard | xml | 2016-02-22T17:54:43 | 2024-08-16T17:53:42 | SkiaSharp | mono/SkiaSharp | 4,347 | 571 |
```xml
import React, { FunctionComponent } from "react";
const SingleNeutralProfilePictureIcon: FunctionComponent = () => {
// path_to_url
return (
<svg
id="Regular"
xmlns="path_to_url"
viewBox="-0.25 -0.25 24.5 24.5"
>
<defs></defs>
<title>single-neutral-profile-picture</title>
<rect
x="2.25"
y="0.75"
width="19.5"
height="22.5"
rx="1.5"
ry="1.5"
fill="none"
stroke="currentColor"
strokeLinecap="round"
strokeLinejoin="round"
></rect>
<circle
cx="12"
cy="9.083"
r="4.11"
fill="none"
stroke="currentColor"
strokeLinecap="round"
strokeLinejoin="round"
></circle>
<path
d="M18.75,19.027a7.63,7.63,0,0,0-13.5,0"
fill="none"
stroke="currentColor"
strokeLinecap="round"
strokeLinejoin="round"
></path>
</svg>
);
};
export default SingleNeutralProfilePictureIcon;
``` | /content/code_sandbox/client/src/core/client/ui/components/icons/SingleNeutralProfilePictureIcon.tsx | xml | 2016-10-31T16:14:05 | 2024-08-06T16:15:57 | talk | coralproject/talk | 1,881 | 286 |
```xml
import { expect } from '@playwright/test';
import { parallelTest as test } from '../../../../parallelTest';
import WpAdminPage from '../../../../pages/wp-admin-page';
const iconExperimentStates = [ 'inactive', 'active' ];
iconExperimentStates.forEach( ( iconExperimentState ) => {
test.describe( `Rating content panel - Icon Experiment ${ iconExperimentState } @rating`, () => {
test( `Functionality test - Icon Experiment: ${ iconExperimentState }`, async ( { page, apiRequests }, testInfo ) => {
const wpAdmin = new WpAdminPage( page, testInfo, apiRequests ),
editor = await wpAdmin.openNewPage(),
container = await editor.addElement( { elType: 'container' }, 'document' ),
ratingId = await editor.addWidget( 'rating', container ),
ratingElement = editor.getPreviewFrame().locator( `.elementor-element-${ ratingId } .e-rating` );
await test.step( 'Rating Scale', async () => {
await editor.setSliderControlValue( 'rating_scale', '3' );
await expect.soft( ratingElement.locator( '.e-icon' ) ).toHaveCount( 3 );
} );
await test.step( 'Rating Value', async () => {
await editor.setNumberControlValue( 'rating_value', '1.543' );
await expect.soft( ratingElement.locator( '.e-icon >> nth=0' ).locator( '.e-icon-marked' ) ).toHaveCSS( '--e-rating-icon-marked-width', '100%' );
await expect.soft( ratingElement.locator( '.e-icon >> nth=1' ).locator( '.e-icon-marked' ) ).toHaveCSS( '--e-rating-icon-marked-width', '54%' );
await expect.soft( ratingElement.locator( '.e-icon >> nth=2' ).locator( '.e-icon-marked' ) ).toHaveCSS( '--e-rating-icon-marked-width', '0%' );
} );
await test.step( 'Icon Alignment Start', async () => {
await editor.togglePreviewMode();
expect.soft( await editor.getPreviewFrame().locator( '.e-rating' ).screenshot( {
type: 'png',
} ) ).toMatchSnapshot( `rating-alignment-start-icon-experiment-${ iconExperimentState }.png` );
await editor.togglePreviewMode();
} );
await test.step( 'Icon Alignment Center', async () => {
await editor.setChooseControlValue( 'icon_alignment', 'eicon-align-center-h' );
await editor.togglePreviewMode();
expect.soft( await editor.getPreviewFrame().locator( '.e-rating' ).screenshot( {
type: 'png',
} ) ).toMatchSnapshot( `rating-alignment-center-icon-experiment-${ iconExperimentState }.png` );
await editor.togglePreviewMode();
} );
await test.step( 'Icon Alignment End', async () => {
await editor.setChooseControlValue( 'icon_alignment', 'eicon-align-end-h' );
await editor.togglePreviewMode();
expect.soft( await editor.getPreviewFrame().locator( '.e-rating' ).screenshot( {
type: 'png',
} ) ).toMatchSnapshot( `rating-alignment-end-icon-experiment-${ iconExperimentState }.png` );
await editor.togglePreviewMode();
} );
} );
} );
} );
``` | /content/code_sandbox/tests/playwright/sanity/includes/widgets/rating/content-panel.test.ts | xml | 2016-05-30T13:05:46 | 2024-08-16T13:13:10 | elementor | elementor/elementor | 6,507 | 715 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<!--
~
~
~ path_to_url
~
~ Unless required by applicable law or agreed to in writing, software
~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-->
<resources>
<string name="mtrl_chip_close_icon_content_description">Retirar %1$s</string>
</resources>
``` | /content/code_sandbox/lib/java/com/google/android/material/chip/res/values-es/strings.xml | xml | 2016-12-05T16:11:29 | 2024-08-16T17:51:42 | material-components-android | material-components/material-components-android | 16,176 | 91 |
```xml
import { Operator } from '../Operator';
import { Observable } from '../Observable';
import { Subscriber } from '../Subscriber';
import { Subscription } from '../Subscription';
import { tryCatch } from '../util/tryCatch';
import { errorObject } from '../util/errorObject';
import { subscribeToResult } from '../util/subscribeToResult';
import { OuterSubscriber } from '../OuterSubscriber';
import { InnerSubscriber } from '../InnerSubscriber';
import { ObservableInput, OperatorFunction } from '../types';
/**
* Applies an accumulator function over the source Observable where the
* accumulator function itself returns an Observable, then each intermediate
* Observable returned is merged into the output Observable.
*
* <span class="informal">It's like {@link scan}, but the Observables returned
* by the accumulator are merged into the outer Observable.</span>
*
* ## Example
* Count the number of click events
* ```javascript
* const click$ = fromEvent(document, 'click');
* const one$ = click$.pipe(mapTo(1));
* const seed = 0;
* const count$ = one$.pipe(
* mergeScan((acc, one) => of(acc + one), seed),
* );
* count$.subscribe(x => console.log(x));
*
* // Results:
* 1
* 2
* 3
* 4
* // ...and so on for each click
* ```
*
* @param {function(acc: R, value: T): Observable<R>} accumulator
* The accumulator function called on each source value.
* @param seed The initial accumulation value.
* @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of
* input Observables being subscribed to concurrently.
* @return {Observable<R>} An observable of the accumulated values.
* @method mergeScan
* @owner Observable
*/
export function mergeScan<T, R>(accumulator: (acc: R, value: T) => ObservableInput<R>,
seed: R,
concurrent: number = Number.POSITIVE_INFINITY): OperatorFunction<T, R> {
return (source: Observable<T>) => source.lift(new MergeScanOperator(accumulator, seed, concurrent));
}
export class MergeScanOperator<T, R> implements Operator<T, R> {
constructor(private accumulator: (acc: R, value: T) => ObservableInput<R>,
private seed: R,
private concurrent: number) {
}
call(subscriber: Subscriber<R>, source: any): any {
return source.subscribe(new MergeScanSubscriber(
subscriber, this.accumulator, this.seed, this.concurrent
));
}
}
/**
* We need this JSDoc comment for affecting ESDoc.
* @ignore
* @extends {Ignored}
*/
export class MergeScanSubscriber<T, R> extends OuterSubscriber<T, R> {
private hasValue: boolean = false;
private hasCompleted: boolean = false;
private buffer: Observable<any>[] = [];
private active: number = 0;
protected index: number = 0;
constructor(destination: Subscriber<R>,
private accumulator: (acc: R, value: T) => ObservableInput<R>,
private acc: R,
private concurrent: number) {
super(destination);
}
protected _next(value: any): void {
if (this.active < this.concurrent) {
const index = this.index++;
const ish = tryCatch(this.accumulator)(this.acc, value);
const destination = this.destination;
if (ish === errorObject) {
destination.error(errorObject.e);
} else {
this.active++;
this._innerSub(ish, value, index);
}
} else {
this.buffer.push(value);
}
}
private _innerSub(ish: any, value: T, index: number): void {
const innerSubscriber = new InnerSubscriber(this, undefined, undefined);
const destination = this.destination as Subscription;
destination.add(innerSubscriber);
subscribeToResult<T, R>(this, ish, value, index, innerSubscriber);
}
protected _complete(): void {
this.hasCompleted = true;
if (this.active === 0 && this.buffer.length === 0) {
if (this.hasValue === false) {
this.destination.next(this.acc);
}
this.destination.complete();
}
this.unsubscribe();
}
notifyNext(outerValue: T, innerValue: R,
outerIndex: number, innerIndex: number,
innerSub: InnerSubscriber<T, R>): void {
const { destination } = this;
this.acc = innerValue;
this.hasValue = true;
destination.next(innerValue);
}
notifyComplete(innerSub: Subscription): void {
const buffer = this.buffer;
const destination = this.destination as Subscription;
destination.remove(innerSub);
this.active--;
if (buffer.length > 0) {
this._next(buffer.shift());
} else if (this.active === 0 && this.hasCompleted) {
if (this.hasValue === false) {
this.destination.next(this.acc);
}
this.destination.complete();
}
}
}
``` | /content/code_sandbox/deps/node-10.15.3/tools/node_modules/eslint/node_modules/rxjs/src/internal/operators/mergeScan.ts | xml | 2016-09-05T10:18:44 | 2024-08-11T13:21:40 | LiquidCore | LiquidPlayer/LiquidCore | 1,010 | 1,078 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<!--
~ Nextcloud - Android Client
~
-->
<menu xmlns:android="path_to_url"
xmlns:app="path_to_url"
xmlns:tools="path_to_url"
tools:ignore="AppCompatResource">
<item
android:id="@+id/etm_preferences_share"
android:title="@string/common_share"
app:showAsAction="ifRoom"
android:showAsAction="ifRoom"
android:icon="@drawable/ic_share" />
</menu>
``` | /content/code_sandbox/app/src/main/res/menu/fragment_etm_preferences.xml | xml | 2016-06-06T21:23:36 | 2024-08-16T18:22:36 | android | nextcloud/android | 4,122 | 122 |
```xml
import { Entity } from "../../../../../../../src/decorator/entity/Entity"
import { PrimaryGeneratedColumn } from "../../../../../../../src/decorator/columns/PrimaryGeneratedColumn"
import { Column } from "../../../../../../../src/decorator/columns/Column"
import { ManyToOne } from "../../../../../../../src/decorator/relations/ManyToOne"
import { Category } from "./Category"
@Entity()
export class Image {
@PrimaryGeneratedColumn()
id: number
@Column()
name: string
@ManyToOne((type) => Category, (category) => category.images)
category: Category
categoryId: number
}
``` | /content/code_sandbox/test/functional/query-builder/relation-id/one-to-many/basic-functionality/entity/Image.ts | xml | 2016-02-29T07:41:14 | 2024-08-16T18:28:52 | typeorm | typeorm/typeorm | 33,875 | 130 |
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!--
*** GENERATED FROM project.xml - DO NOT EDIT ***
*** EDIT ../build.xml INSTEAD ***
-->
<project name="org.graalvm.visualvm.hostremote-impl" basedir="..">
<property file="nbproject/private/suite-private.properties"/>
<property file="nbproject/suite.properties"/>
<fail unless="suite.dir">You must set 'suite.dir' to point to your containing module suite</fail>
<property file="${suite.dir}/nbproject/private/platform-private.properties"/>
<property file="${suite.dir}/nbproject/platform.properties"/>
<macrodef name="property" uri="path_to_url">
<attribute name="name"/>
<attribute name="value"/>
<sequential>
<property name="@{name}" value="${@{value}}"/>
</sequential>
</macrodef>
<property file="${user.properties.file}"/>
<nbmproject2:property name="harness.dir" value="nbplatform.${nbplatform.active}.harness.dir" xmlns:nbmproject2="path_to_url"/>
<nbmproject2:property name="netbeans.dest.dir" value="nbplatform.${nbplatform.active}.netbeans.dest.dir" xmlns:nbmproject2="path_to_url"/>
<fail message="You must define 'nbplatform.${nbplatform.active}.harness.dir'">
<condition>
<not>
<available file="${harness.dir}" type="dir"/>
</not>
</condition>
</fail>
<import file="${harness.dir}/build.xml"/>
</project>
``` | /content/code_sandbox/visualvm/hostremote/nbproject/build-impl.xml | xml | 2016-09-12T14:44:30 | 2024-08-16T14:41:50 | visualvm | oracle/visualvm | 2,821 | 349 |
```xml
import * as Blockly from "blockly";
import { WorkspaceSearch } from "@blockly/plugin-workspace-search";
export class PxtWorkspaceSearch extends WorkspaceSearch {
protected injectionDiv: Element;
protected inputElement_: HTMLInputElement;
constructor(workspace: Blockly.WorkspaceSvg) {
super(workspace);
this.injectionDiv = workspace.getInjectionDiv();
}
protected override highlightSearchGroup(blocks: Blockly.BlockSvg[]) {
blocks.forEach((block) => {
const blockPath = block.pathObject.svgPath;
Blockly.utils.dom.addClass(blockPath, 'blockly-ws-search-highlight-pxt');
});
}
protected override unhighlightSearchGroup(blocks: Blockly.BlockSvg[]) {
blocks.forEach((block) => {
const blockPath = block.pathObject.svgPath;
Blockly.utils.dom.removeClass(blockPath, 'blockly-ws-search-highlight-pxt');
});
}
override open() {
super.open();
Blockly.utils.dom.addClass(this.injectionDiv, 'blockly-ws-searching');
}
override close() {
super.close();
Blockly.utils.dom.removeClass(this.injectionDiv, 'blockly-ws-searching');
}
}
``` | /content/code_sandbox/pxtblocks/workspaceSearch.ts | xml | 2016-01-24T19:35:52 | 2024-08-16T16:39:39 | pxt | microsoft/pxt | 2,069 | 246 |
```xml
<?xml version="1.0" encoding="UTF-8"?>
<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" version="1.2">
<file source-language="en" target-language="zh-Hant" datatype="plaintext" original="invoice-renderer.en.xlf">
<body>
<trans-unit id="lt2Y2LO" resname="timesheet" xml:space="preserve" approved="yes">
<source>timesheet</source>
<target state="final"></target>
</trans-unit>
<trans-unit id="N6juwc4" resname="default" xml:space="preserve" approved="yes">
<source>Invoice</source>
<target state="final"></target>
</trans-unit>
<trans-unit id="E5BwZHT" resname="programmatic" xml:space="preserve" approved="yes">
<source>programmatic</source>
<target state="final"></target>
</trans-unit>
<trans-unit id="Utbj3k_" resname="invoice" xml:space="preserve" approved="yes">
<source>invoice</source>
<target state="final"></target>
</trans-unit>
<trans-unit id="hOcTt2G" resname="invoice_renderer" xml:space="preserve" approved="yes">
<source>invoice_renderer</source>
<target state="final"></target>
</trans-unit>
<trans-unit id="7mEUv6C" resname="help.upload" xml:space="preserve" approved="yes">
<source>help.upload</source>
<target state="final">%extensions%</target>
</trans-unit>
<trans-unit id="mC2ePrm" resname="text" xml:space="preserve" approved="yes">
<source>text</source>
<target state="final"></target>
</trans-unit>
<trans-unit id="m1UyfD9" resname="service-date" approved="yes" xml:space="preserve">
<source>Single service date</source>
<target state="final"></target>
</trans-unit>
<trans-unit id="22pt8Gs" resname="download_invoice_renderer" xml:space="preserve" approved="yes">
<source>download_invoice_renderer</source>
<target state="final"></target>
</trans-unit>
</body>
</file>
</xliff>
``` | /content/code_sandbox/translations/invoice-renderer.zh_Hant.xlf | xml | 2016-10-20T17:06:34 | 2024-08-16T18:27:30 | kimai | kimai/kimai | 3,084 | 551 |
```xml
import { defineUntypedSchema } from 'untyped'
import { template as loadingTemplate } from '../../../ui-templates/dist/templates/loading'
export default defineUntypedSchema({
devServer: {
/**
* Whether to enable HTTPS.
* @example
* ```ts
* export default defineNuxtConfig({
* devServer: {
* https: {
* key: './server.key',
* cert: './server.crt'
* }
* }
* })
* ```
* @type {boolean | { key: string; cert: string }}
*/
https: false,
/** Dev server listening port */
port: process.env.NUXT_PORT || process.env.NITRO_PORT || process.env.PORT || 3000,
/** Dev server listening host */
host: process.env.NUXT_HOST || process.env.NITRO_HOST || process.env.HOST || undefined,
/**
* Listening dev server URL.
*
* This should not be set directly as it will always be overridden by the
* dev server with the full URL (for module and internal use).
*/
url: 'path_to_url
/**
* Template to show a loading screen
* @type {(data: { loading?: string }) => string}
*/
loadingTemplate,
},
})
``` | /content/code_sandbox/packages/schema/src/config/dev.ts | xml | 2016-10-26T11:18:47 | 2024-08-16T19:32:46 | nuxt | nuxt/nuxt | 53,705 | 288 |
```xml
import { NgModule } from '@angular/core';
import { IonicPageModule } from 'ionic-angular';
import { ModalWithNavigationPage } from './modal-with-navigation';
@NgModule({
declarations: [
ModalWithNavigationPage,
],
imports: [
IonicPageModule.forChild(ModalWithNavigationPage),
],
exports: [
ModalWithNavigationPage
]
})
export class ModalWithNavigationPageModule {}
``` | /content/code_sandbox/src/pages/modal-with-navigation/modal-with-navigation.module.ts | xml | 2016-11-04T05:48:23 | 2024-08-03T05:22:54 | ionic3-components | yannbf/ionic3-components | 1,679 | 84 |
```xml
<vector xmlns:android="path_to_url"
android:width="24dp"
android:height="24dp"
android:viewportWidth="24.0"
android:viewportHeight="24.0">
<path
android:fillColor="#4141ba"
android:pathData="M19,4L5,4c-1.11,0 -2,0.9 -2,2v12c0,1.1 0.89,2 2,2h4v-2L5,18L5,8h14v10h-4v2h4c1.1,0 2,-0.9 2,-2L21,6c0,-1.1 -0.89,-2 -2,-2zM12,10l-4,4h3v6h2v-6h3l-4,-4z"/>
</vector>
``` | /content/code_sandbox/app/src/main/res/drawable/ic_open_in_browser_primary_24dp.xml | xml | 2016-07-02T10:44:04 | 2024-08-16T18:55:54 | StreetComplete | streetcomplete/StreetComplete | 3,781 | 198 |
```xml
import { color, typography } from '../base';
import type { ThemeVars } from '../types';
const theme: ThemeVars = {
base: 'dark',
// Storybook-specific color palette
colorPrimary: '#FF4785', // coral
colorSecondary: '#029CFD', // ocean
// UI
appBg: '#222425',
appContentBg: '#1B1C1D',
appPreviewBg: color.lightest,
appBorderColor: 'rgba(255,255,255,.1)',
appBorderRadius: 4,
// Fonts
fontBase: typography.fonts.base,
fontCode: typography.fonts.mono,
// Text colors
textColor: '#C9CDCF',
textInverseColor: '#222425',
textMutedColor: '#798186',
// Toolbar default and active colors
barTextColor: color.mediumdark,
barHoverColor: color.secondary,
barSelectedColor: color.secondary,
barBg: '#292C2E',
// Form colors
buttonBg: '#222425',
buttonBorder: 'rgba(255,255,255,.1)',
booleanBg: '#222425',
booleanSelectedBg: '#2E3438',
inputBg: '#1B1C1D',
inputBorder: 'rgba(255,255,255,.1)',
inputTextColor: color.lightest,
inputBorderRadius: 4,
};
export default theme;
``` | /content/code_sandbox/code/core/src/theming/themes/dark.ts | xml | 2016-03-18T04:23:44 | 2024-08-16T19:22:08 | storybook | storybookjs/storybook | 83,755 | 316 |
```xml
// luma.gl
const uidCounters: Record<string, number> = {};
/**
* Returns a UID.
* @param id= - Identifier base name
* @return uid
**/
export function uid(id: string = 'id'): string {
uidCounters[id] = uidCounters[id] || 1;
const count = uidCounters[id]++;
return `${id}-${count}`;
}
``` | /content/code_sandbox/modules/webgl/src/utils/uid.ts | xml | 2016-01-25T09:41:59 | 2024-08-16T10:03:05 | luma.gl | visgl/luma.gl | 2,280 | 85 |
```xml
import { IdentityApi } from "../api/identity.api";
export class IdentityData {
title: string;
firstName: string;
middleName: string;
lastName: string;
address1: string;
address2: string;
address3: string;
city: string;
state: string;
postalCode: string;
country: string;
company: string;
email: string;
phone: string;
ssn: string;
username: string;
passportNumber: string;
licenseNumber: string;
constructor(data?: IdentityApi) {
if (data == null) {
return;
}
this.title = data.title;
this.firstName = data.firstName;
this.middleName = data.middleName;
this.lastName = data.lastName;
this.address1 = data.address1;
this.address2 = data.address2;
this.address3 = data.address3;
this.city = data.city;
this.state = data.state;
this.postalCode = data.postalCode;
this.country = data.country;
this.company = data.company;
this.email = data.email;
this.phone = data.phone;
this.ssn = data.ssn;
this.username = data.username;
this.passportNumber = data.passportNumber;
this.licenseNumber = data.licenseNumber;
}
}
``` | /content/code_sandbox/libs/common/src/vault/models/data/identity.data.ts | xml | 2016-03-09T23:14:01 | 2024-08-16T15:07:51 | clients | bitwarden/clients | 8,877 | 288 |
```xml
import * as React from 'react';
import clsx from 'clsx';
import TextField, { TextFieldProps } from '@mui/material/TextField';
import { useInput, FieldTitle, mergeRefs } from 'ra-core';
import { CommonInputProps } from './CommonInputProps';
import { sanitizeInputRestProps } from './sanitizeInputRestProps';
import { InputHelperText } from './InputHelperText';
/**
* Converts a datetime string without timezone to a date object
* with timezone, using the browser timezone.
*
* @param {string} value Date string, formatted as yyyy-MM-ddThh:mm
* @return {Date}
*/
const parseDateTime = (value: string) =>
value ? new Date(value) : value === '' ? null : value;
/**
* Input component for entering a date and a time with timezone, using the browser locale
*/
export const DateTimeInput = ({
className,
defaultValue,
format = formatDateTime,
label,
helperText,
margin,
onBlur,
onChange,
onFocus,
source,
resource,
parse = parseDateTime,
validate,
variant,
disabled,
readOnly,
...rest
}: DateTimeInputProps) => {
const { field, fieldState, id, isRequired } = useInput({
defaultValue,
onBlur,
resource,
source,
validate,
disabled,
readOnly,
...rest,
});
const [renderCount, setRenderCount] = React.useState(1);
const valueChangedFromInput = React.useRef(false);
const localInputRef = React.useRef<HTMLInputElement>();
const initialDefaultValueRef = React.useRef(field.value);
React.useEffect(() => {
const initialDateValue =
new Date(initialDefaultValueRef.current).getTime() || null;
const fieldDateValue = new Date(field.value).getTime() || null;
if (
initialDateValue !== fieldDateValue &&
!valueChangedFromInput.current
) {
setRenderCount(r => r + 1);
parse
? field.onChange(parse(field.value))
: field.onChange(field.value);
initialDefaultValueRef.current = field.value;
valueChangedFromInput.current = false;
}
}, [setRenderCount, parse, field]);
const { onBlur: onBlurFromField } = field;
const hasFocus = React.useRef(false);
// update the input text when the user types in the input
const handleChange = (event: React.ChangeEvent<HTMLInputElement>) => {
if (onChange) {
onChange(event);
}
if (
typeof event.target === 'undefined' ||
typeof event.target.value === 'undefined'
) {
return;
}
const target = event.target;
const newValue =
target.valueAsDate !== undefined &&
target.valueAsDate !== null &&
!isNaN(new Date(target.valueAsDate).getTime())
? parse
? parse(target.valueAsDate)
: target.valueAsDate
: parse
? parse(target.value)
: formatDateTime(target.value);
// Some browsers will return null for an invalid date so we only change react-hook-form value if it's not null
// The input reset is handled in the onBlur event handler
if (newValue !== '' && newValue != null) {
field.onChange(newValue);
valueChangedFromInput.current = true;
}
};
const handleFocus = (event: React.FocusEvent<HTMLInputElement>) => {
if (onFocus) {
onFocus(event);
}
hasFocus.current = true;
};
const handleBlur = () => {
hasFocus.current = false;
if (!localInputRef.current) {
return;
}
// To ensure users can clear the input, we check its value on blur
// and submit it to react-hook-form
const newValue =
localInputRef.current.valueAsDate !== undefined &&
localInputRef.current.valueAsDate !== null &&
!isNaN(new Date(localInputRef.current.valueAsDate).getTime())
? parse
? parse(localInputRef.current.valueAsDate)
: formatDateTime(localInputRef.current.valueAsDate)
: parse
? parse(localInputRef.current.value)
: formatDateTime(localInputRef.current.value);
if (newValue !== field.value) {
field.onChange(newValue ?? '');
}
if (onBlurFromField) {
onBlurFromField();
}
};
const { error, invalid } = fieldState;
const renderHelperText = helperText !== false || invalid;
const { ref, name } = field;
const inputRef = mergeRefs([ref, localInputRef]);
return (
<TextField
id={id}
inputRef={inputRef}
name={name}
defaultValue={format(initialDefaultValueRef.current)}
key={renderCount}
type="datetime-local"
onChange={handleChange}
onFocus={handleFocus}
onBlur={handleBlur}
className={clsx('ra-input', `ra-input-${source}`, className)}
size="small"
variant={variant}
margin={margin}
error={invalid}
disabled={disabled || readOnly}
readOnly={readOnly}
helperText={
renderHelperText ? (
<InputHelperText
error={error?.message}
helperText={helperText}
/>
) : null
}
label={
<FieldTitle
label={label}
source={source}
resource={resource}
isRequired={isRequired}
/>
}
InputLabelProps={defaultInputLabelProps}
{...sanitizeInputRestProps(rest)}
/>
);
};
export type DateTimeInputProps = CommonInputProps &
Omit<TextFieldProps, 'helperText' | 'label'>;
const leftPad =
(nb = 2) =>
value =>
('0'.repeat(nb) + value).slice(-nb);
const leftPad4 = leftPad(4);
const leftPad2 = leftPad(2);
/**
* @param {Date} value value to convert
* @returns {String} A standardized datetime (yyyy-MM-ddThh:mm), to be passed to an <input type="datetime-local" />
*/
const convertDateToString = (value: Date) => {
if (!(value instanceof Date) || isNaN(value.getDate())) return '';
const yyyy = leftPad4(value.getFullYear());
const MM = leftPad2(value.getMonth() + 1);
const dd = leftPad2(value.getDate());
const hh = leftPad2(value.getHours());
const mm = leftPad2(value.getMinutes());
return `${yyyy}-${MM}-${dd}T${hh}:${mm}`;
};
// yyyy-MM-ddThh:mm
const dateTimeRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/;
const defaultInputLabelProps = { shrink: true };
/**
* Converts a date from the dataProvider, with timezone, to a date string
* without timezone for use in an <input type="datetime-local" />.
*
* @param {Date | String} value date string or object
*/
const formatDateTime = (value: string | Date) => {
// null, undefined and empty string values should not go through convertDateToString
// otherwise, it returns undefined and will make the input an uncontrolled one.
if (value == null || value === '') {
return '';
}
if (value instanceof Date) {
return convertDateToString(value);
}
// valid dates should not be converted
if (dateTimeRegex.test(value)) {
return value;
}
return convertDateToString(new Date(value));
};
``` | /content/code_sandbox/packages/ra-ui-materialui/src/input/DateTimeInput.tsx | xml | 2016-07-13T07:58:54 | 2024-08-16T18:32:27 | react-admin | marmelab/react-admin | 24,624 | 1,604 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net$(BundledNETCoreAppTargetFrameworkVersion)-ios</TargetFramework>
<RuntimeIdentifier>iossimulator-x64</RuntimeIdentifier>
<OutputType>Exe</OutputType>
<CustomBeforeMicrosoftCommonTargets>$(CustomBeforeMicrosoftCommonTargets);$(MSBuildThisFileDirectory)../../SupportedOSPlatformVersions.targets</CustomBeforeMicrosoftCommonTargets>
<LangVersion>latest</LangVersion>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\MyPhotoEditingExtension\MyPhotoEditingExtension.dotnet.csproj">
<IsAppExtension>True</IsAppExtension>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<None Remove="Info.plist" />
<None Update="Info-dotnet.plist" Link="Info.plist" />
</ItemGroup>
</Project>
``` | /content/code_sandbox/tests/common/TestProjects/MySpriteKitGame/MySpriteKitGame.dotnet.csproj | xml | 2016-04-20T18:24:26 | 2024-08-16T13:29:19 | xamarin-macios | xamarin/xamarin-macios | 2,436 | 211 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="path_to_url">
<ItemGroup>
<Filter Include="tutorials">
<UniqueIdentifier>{CCD2FA77-35F5-BA43-B809-8BFB7B53DAA1}</UniqueIdentifier>
</Filter>
<Filter Include="tutorials\tutorial_3">
<UniqueIdentifier>{5555518B-8AF2-D54C-BAC5-4E63D6F2886E}</UniqueIdentifier>
</Filter>
<Filter Include="tutorials\tutorial_3\cpp">
<UniqueIdentifier>{870B113F-6703-0047-8394-681E91AED8EB}</UniqueIdentifier>
</Filter>
<Filter Include="tutorials\tutorial_3\cpp\behaviac_generated">
<UniqueIdentifier>{48408BEA-C7A8-3D40-B39C-BEDAAF639A2F}</UniqueIdentifier>
</Filter>
<Filter Include="tutorials\tutorial_3\cpp\behaviac_generated\types">
<UniqueIdentifier>{2C48F076-0D73-F448-8DC2-1C561B0BAA47}</UniqueIdentifier>
</Filter>
<Filter Include="tutorials\tutorial_3\cpp\behaviac_generated\types\internal">
<UniqueIdentifier>{C18D4BA5-4D12-1044-97B6-036EA14A26DE}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\tutorials\tutorial_3\cpp\behaviac_generated\types\behaviac_types.h">
<Filter>tutorials\tutorial_3\cpp\behaviac_generated\types</Filter>
</ClInclude>
<ClInclude Include="..\..\tutorials\tutorial_3\cpp\behaviac_generated\types\internal\behaviac_agent_headers.h">
<Filter>tutorials\tutorial_3\cpp\behaviac_generated\types\internal</Filter>
</ClInclude>
<ClInclude Include="..\..\tutorials\tutorial_3\cpp\behaviac_generated\types\internal\behaviac_agent_member_visitor.h">
<Filter>tutorials\tutorial_3\cpp\behaviac_generated\types\internal</Filter>
</ClInclude>
<ClInclude Include="..\..\tutorials\tutorial_3\cpp\behaviac_generated\types\internal\behaviac_agent_meta.h">
<Filter>tutorials\tutorial_3\cpp\behaviac_generated\types\internal</Filter>
</ClInclude>
<ClInclude Include="..\..\tutorials\tutorial_3\cpp\behaviac_generated\types\internal\behaviac_headers.h">
<Filter>tutorials\tutorial_3\cpp\behaviac_generated\types\internal</Filter>
</ClInclude>
<ClInclude Include="..\..\tutorials\tutorial_3\cpp\behaviac_generated\types\internal\FirstAgent.h">
<Filter>tutorials\tutorial_3\cpp\behaviac_generated\types\internal</Filter>
</ClInclude>
<ClInclude Include="..\..\tutorials\tutorial_3\cpp\behaviac_generated\types\internal\SecondAgent.h">
<Filter>tutorials\tutorial_3\cpp\behaviac_generated\types\internal</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\tutorials\tutorial_3\cpp\tutorial_3.cpp">
<Filter>tutorials\tutorial_3\cpp</Filter>
</ClCompile>
<ClCompile Include="..\..\tutorials\tutorial_3\cpp\behaviac_generated\types\internal\behaviac_agent_meta.cpp">
<Filter>tutorials\tutorial_3\cpp\behaviac_generated\types\internal</Filter>
</ClCompile>
<ClCompile Include="..\..\tutorials\tutorial_3\cpp\behaviac_generated\types\internal\FirstAgent.cpp">
<Filter>tutorials\tutorial_3\cpp\behaviac_generated\types\internal</Filter>
</ClCompile>
<ClCompile Include="..\..\tutorials\tutorial_3\cpp\behaviac_generated\types\internal\SecondAgent.cpp">
<Filter>tutorials\tutorial_3\cpp\behaviac_generated\types\internal</Filter>
</ClCompile>
</ItemGroup>
</Project>
``` | /content/code_sandbox/projects/vs2013/tutorial_3.vcxproj.filters | xml | 2016-11-21T05:08:08 | 2024-08-16T07:18:30 | behaviac | Tencent/behaviac | 2,831 | 1,010 |
```xml
<Controls:MetroWindow
x:Class="Certify.UI.Windows.ImportExport"
xmlns="path_to_url"
xmlns:x="path_to_url"
xmlns:Controls="clr-namespace:MahApps.Metro.Controls;assembly=MahApps.Metro"
xmlns:d="path_to_url"
xmlns:local="clr-namespace:Certify.UI.Windows"
xmlns:mc="path_to_url"
Title="Import or Export Settings"
Width="800"
Height="740"
TitleCharacterCasing="Normal"
WindowStartupLocation="CenterOwner"
WindowTransitionsEnabled="False"
mc:Ignorable="d">
<DockPanel Margin="16" LastChildFill="true">
<StackPanel DockPanel.Dock="Top" Orientation="Vertical">
<TextBlock DockPanel.Dock="Top" Style="{StaticResource Subheading}">Import/Export Settings</TextBlock>
<TextBlock HorizontalAlignment="Left" Style="{StaticResource Instructions}">"{x:Static properties:SR.Settings_Export_Intro}"</TextBlock>
<TextBlock HorizontalAlignment="Left" Style="{StaticResource Instructions}">To import or export, you should specify a password to use for encryption/decryption:</TextBlock>
<PasswordBox
x:Name="txtSecret"
Width="200"
HorizontalAlignment="Left"
Controls:TextBoxHelper.Watermark="Password" />
</StackPanel>
<TabControl
x:Name="GeneralSettingsTab"
Height="auto"
Margin="0,8,0,0"
HorizontalContentAlignment="Left"
VerticalContentAlignment="Stretch"
Controls:TabControlHelper.UnderlineBrush="{DynamicResource MahApps.Brushes.Accent4}"
Controls:TabControlHelper.Underlined="TabPanel"
DockPanel.Dock="Top"
TabStripPlacement="Top">
<TabItem
Height="32"
MinWidth="140"
Controls:HeaderedControlHelper.HeaderFontSize="12"
Header="Export Settings"
IsSelected="true">
<StackPanel DockPanel.Dock="Top" Orientation="Vertical">
<TextBlock DockPanel.Dock="Top" Style="{StaticResource Instructions}">Export a settings bundle including managed certificate settings, certificate files and encrypted credentials.</TextBlock>
<Button
x:Name="Export"
Width="120"
HorizontalAlignment="Left"
Click="Export_Click"
DockPanel.Dock="Top">
Export..
</Button>
</StackPanel>
</TabItem>
<TabItem
Height="32"
MinWidth="140"
Controls:HeaderedControlHelper.HeaderFontSize="12"
Header="Import Settings">
<StackPanel Margin="0,16,0,0" Orientation="Vertical">
<TextBlock DockPanel.Dock="Top" Style="{StaticResource Instructions}">Import a settings bundle exported from another instance of the app.</TextBlock>
<CheckBox
x:Name="OverwriteExisting"
Margin="0,4,4,4"
Content="Overwrite Existing"
DockPanel.Dock="Top" />
<CheckBox
x:Name="IncludeDeployment"
Margin="0,4,4,4"
Content="Include Standard Certificate Storage and Auto Deployment"
DockPanel.Dock="Top"
IsChecked="True" />
<StackPanel DockPanel.Dock="Top" Orientation="Horizontal">
<Button
x:Name="Import"
Width="120"
HorizontalAlignment="Left"
Click="Import_Click"
DockPanel.Dock="Top">
Preview Import..
</Button>
<Button
x:Name="CompleteImport"
Width="120"
Margin="16,0,0,0"
HorizontalAlignment="Left"
Click="CompleteImport_Click"
DockPanel.Dock="Bottom"
Visibility="{Binding IsImportReady, Converter={StaticResource ResourceKey=BoolToVisConverter}}">
Complete Import
</Button>
</StackPanel>
<Controls:MetroProgressBar
Width="250"
Height="32"
Margin="4"
HorizontalAlignment="Left"
DockPanel.Dock="Top"
IsIndeterminate="True"
Visibility="{Binding InProgress, Converter={StaticResource ResourceKey=BoolToVisConverter}}" />
<DockPanel
DockPanel.Dock="Top"
LastChildFill="False"
Visibility="{Binding IsPreviewReady, Converter={StaticResource ResourceKey=BoolToVisConverter}}">
<WebBrowser
x:Name="MarkdownView"
Margin="0,16,0,0"
DockPanel.Dock="Top" />
</DockPanel>
</StackPanel>
</TabItem>
</TabControl>
</DockPanel>
</Controls:MetroWindow>
``` | /content/code_sandbox/src/Certify.UI.Shared/Windows/ImportExport.xaml | xml | 2016-03-27T07:05:15 | 2024-08-15T05:08:45 | certify | webprofusion/certify | 1,471 | 1,002 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="path_to_url">
<item android:drawable="@mipmap/bg_room_red"></item>
<item>
<inset
android:insetLeft="-10px"
android:insetRight="-10px">
<shape xmlns:android="path_to_url">
<stroke
android:width="1px"
android:color="#E7E7E7" />
</shape>
</inset>
</item>
</layer-list>
``` | /content/code_sandbox/app/src/main/res/drawable/bg_room_red_begin_with_stroke.xml | xml | 2016-11-28T06:41:44 | 2024-07-02T03:09:32 | ScrollablePanel | Kelin-Hong/ScrollablePanel | 2,079 | 123 |
```xml
import { ElementUIComponent } from './component'
/** Main Component */
export declare class ElMain extends ElementUIComponent {}
``` | /content/code_sandbox/types/main.d.ts | xml | 2016-09-03T06:19:26 | 2024-08-16T02:26:18 | element | ElemeFE/element | 54,066 | 25 |
```xml
import { buildResourceItem } from '../Resources';
import { setStringItem } from '../Strings';
describe(setStringItem, () => {
it('add item from empty xml', () => {
const results = setStringItem([buildResourceItem({ name: 'foo', value: 'foo' })], {
resources: {},
});
expect(results).toEqual({
resources: { string: [{ $: { name: 'foo' }, _: 'foo' }] },
});
});
it('support adding multiple items', () => {
const results = setStringItem(
[
buildResourceItem({ name: 'foo', value: 'foo' }),
buildResourceItem({ name: 'bar', value: 'bar' }),
],
{
resources: {},
}
);
expect(results).toEqual({
resources: {
string: [
{ $: { name: 'foo' }, _: 'foo' },
{ $: { name: 'bar' }, _: 'bar' },
],
},
});
});
it('override existing item', () => {
const results = setStringItem(
[buildResourceItem({ name: 'foo', value: 'bar', translatable: false })],
{
resources: { string: [{ $: { name: 'foo' }, _: 'foo' }] },
}
);
expect(results).toEqual({
resources: { string: [{ $: { name: 'foo', translatable: 'false' }, _: 'bar' }] },
});
});
});
``` | /content/code_sandbox/packages/@expo/config-plugins/src/android/__tests__/Strings-test.ts | xml | 2016-08-15T17:14:25 | 2024-08-16T19:54:44 | expo | expo/expo | 32,004 | 330 |
```xml
import { Injectable } from '@angular/core';
import { of as observableOf, Observable } from 'rxjs';
import { PeriodsService } from './periods.service';
import { OutlineData, VisitorsAnalyticsData } from '../data/visitors-analytics';
@Injectable()
export class VisitorsAnalyticsService extends VisitorsAnalyticsData {
constructor(private periodService: PeriodsService) {
super();
}
private pieChartValue = 75;
private innerLinePoints: number[] = [
94, 188, 225, 244, 253, 254, 249, 235, 208,
173, 141, 118, 105, 97, 94, 96, 104, 121, 147,
183, 224, 265, 302, 333, 358, 375, 388, 395,
400, 400, 397, 390, 377, 360, 338, 310, 278,
241, 204, 166, 130, 98, 71, 49, 32, 20, 13, 9,
];
private outerLinePoints: number[] = [
85, 71, 59, 50, 45, 42, 41, 44 , 58, 88,
136 , 199, 267, 326, 367, 391, 400, 397,
376, 319, 200, 104, 60, 41, 36, 37, 44,
55, 74, 100 , 131, 159, 180, 193, 199, 200,
195, 184, 164, 135, 103, 73, 50, 33, 22, 15, 11,
];
private generateOutlineLineData(): OutlineData[] {
const months = this.periodService.getMonths();
const outerLinePointsLength = this.outerLinePoints.length;
const monthsLength = months.length;
return this.outerLinePoints.map((p, index) => {
const monthIndex = Math.round(index / 4);
const label = (index % Math.round(outerLinePointsLength / monthsLength) === 0)
? months[monthIndex]
: '';
return {
label,
value: p,
};
});
}
getInnerLineChartData(): Observable<number[]> {
return observableOf(this.innerLinePoints);
}
getOutlineLineChartData(): Observable<OutlineData[]> {
return observableOf(this.generateOutlineLineData());
}
getPieChartData(): Observable<number> {
return observableOf(this.pieChartValue);
}
}
``` | /content/code_sandbox/src/app/@core/mock/visitors-analytics.service.ts | xml | 2016-05-25T10:09:03 | 2024-08-16T16:34:03 | ngx-admin | akveo/ngx-admin | 25,169 | 592 |
```xml
const Handlebars = require('handlebars');
import * as path from 'path';
import { decode } from 'html-entities';
import { MAX_SIZE_FILE_CHEERIO_PARSING, MAX_SIZE_FILE_SEARCH_INDEX } from '../../utils/constants';
import { logger } from '../../utils/logger';
import Configuration from '../configuration';
import FileEngine from './file.engine';
const lunr: any = require('lunr');
const cheerio: any = require('cheerio');
export class SearchEngine {
public searchIndex: any;
private searchDocuments = [];
public documentsStore: Object = {};
public indexSize: number;
public amountOfMemory = 0;
private static instance: SearchEngine;
private constructor() {}
public static getInstance() {
if (!SearchEngine.instance) {
SearchEngine.instance = new SearchEngine();
}
return SearchEngine.instance;
}
public indexPage(page) {
let text;
this.amountOfMemory += page.rawData.length;
if (this.amountOfMemory < MAX_SIZE_FILE_CHEERIO_PARSING) {
let indexStartContent = page.rawData.indexOf('<!-- START CONTENT -->');
let indexEndContent = page.rawData.indexOf('<!-- END CONTENT -->');
let $ = cheerio.load(page.rawData.substring(indexStartContent + 1, indexEndContent));
text = $('.content').html();
text = decode(text);
text = text.replace(/(<([^>]+)>)/gi, '');
page.url = page.url.replace(Configuration.mainData.output, '');
let doc = {
url: page.url,
title: page.infos.context + ' - ' + page.infos.name,
body: text
};
if (
!this.documentsStore.hasOwnProperty(doc.url) &&
doc.body.length < MAX_SIZE_FILE_SEARCH_INDEX
) {
this.documentsStore[doc.url] = doc;
this.searchDocuments.push(doc);
}
}
}
public generateSearchIndexJson(outputFolder: string): Promise<void> {
let that = this;
let searchIndex = lunr(function () {
/* tslint:disable:no-invalid-this */
this.ref('url');
this.field('title');
this.field('body');
this.pipeline.remove(lunr.stemmer);
let i = 0;
let len = that.searchDocuments.length;
for (i; i < len; i++) {
this.add(that.searchDocuments[i]);
}
});
return FileEngine.get(__dirname + '/../src/templates/partials/search-index.hbs').then(
data => {
let template: any = Handlebars.compile(data);
let result = template({
index: JSON.stringify(searchIndex),
store: JSON.stringify(this.documentsStore)
});
let testOutputDir = outputFolder.match(process.cwd());
if (testOutputDir && testOutputDir.length > 0) {
outputFolder = outputFolder.replace(process.cwd() + path.sep, '');
}
return FileEngine.write(
outputFolder + path.sep + '/js/search/search_index.js',
result
).catch(err => {
logger.error('Error during search index file generation ', err);
return Promise.reject(err);
});
},
err => Promise.reject('Error during search index generation')
);
}
}
export default SearchEngine.getInstance();
``` | /content/code_sandbox/src/app/engines/search.engine.ts | xml | 2016-10-17T07:09:28 | 2024-08-14T16:30:10 | compodoc | compodoc/compodoc | 3,980 | 697 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="path_to_url"
xmlns:app="path_to_url"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:orientation="vertical">
<com.kofigyan.stateprogressbar.StateProgressBar
android:id="@+id/state_progress_bar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
app:spb_currentStateNumber="four"
app:spb_maxStateNumber="five" />
</LinearLayout>
``` | /content/code_sandbox/sample/src/main/res/layout/activity_basic_five_states.xml | xml | 2016-08-16T12:50:30 | 2024-08-13T08:27:46 | StateProgressBar | kofigyan/StateProgressBar | 1,537 | 130 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS>
<TS version="2.1" language="en_US">
<context>
<name>QtGui::DevView</name>
<message>
<location filename="../gui/devview.cpp" line="60"/>
<source>Copy value</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/devview.cpp" line="66"/>
<source>Copy name</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/devview.cpp" line="69"/>
<source>Copy ID</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/devview.cpp" line="75"/>
<source>Resume</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/devview.cpp" line="80"/>
<source>Pause</source>
<translation type="unfinished"></translation>
</message>
</context>
<context>
<name>QtGui::DirView</name>
<message>
<location filename="../gui/dirview.cpp" line="77"/>
<source>Copy value</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/dirview.cpp" line="83"/>
<source>Copy label/ID</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/dirview.cpp" line="86"/>
<source>Copy path</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/dirview.cpp" line="91"/>
<source>Rescan</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/dirview.cpp" line="96"/>
<source>Resume</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/dirview.cpp" line="101"/>
<source>Pause</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/dirview.cpp" line="105"/>
<source>Open in file browser</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/dirview.cpp" line="109"/>
<source>Browse remote files</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/dirview.cpp" line="111"/>
<source>Show/edit ignore patterns</source>
<translation type="unfinished"></translation>
</message>
</context>
<context>
<name>QtGui::DownloadView</name>
<message>
<location filename="../gui/downloadview.cpp" line="65"/>
<source>Copy value</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/downloadview.cpp" line="70"/>
<source>Copy label/ID</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/downloadview.cpp" line="74"/>
<source>Open in file browser</source>
<translation type="unfinished"></translation>
</message>
</context>
<context>
<name>QtGui::TrayIcon</name>
<message>
<location filename="../gui/trayicon.cpp" line="54"/>
<source>Open Syncthing</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/trayicon.cpp" line="58"/>
<source>Settings</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/trayicon.cpp" line="62"/>
<source>Rescan all</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/trayicon.cpp" line="66"/>
<source>Log</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/trayicon.cpp" line="70"/>
<source>Show internal errors</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/trayicon.cpp" line="75"/>
<source>About</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/trayicon.cpp" line="80"/>
<source>Close</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/trayicon.cpp" line="214"/>
<source>Error</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/trayicon.cpp" line="234"/>
<source>Launcher error</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/trayicon.cpp" line="250"/>
<source>Syncthing notification - click to dismiss</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/trayicon.cpp" line="280"/>
<source>Syncthing device wants to connect - click for web UI</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/trayicon.cpp" line="296"/>
<source>New Syncthing folder - click for web UI</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/trayicon.cpp" line="175"/>
<source>Disconnected from Syncthing</source>
<translation type="unfinished"></translation>
</message>
</context>
<context>
<name>QtGui::TrayWidget</name>
<message>
<location filename="../gui/traywidget.ui" line="6"/>
<source>Syncthing Tray</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="99"/>
<location filename="../gui/traywidget.cpp" line="350"/>
<source>About</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="58"/>
<location filename="../gui/traywidget.cpp" line="479"/>
<source>Connect</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="72"/>
<location filename="../gui/traywidget.cpp" line="899"/>
<location filename="../gui/traywidget.cpp" line="941"/>
<source>Start</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="113"/>
<source>Settings</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="127"/>
<source>Open Syncthing</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="289"/>
<source>In</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="296"/>
<source>Incoming traffic</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="228"/>
<location filename="../gui/traywidget.ui" line="248"/>
<location filename="../gui/traywidget.ui" line="299"/>
<location filename="../gui/traywidget.ui" line="319"/>
<source>unknown</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="218"/>
<source>Global</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="225"/>
<source>Global overall statistics</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="235"/>
<source>Local</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="245"/>
<source>Local overall statistics</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="306"/>
<source>Out</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="316"/>
<source>Outgoing traffic</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="350"/>
<source>Click to show <i>new</i> notifications<br>
For <i>all</i> notifications, checkout the log</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="357"/>
<location filename="../gui/traywidget.cpp" line="160"/>
<location filename="../gui/traywidget.cpp" line="390"/>
<source>New notifications</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="388"/>
<source>Folders</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="421"/>
<source>Devices</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="454"/>
<source>Downloads</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="483"/>
<source>Recent changes</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="519"/>
<source>Show</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.ui" line="529"/>
<source>Dismiss</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="132"/>
<source>View own device ID</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="137"/>
<source>Restart Syncthing</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="142"/>
<source>Show Syncthing log</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="147"/>
<source>Rescan all folders</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="154"/>
<source>Connection</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="176"/>
<source>Show internal errors</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="191"/>
<source>Quit Syncthing Tray</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="447"/>
<source>Do you really want to restart Syncthing?</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="474"/>
<source>Connecting </source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="475"/>
<source>Establishing connection to Syncthing </source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="480"/>
<source>Not connected to Syncthing, click to connect</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="485"/>
<source>Unable to establish connection to Syncthing.</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="493"/>
<source>Pause</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="494"/>
<source>Syncthing is running, click to pause all devices</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="499"/>
<source>Continue</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="500"/>
<source>At least one device is paused, click to resume</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="625"/>
<source>The specified connection configuration <em>%1</em> is not defined and hence ignored.</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="696"/>
<source>The folder <i>%1</i> does not exist on the local machine.</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="707"/>
<source>The containing folder <i>%1</i> does not exist on the local machine.</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="760"/>
<source>Copy path</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="764"/>
<source>Copy device ID</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="767"/>
<source>Copy folder ID</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="895"/>
<location filename="../gui/traywidget.cpp" line="935"/>
<source>Stop</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="896"/>
<source>Stop Syncthing instance launched via tray icon</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../gui/traywidget.cpp" line="900"/>
<source>Start Syncthing with the built-in launcher configured in the settings</source>
<translation type="unfinished"></translation>
</message>
</context>
<context>
<name>main</name>
<message>
<location filename="../application/main.cpp" line="66"/>
<source>Unable to </source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../application/main.cpp" line="101"/>
<source>The system tray is (currently) not available. You could open the tray menu as a regular window using the --windowed flag, though.It is also possible to start Syncthing Tray with --wait to wait until the system tray becomes available instead of showing this message.</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../application/main.cpp" line="128"/>
<source>The Qt libraries have not been built with tray icon support. You could open the tray menu as a regular window using the -w flag, though.</source>
<translation type="unfinished"></translation>
</message>
</context>
</TS>
``` | /content/code_sandbox/tray/translations/syncthingtray_en_US.ts | xml | 2016-08-24T22:46:19 | 2024-08-16T13:39:56 | syncthingtray | Martchus/syncthingtray | 1,558 | 3,834 |
```xml
import {
CustomRangeContainer,
FilterBox,
FilterButton,
MenuFooter,
RightMenuContainer,
TabContent
} from "../styles/rightMenu";
import { DATERANGES, PRIORITIES } from "../constants";
import { TabTitle, Tabs } from "@erxes/ui/src/components/tabs";
import Archive from "./Archive";
import Button from "@erxes/ui/src/components/Button";
import ControlLabel from "@erxes/ui/src/components/form/Label";
import DateControl from "@erxes/ui/src/components/form/DateControl";
import FormControl from "@erxes/ui/src/components/form/Control";
import { IOption } from "@erxes/ui/src/types";
import { IOptions } from "../types";
import Icon from "@erxes/ui/src/components/Icon";
import React, { Fragment } from "react";
import SegmentFilter from "../containers/SegmentFilter";
import Select, { OnChangeValue } from "react-select";
import SelectBranches from "@erxes/ui/src/team/containers/SelectBranches";
import SelectDepartments from "@erxes/ui/src/team/containers/SelectDepartments";
import SelectLabel from "./label/SelectLabel";
import SelectTeamMembers from "@erxes/ui/src/team/containers/SelectTeamMembers";
import { __ } from "coreui/utils";
import dayjs from "dayjs";
import { isEnabled } from "@erxes/ui/src/utils/core";
import { Transition } from "@headlessui/react";
type Props = {
onSearch: (search: string) => void;
onSelect: (values: string[] | string, key: string) => void;
queryParams: any;
link: string;
extraFilter?: React.ReactNode;
options: IOptions;
isFiltered: boolean;
clearFilter: () => void;
};
type StringState = {
currentTab: string;
};
type State = {
showMenu: boolean;
dateRangeType: IOption | null;
dateRange: any;
} & StringState;
export default class RightMenu extends React.Component<Props, State> {
private wrapperRef;
constructor(props) {
super(props);
this.state = {
currentTab: "Filter",
dateRangeType: null,
showMenu: false,
dateRange: {} as any
};
this.setWrapperRef = this.setWrapperRef.bind(this);
this.handleClickOutside = this.handleClickOutside.bind(this);
}
setWrapperRef(node) {
this.wrapperRef = node;
}
componentDidMount() {
document.addEventListener("click", this.handleClickOutside, true);
}
componentWillUnmount() {
document.removeEventListener("click", this.handleClickOutside, true);
}
handleClickOutside = event => {
if (
this.wrapperRef &&
!this.wrapperRef.contains(event.target) &&
this.state.currentTab === "Filter"
) {
this.setState({ showMenu: false });
}
};
toggleMenu = () => {
this.setState({ showMenu: !this.state.showMenu });
};
onSearch = (e: React.KeyboardEvent<Element>) => {
if (e.key === "Enter") {
const target = e.currentTarget as HTMLInputElement;
this.props.onSearch(target.value || "");
}
};
onChange = (name: string, value: string) => {
this.setState({ [name]: value } as Pick<StringState, keyof StringState>);
};
onTypeChange = type => {
return this.setState({ dateRangeType: type }, () => {
switch (this.state.dateRangeType?.value) {
case "createdAt":
return this.setState({
dateRange: {
startDate: "createdStartDate",
endDate: "createdEndDate"
}
});
case "stageChangedDate":
return this.setState({
dateRange: {
startDate: "stateChangedStartDate",
endDate: "stateChangedEndDate"
}
});
case "startDate":
return this.setState({
dateRange: {
startDate: "startDateStartDate",
endDate: "startDateEndDate"
}
});
case "closeDate":
return this.setState({
dateRange: {
startDate: "closeDateStartDate",
endDate: "closeDateEndDate"
}
});
}
});
};
startDateValue = () => {
const { queryParams } = this.props;
if (queryParams.createdStartDate) {
return queryParams.createdStartDate;
}
if (queryParams.stateChangedStartDate) {
return queryParams.stateChangedStartDate;
}
if (queryParams.startDateStartDate) {
return queryParams.startDateStartDate;
}
if (queryParams.closeDateStartDate) {
return queryParams.closeDateStartDate;
}
};
endDateValue = () => {
const { queryParams } = this.props;
if (queryParams.createdEndDate) {
return queryParams.createdEndDate;
}
if (queryParams.stateChangedEndDate) {
return queryParams.stateChangedEndDate;
}
if (queryParams.startDateEndDate) {
return queryParams.startDateEndDate;
}
if (queryParams.closeDateEndDate) {
return queryParams.closeDateEndDate;
}
};
dateRangeType = () => {
const { queryParams } = this.props;
if (queryParams.createdStartDate || queryParams.createdEndDate) {
return { label: "Created date", value: "createdAt" };
}
if (queryParams.stateChangedStartDate || queryParams.stateChangedEndDate) {
return { label: "Stage changed date", value: "stageChangedDate" };
}
if (queryParams.startDateStartDate || queryParams.startDateEndDate) {
return { label: "Start date", value: "startDate" };
}
if (queryParams.closeDateStartDate || queryParams.closeDateEndDate) {
return { label: "Close date", value: "closeDate" };
}
};
onChangeRangeFilter = (kind: string, date) => {
const formattedDate = date ? dayjs(date).format("YYYY-MM-DD") : "";
const { queryParams, onSelect } = this.props;
if (typeof kind === "undefined") {
return null;
}
if (queryParams[kind] !== formattedDate) {
onSelect(formattedDate, kind);
}
};
renderDates() {
const { link } = this.props;
if (link.includes("calendar")) {
return null;
}
return (
<>
{this.renderLink("Assigned to me", "assignedToMe", "true")}
{this.renderLink("Due tomorrow", "closeDateType", "nextDay")}
{this.renderLink("Due next week", "closeDateType", "nextWeek")}
{this.renderLink("Due next month", "closeDateType", "nextMonth")}
{this.renderLink("Has no close date", "closeDateType", "noCloseDate")}
{this.renderLink("Overdue", "overdue", "closeDateType")}
</>
);
}
renderLink(label: string, key: string, value: string) {
const { onSelect, queryParams } = this.props;
const selected = queryParams[key] === value;
const onClick = _e => {
onSelect(value, key);
};
return (
<FilterButton selected={selected} onClick={onClick}>
{__(label)}
{selected && <Icon icon="check-1" size={14} />}
</FilterButton>
);
}
renderFilter() {
const { queryParams, onSelect, extraFilter, options } = this.props;
const { dateRangeType, dateRange } = this.state;
const priorityValues = PRIORITIES.map(p => ({
label: p,
value: p
}));
const daterangeValues = DATERANGES.map(p => ({
label: p.name,
value: p.value
}));
const priorities = queryParams ? queryParams.priority : [];
const onPrioritySelect = (ops: OnChangeValue<IOption, true>) =>
onSelect(
ops.map(option => option.value),
"priority"
);
return (
<FilterBox>
<FormControl
defaultValue={queryParams.search}
placeholder={__("Type to search")}
onKeyPress={this.onSearch}
autoFocus={true}
/>
<SelectTeamMembers
label="Filter by created members"
name="userIds"
queryParams={queryParams}
onSelect={onSelect}
/>
<SelectBranches
name="branchIds"
label="Filter by branches"
initialValue={queryParams.branchIds}
onSelect={onSelect}
/>
<SelectDepartments
name="departmentIds"
label="Filter by departments"
initialValue={queryParams.departmentIds}
onSelect={onSelect}
/>
<Select
placeholder={__("Filter by priority")}
value={priorityValues.filter(option =>
(priorities || []).includes(option.value)
)}
options={priorityValues}
name="priority"
onChange={onPrioritySelect}
isMulti={true}
loadingMessage={__("Loading...")}
/>
<SelectTeamMembers
label="Filter by team members"
name="assignedUserIds"
queryParams={queryParams}
onSelect={onSelect}
customOption={{
value: "",
label: "Assigned to no one"
}}
/>
<SelectLabel
queryParams={queryParams}
name="labelIds"
onSelect={onSelect}
filterParams={{
pipelineId: queryParams.pipelineId || ""
}}
multi={true}
customOption={{ value: "", label: "No label chosen" }}
/>
{extraFilter}
<ControlLabel>Date range:</ControlLabel>
<Select
placeholder={__("Choose date range type")}
value={this.dateRangeType() || dateRangeType}
options={daterangeValues}
name="daterangeType"
isClearable={true}
onChange={this.onTypeChange}
/>
<CustomRangeContainer>
<DateControl
value={this.startDateValue()}
required={false}
name={dateRange.startDate}
onChange={date =>
this.onChangeRangeFilter(dateRange.startDate, date)
}
placeholder={"Start date"}
dateFormat={"YYYY-MM-DD"}
/>
<DateControl
value={this.endDateValue()}
required={false}
name={dateRange.endDate}
placeholder={"End date"}
onChange={date => this.onChangeRangeFilter(dateRange.endDate, date)}
dateFormat={"YYYY-MM-DD"}
/>
</CustomRangeContainer>
{this.renderDates()}
<SegmentFilter
type={`tasks:${options.type}`}
boardId={queryParams.id || ""}
pipelineId={queryParams.pipelineId || ""}
/>
</FilterBox>
);
}
renderTabContent() {
if (this.state.currentTab === "Filter") {
const { isFiltered, clearFilter } = this.props;
return (
<>
<TabContent>{this.renderFilter()}</TabContent>
{isFiltered && (
<MenuFooter>
<Button
block={true}
btnStyle="warning"
onClick={clearFilter}
icon="times-circle"
>
{__("Clear Filter")}
</Button>
</MenuFooter>
)}
</>
);
}
const { queryParams, options } = this.props;
return (
<TabContent>
<Archive queryParams={queryParams} options={options} />
</TabContent>
);
}
render() {
const tabOnClick = (name: string) => {
this.onChange("currentTab", name);
};
const { currentTab, showMenu } = this.state;
const { isFiltered } = this.props;
return (
<div ref={this.setWrapperRef}>
{isFiltered && (
<Button
btnStyle="warning"
icon="times-circle"
onClick={this.props.clearFilter}
>
{__("Clear Filter")}
</Button>
)}
<Button btnStyle="simple" icon="bars" onClick={this.toggleMenu}>
{showMenu ? __("Hide Menu") : __("Show Menu")}
</Button>
<Transition show={showMenu} unmount={true} as={Fragment}>
<Transition.Child as={Fragment}>
<RightMenuContainer>
<Tabs full={true}>
<TabTitle
className={currentTab === "Filter" ? "active" : ""}
onClick={tabOnClick.bind(this, "Filter")}
>
{__("Filter")}
</TabTitle>
<TabTitle
className={currentTab === "Archived items" ? "active" : ""}
onClick={tabOnClick.bind(this, "Archived items")}
>
{__("Archived items")}
</TabTitle>
</Tabs>
{this.renderTabContent()}
</RightMenuContainer>
</Transition.Child>
</Transition>
</div>
);
}
}
``` | /content/code_sandbox/packages/ui-tasks/src/boards/components/RightMenu.tsx | xml | 2016-11-11T06:54:50 | 2024-08-16T10:26:06 | erxes | erxes/erxes | 3,479 | 2,692 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="path_to_url">
<item android:drawable="@drawable/record_delete_check_normal" android:state_checked="true" android:state_pressed="false"/>
<item android:drawable="@drawable/record_delete_check_press" android:state_checked="true" android:state_pressed="true"/>
<item android:drawable="@drawable/record_delete_press" android:state_pressed="true"/>
<item android:drawable="@drawable/record_delete_normal"/>
</selector>
``` | /content/code_sandbox/SmallVideoRecord1/SmallVideoLib/src/main/res/drawable/record_delete_selector.xml | xml | 2016-08-25T09:20:09 | 2024-08-11T05:54:45 | small-video-record | mabeijianxi/small-video-record | 3,455 | 117 |
```xml
/*your_sha256_hash-----------------------------
*your_sha256_hash----------------------------*/
import { promises as fs } from 'fs';
export async function exists(path: string): Promise<boolean> {
try {
await fs.access(path);
return true;
} catch (e) {
return false;
}
}
export class CancelError extends Error { }
``` | /content/code_sandbox/src/utils/utils.ts | xml | 2016-06-26T04:38:04 | 2024-08-16T20:04:12 | vscode-mssql | microsoft/vscode-mssql | 1,523 | 71 |
```xml
import type { NextConfigComplete } from '../../server/config-shared'
import path from 'path'
const EVENT_VERSION = 'NEXT_CLI_SESSION_STARTED'
type EventCliSessionStarted = {
nextVersion: string
nodeVersion: string
cliCommand: string
isSrcDir: boolean | null
hasNowJson: boolean
isCustomServer: boolean | null
hasNextConfig: boolean
buildTarget: string
hasWebpackConfig: boolean
hasBabelConfig: boolean
basePathEnabled: boolean
i18nEnabled: boolean
imageEnabled: boolean
imageFutureEnabled: boolean
locales: string | null
localeDomainsCount: number | null
localeDetectionEnabled: boolean | null
imageDomainsCount: number | null
imageRemotePatternsCount: number | null
imageSizes: string | null
imageLoader: string | null
imageFormats: string | null
nextConfigOutput: string | null
trailingSlashEnabled: boolean
reactStrictMode: boolean
webpackVersion: number | null
turboFlag: boolean
appDir: boolean | null
pagesDir: boolean | null
staticStaleTime: number | null
dynamicStaleTime: number | null
reactCompiler: boolean
reactCompilerCompilationMode: string | null
reactCompilerPanicThreshold: string | null
}
function hasBabelConfig(dir: string): boolean {
try {
const noopFile = path.join(dir, 'noop.js')
const res = require('next/dist/compiled/babel/core').loadPartialConfig({
cwd: dir,
filename: noopFile,
sourceFileName: noopFile,
}) as any
const isForTooling =
res.options?.presets?.every(
(e: any) => e?.file?.request === 'next/babel'
) && res.options?.plugins?.length === 0
return res.hasFilesystemConfig() && !isForTooling
} catch {
return false
}
}
export function eventCliSession(
dir: string,
nextConfig: NextConfigComplete,
event: Omit<
EventCliSessionStarted,
| 'nextVersion'
| 'nodeVersion'
| 'hasNextConfig'
| 'buildTarget'
| 'hasWebpackConfig'
| 'hasBabelConfig'
| 'basePathEnabled'
| 'i18nEnabled'
| 'imageEnabled'
| 'imageFutureEnabled'
| 'locales'
| 'localeDomainsCount'
| 'localeDetectionEnabled'
| 'imageDomainsCount'
| 'imageRemotePatternsCount'
| 'imageSizes'
| 'imageLoader'
| 'imageFormats'
| 'nextConfigOutput'
| 'trailingSlashEnabled'
| 'reactStrictMode'
| 'staticStaleTime'
| 'dynamicStaleTime'
| 'reactCompiler'
| 'reactCompilerCompilationMode'
| 'reactCompilerPanicThreshold'
>
): { eventName: string; payload: EventCliSessionStarted }[] {
// This should be an invariant, if it fails our build tooling is broken.
if (typeof process.env.__NEXT_VERSION !== 'string') {
return []
}
const { images, i18n } = nextConfig || {}
const payload: EventCliSessionStarted = {
nextVersion: process.env.__NEXT_VERSION,
nodeVersion: process.version,
cliCommand: event.cliCommand,
isSrcDir: event.isSrcDir,
hasNowJson: event.hasNowJson,
isCustomServer: event.isCustomServer,
hasNextConfig: nextConfig.configOrigin !== 'default',
buildTarget: 'default',
hasWebpackConfig: typeof nextConfig?.webpack === 'function',
hasBabelConfig: hasBabelConfig(dir),
imageEnabled: !!images,
imageFutureEnabled: !!images,
basePathEnabled: !!nextConfig?.basePath,
i18nEnabled: !!i18n,
locales: i18n?.locales ? i18n.locales.join(',') : null,
localeDomainsCount: i18n?.domains ? i18n.domains.length : null,
localeDetectionEnabled: !i18n ? null : i18n.localeDetection !== false,
imageDomainsCount: images?.domains ? images.domains.length : null,
imageRemotePatternsCount: images?.remotePatterns
? images.remotePatterns.length
: null,
imageSizes: images?.imageSizes ? images.imageSizes.join(',') : null,
imageLoader: images?.loader,
imageFormats: images?.formats ? images.formats.join(',') : null,
nextConfigOutput: nextConfig?.output || null,
trailingSlashEnabled: !!nextConfig?.trailingSlash,
reactStrictMode: !!nextConfig?.reactStrictMode,
webpackVersion: event.webpackVersion || null,
turboFlag: event.turboFlag || false,
appDir: event.appDir,
pagesDir: event.pagesDir,
staticStaleTime: nextConfig.experimental.staleTimes?.static ?? null,
dynamicStaleTime: nextConfig.experimental.staleTimes?.dynamic ?? null,
reactCompiler: Boolean(nextConfig.experimental.reactCompiler),
reactCompilerCompilationMode:
typeof nextConfig.experimental.reactCompiler !== 'boolean'
? nextConfig.experimental.reactCompiler?.compilationMode ?? null
: null,
reactCompilerPanicThreshold:
typeof nextConfig.experimental.reactCompiler !== 'boolean'
? nextConfig.experimental.reactCompiler?.panicThreshold ?? null
: null,
}
return [{ eventName: EVENT_VERSION, payload }]
}
``` | /content/code_sandbox/packages/next/src/telemetry/events/version.ts | xml | 2016-10-05T23:32:51 | 2024-08-16T19:44:30 | next.js | vercel/next.js | 124,056 | 1,212 |
```xml
import { c } from 'ttag';
import { Button, Kbd } from '@proton/atoms';
import { Icon, Tooltip } from '@proton/components';
import DropdownMenuButton from '@proton/components/components/dropdown/DropdownMenuButton';
import { metaKey, shiftKey } from '@proton/shared/lib/helpers/browser';
import clsx from '@proton/utils/clsx';
import useMailModel from 'proton-mail/hooks/useMailModel';
import ComposerMoreOptionsDropdown from './ComposerMoreOptionsDropdown';
interface Props {
isPassword: boolean;
onPassword: () => void;
onRemoveOutsideEncryption: () => void;
}
const ComposerPasswordActions = ({ isPassword, onRemoveOutsideEncryption, onPassword }: Props) => {
const { Shortcuts } = useMailModel('MailSettings');
const titleEncryption = Shortcuts ? (
<>
{c('Title').t`External encryption`}
<br />
<Kbd shortcut={metaKey} /> + <Kbd shortcut={shiftKey} /> + <Kbd shortcut="E" />
</>
) : (
c('Title').t`External encryption`
);
if (isPassword) {
return (
<ComposerMoreOptionsDropdown
title={c('Title').t`External encryption`}
titleTooltip={c('Title').t`External encryption`}
className="button button-for-icon composer-more-dropdown"
data-testid="composer:encryption-options-button"
content={
<Icon
name="lock"
className={clsx([isPassword && 'color-primary'])}
alt={c('Action').t`External encryption`}
/>
}
>
<DropdownMenuButton
className="text-left flex flex-nowrap items-center"
onClick={onPassword}
data-testid="composer:edit-outside-encryption"
>
<Icon name="lock" />
<span className="ml-2 my-auto flex-1">{c('Action').t`Edit encryption`}</span>
</DropdownMenuButton>
<DropdownMenuButton
className="text-left flex flex-nowrap items-center color-danger"
onClick={onRemoveOutsideEncryption}
data-testid="composer:remove-outside-encryption"
>
<Icon name="trash" />
<span className="ml-2 my-auto flex-1">{c('Action').t`Remove encryption`}</span>
</DropdownMenuButton>
</ComposerMoreOptionsDropdown>
);
}
return (
<Tooltip title={titleEncryption}>
<Button
icon
color={isPassword ? 'norm' : undefined}
shape="ghost"
data-testid="composer:password-button"
onClick={onPassword}
aria-pressed={isPassword}
>
<Icon name="lock" alt={c('Action').t`Encryption`} />
</Button>
</Tooltip>
);
};
export default ComposerPasswordActions;
``` | /content/code_sandbox/applications/mail/src/app/components/composer/actions/ComposerPasswordActions.tsx | xml | 2016-06-08T11:16:51 | 2024-08-16T14:14:27 | WebClients | ProtonMail/WebClients | 4,300 | 617 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
"path_to_url">
<!--
file LICENSE_1_0.txt or copy at path_to_url
-->
<header name="boost/signals2/signal_base.hpp" last-revision="$Date: 2007-03-06 16:51:55 -0500 (Tue, 06 Mar 2007) $">
<namespace name="boost">
<namespace name="signals2">
<class name="signal_base">
<inherit access="public">
<type><classname>noncopyable</classname></type>
</inherit>
<purpose>Base class for signals.</purpose>
<destructor specifiers="virtual">
<description><para>Virtual destructor.</para></description>
</destructor>
</class>
</namespace>
</namespace>
</header>
``` | /content/code_sandbox/deps/boost_1_66_0/libs/signals2/doc/reference/signal_base.xml | xml | 2016-09-05T10:18:44 | 2024-08-11T13:21:40 | LiquidCore | LiquidPlayer/LiquidCore | 1,010 | 203 |
```xml
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet title="XSL_formatting" type="text/xsl" href="/shared/bsp/xsl/rss/nolsol.xsl"?>
<rss xmlns:dc="path_to_url" xmlns:content="path_to_url" xmlns:atom="path_to_url" version="2.0" xmlns:media="path_to_url">
<channel>
<title><![CDATA[BBC News - Home]]></title>
<description><![CDATA[BBC News - Home]]></description>
<link>path_to_url
<image>
<url>path_to_url
<title>BBC News - Home</title>
<link>path_to_url
</image>
<generator>RSS for Node</generator>
<lastBuildDate>Fri, 31 Mar 2017 14:20:51 GMT</lastBuildDate>
<language><![CDATA[en-gb]]></language>
<ttl>15</ttl>
<item>
<title><![CDATA[EU sets out 'phased' Brexit strategy]]></title>
<description><![CDATA[Talks on a trade deal may begin once progress in Brexit talks has been made, the bloc suggests.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 14:18:09 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[NHS operations: Waiting times to rise in 'trade-off', boss says]]></title>
<description><![CDATA[Cancer care and A&E to be prioritised as health service leader in England says something has to give.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 10:01:22 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Nicola Sturgeon: 'No rational reason' for Theresa May to block indyref2]]></title>
<description><![CDATA[Nicola Sturgeon sends a letter to Theresa May seeking powers to hold an independence referendum.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 12:53:20 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Google reveals latest UK tax bill]]></title>
<description><![CDATA[The search giant was charged 36.4m in UK corporation tax in the year to June 2016.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 14:19:00 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Brexit: MPs angered by EU 'veto' over Gibraltar]]></title>
<description><![CDATA[British sovereignty is non-negotiable, MPs say, as the EU suggests Spain has a say on future arrangements.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 14:16:27 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Meet the fish with the heroin-like bite]]></title>
<description><![CDATA[Research reveals the toxic secret behind the fang blenny's pain-free bite.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 12:27:08 GMT</pubDate>
<media:thumbnail width="640" height="360" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Bin lorry deaths driver Harry Clarke banned from driving]]></title>
<description><![CDATA[Harry Clarke was found behind the wheel nine months after the tragedy, despite being unfit to drive.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 11:21:22 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[British endurance cyclist Mike Hall killed in road race]]></title>
<description><![CDATA[The Indian Pacific Wheel Race was cancelled shortly after Mike Hall died in a collision with a car.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 09:41:59 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Kim Jong-nam: Body 'arrives in Pyongyang' in exchange deal]]></title>
<description><![CDATA[Nine Malaysians also return home under a deal to end the diplomatic row that followed his death.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 11:52:18 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Household savings ratio falls to record low, says ONS]]></title>
<description><![CDATA[The economy was "robust" in late 2016, but economists warn of worrying signs as savings ratio falls.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 11:50:22 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Stourbridge stabbing Land Rover chase caught on dashcam]]></title>
<description><![CDATA[The 4x4 was taken from the house in Stourbridge where a husband, wife and their son were attacked.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 10:33:37 GMT</pubDate>
<media:thumbnail width="464" height="261" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Fallon and Mattis discussing Nato spending]]></title>
<description><![CDATA[Defence secretary says other nations should be "shamed" into spending more as he meets US counterpart.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 11:05:16 GMT</pubDate>
<media:thumbnail width="1920" height="1080" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Pamela Anderson's 'love' for Julian Assange]]></title>
<description><![CDATA[Pamela Anderson says the Wikileaks founder "might be the most famous refugee of our time".]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 11:43:37 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Quiz: Which airline stopped girls in leggings from flying?]]></title>
<description><![CDATA[A weekly quiz of the news, 7 days 7 questions.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 23:52:21 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[James Van Der Beek and his awkward Dawson's Creek interview questions]]></title>
<description><![CDATA[Why are chat show hosts putting the former Dawson's Creek star through such awkward interviews?]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 12:13:55 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[The rapping hijabi lights up social media]]></title>
<description><![CDATA[Find out what's buzzing in the social media world today.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 13:25:57 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[What gifts has Theresa May been given?]]></title>
<description><![CDATA[Like all prime ministers, Theresa May is showered with gifts but she does not keep many of them.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 09:38:00 GMT</pubDate>
<media:thumbnail width="768" height="432" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Flying Scotsman marks Carlisle-to-Settle line reopening]]></title>
<description><![CDATA[The Settle-to-Carlisle line was closed for 13 months after a 500,000-tonne landslip.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 11:44:29 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Hedgehog-like critters arrive at Chester Zoo]]></title>
<description><![CDATA[Its stripes are more like a bumblebee's.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 05:25:23 GMT</pubDate>
<media:thumbnail width="1024" height="576" url="path_to_url"/>
</item>
<item>
<title><![CDATA['Inspiring' ex-teacher helps disabled children]]></title>
<description><![CDATA[The story of the former teacher who has set up a Facebook page for interviews with the children.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 23:53:19 GMT</pubDate>
<media:thumbnail width="1024" height="579" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Africa's top shots: 24-30 March 2017]]></title>
<description><![CDATA[A selection of the best photos from across Africa this week.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 23:46:14 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Ivanka Trump steps into White House ethics minefield]]></title>
<description><![CDATA[Donald Trump's daughter has to circumvent conflicts of interest laws in her new job.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 22:36:43 GMT</pubDate>
<media:thumbnail width="2048" height="1152" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Cat ownership rise driven by men, survey suggests]]></title>
<description><![CDATA[There are now eight million pet cats in the UK - 500,000 more than in 2016, a survey suggests.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 10:18:11 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Is 'luxury co-living' a solution to loneliness in big cities?]]></title>
<description><![CDATA[Could student hall-style accommodation for young professionals tackle loneliness in big cities?]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Wed, 29 Mar 2017 23:31:45 GMT</pubDate>
<media:thumbnail width="1920" height="1080" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Thirsty snake drinks from water bottle]]></title>
<description><![CDATA[A cobra in a drought-hit village in India has been filmed drinking water from a bottle.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 12:26:18 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[BBC News Channel]]></title>
<description><![CDATA[BBC coverage of latest developments]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 17 Feb 2017 09:41:12 GMT</pubDate>
<media:thumbnail width="2048" height="1152" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Peter Taylor: How has terror changed in 50 years?]]></title>
<description><![CDATA[The threat from terrorism is always evolving, but some things are constant, writes Peter Taylor.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 23:54:44 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Meet the Hunter Troop: Norway's tough-as-nails female soldiers]]></title>
<description><![CDATA[Meet the Norwegian women going through gruelling special forces training.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 23:17:14 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Inside France's young far-right]]></title>
<description><![CDATA[A new generation of far-right activists have found a home in the Front National.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 02:32:02 GMT</pubDate>
<media:thumbnail width="1024" height="576" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Prince's Sign O' The Times, 30 years on]]></title>
<description><![CDATA[A look at the making of Prince's masterpiece, by the people who were there.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 23:56:02 GMT</pubDate>
<media:thumbnail width="1024" height="576" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Masters 2017: Danny Willett - inside the ropes with a Masters winner]]></title>
<description><![CDATA[Masters champion Danny Willett and his caddie Jonathan Swift talk us through their sensational back nine at Augusta to win the 2016 title.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 05:50:42 GMT</pubDate>
<media:thumbnail width="624" height="351" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Information warfare: Is Russia really interfering in European states?]]></title>
<description><![CDATA[How Russia became an expert at information warfare - and the risks that poses for Europe.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 23:53:30 GMT</pubDate>
<media:thumbnail width="976" height="549" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Can China's ivory trade ban save elephants?]]></title>
<description><![CDATA[China begins closing down its legal ivory trade, but will consumer attitudes to prized artwork change?]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 23:27:04 GMT</pubDate>
<media:thumbnail width="2048" height="1152" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Three words to set alarm bells off for every firm]]></title>
<description><![CDATA[Incidents of fraudsters posing as the boss and demanding staff make payments is on the rise.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 23:05:39 GMT</pubDate>
<media:thumbnail width="2048" height="1152" url="path_to_url"/>
</item>
<item>
<title><![CDATA[The joy and sadness of returning to Mosul]]></title>
<description><![CDATA[BBC Arabic's Basheer Al Zaidi returns to his hometown of Mosul to find out how life has changed after the end of occupation by so-called Islamic State.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 23:21:32 GMT</pubDate>
<media:thumbnail width="1920" height="1080" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Man Utd: Chris Smalling & Phil Jones suffered 'long term' injuries]]></title>
<description><![CDATA[The injuries suffered by defenders Chris Smalling and Phil Jones on England duty are "long term", says their Manchester United manager Jose Mourinho.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Fri, 31 Mar 2017 14:03:48 GMT</pubDate>
<media:thumbnail width="2048" height="1152" url="path_to_url"/>
</item>
<item>
<title><![CDATA[Saido Berahino: Drugs ban from a spiked drink, says Stoke striker]]></title>
<description><![CDATA[Stoke striker Saido Berahino tells Football Focus the eight-week drugs ban he served this season came after his drink was spiked.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 20:33:06 GMT</pubDate>
<media:thumbnail width="624" height="351" url="path_to_url"/>
</item>
<item>
<title><![CDATA[PFA Player of the Year: BBC pundits pick the Premier League's best player]]></title>
<description><![CDATA[With voting for the PFA Player of the Year award about to close, 15 BBC pundits reveal who they think should land the prize.]]></description>
<link>path_to_url
<guid isPermaLink="true">path_to_url
<pubDate>Thu, 30 Mar 2017 23:04:42 GMT</pubDate>
<media:thumbnail width="2048" height="1152" url="path_to_url"/>
</item>
</channel>
</rss>
``` | /content/code_sandbox/riko/data/bbci.co.uk.xml | xml | 2016-06-02T12:22:51 | 2024-08-15T02:25:15 | riko | nerevu/riko | 1,606 | 4,860 |
```xml
import React, { forwardRef, PropsWithoutRef } from "react"
import { FlatList } from "react-native"
import { isRTL } from "app/i18n"
import { FlashList, FlashListProps } from "@shopify/flash-list"
export type ListViewRef<T> = FlashList<T> | FlatList<T>
export type ListViewProps<T> = PropsWithoutRef<FlashListProps<T>>
/**
* This is a Higher Order Component meant to ease the pain of using @shopify/flash-list
* when there is a chance that a user would have their device language set to an
* RTL language like Arabic or Punjabi. This component will use react-native's
* FlatList if the user's language is RTL or FlashList if the user's language is LTR.
*
* Because FlashList's props are a superset of FlatList's, you must pass estimatedItemSize
* to this component if you want to use it.
*
* This is a temporary workaround until the FlashList component supports RTL at
* which point this component can be removed and we will default to using FlashList everywhere.
* @see {@link path_to_url|RTL Bug Android}
* @see {@link path_to_url|Flashlist Not Support RTL}
* @param {FlashListProps | FlatListProps} props - The props for the `ListView` component.
* @param {React.RefObject<ListViewRef>} forwardRef - An optional forwarded ref.
* @returns {JSX.Element} The rendered `ListView` component.
*/
const ListViewComponent = forwardRef(
<T,>(props: ListViewProps<T>, ref: React.ForwardedRef<ListViewRef<T>>) => {
const ListComponentWrapper = isRTL ? FlatList : FlashList
return <ListComponentWrapper {...props} ref={ref} />
},
)
ListViewComponent.displayName = "ListView"
export const ListView = ListViewComponent as <T>(
props: ListViewProps<T> & {
ref?: React.RefObject<ListViewRef<T>>
},
) => React.ReactElement
``` | /content/code_sandbox/boilerplate/app/components/ListView.tsx | xml | 2016-02-10T16:06:07 | 2024-08-16T19:52:51 | ignite | infinitered/ignite | 17,196 | 428 |
```xml
import * as Clipboard from 'expo-clipboard';
import React, { useEffect, useMemo, useRef, useState } from 'react';
import { View, Text, StyleSheet, LogBox } from 'react-native';
import { isCurrentPlatformSupported } from '../../components/FunctionDemo/utils';
import HeadingText from '../../components/HeadingText';
import MonoTextWithCountdown from '../../components/MonoTextWithCountdown';
const STRING_TRIM_THRESHOLD = 100;
// TODO: (barthap): Remove this once we removed the listener wrapper from `Clipboard.ts`
LogBox.ignoreLogs([/The 'content' property of the clipboard event is deprecated/]);
export default function ClipboardListenerDemo() {
const isSupported = useMemo(() => isCurrentPlatformSupported(['ios', 'android']), []);
return (
<View style={styles.container}>
<HeadingText>Clipboard Listener</HeadingText>
{isSupported ? (
<ClipboardListenerContent />
) : (
<Text>Clipboard listener is not supported on web</Text>
)}
</View>
);
}
function ClipboardListenerContent() {
const clipboardListener = useRef<Clipboard.Subscription | null>(null);
const [value, setValue] = useState<string | undefined>(undefined);
useEffect(() => {
clipboardListener.current = Clipboard.addClipboardListener(
(event: Clipboard.ClipboardEvent) => {
setValue(stringifyEvent(event));
}
);
return () => {
if (clipboardListener.current) {
Clipboard.removeClipboardListener(clipboardListener.current);
}
};
}, []);
return value !== undefined ? (
<>
<MonoTextWithCountdown timeout={30 * 1000} onCountdownEnded={() => setValue(undefined)}>
{value}
</MonoTextWithCountdown>
<Text>The 'content' property should be empty</Text>
</>
) : (
<Text>No recent changes. Copy something to trigger event</Text>
);
}
function stringifyEvent(event: Clipboard.ClipboardEvent): string {
const trimmedResult = Object.fromEntries(
Object.entries(event).map(([key, value]) => [
key,
typeof value === 'string' && value.length > STRING_TRIM_THRESHOLD
? `${value.substring(0, STRING_TRIM_THRESHOLD)}...`
: value,
])
);
return JSON.stringify(trimmedResult, null, 2);
}
const styles = StyleSheet.create({
container: {
paddingBottom: 20,
},
});
``` | /content/code_sandbox/apps/native-component-list/src/screens/Clipboard/ClipboardListenerDemo.tsx | xml | 2016-08-15T17:14:25 | 2024-08-16T19:54:44 | expo | expo/expo | 32,004 | 518 |
```xml
import { mat4 } from 'gl-matrix';
import vtkPolyData from '../../../Common/DataModel/PolyData';
import { vtkAlgorithm, vtkObject } from '../../../interfaces';
export enum FormatTypes {
ASCII,
BINARY,
}
/**
*
*/
export interface ISTLWriterInitialValues {}
type vtkSTLWriterBase = vtkObject & vtkAlgorithm;
export interface vtkSTLWriter extends vtkSTLWriterBase {
/**
*
*/
getFormat(): FormatTypes;
/**
*
*/
getTransform(): mat4;
/**
*
* @param inData
* @param outData
*/
requestData(inData: any, outData: any): void;
/**
*
* @param {FormatTypes} format
*/
setFormat(format: FormatTypes): boolean;
/**
*
* @param {mat4} transform Tranformation matrix.
*/
setTransform(transform: mat4): boolean;
}
/**
* Method used to decorate a given object (publicAPI+model) with vtkSTLWriter characteristics.
*
* @param publicAPI object on which methods will be bounds (public)
* @param model object on which data structure will be bounds (protected)
* @param {ISTLWriterInitialValues} [initialValues] (default: {})
*/
export function extend(
publicAPI: object,
model: object,
initialValues?: ISTLWriterInitialValues
): void;
/**
* Method used to create a new instance of vtkSTLWriter
* @param {ISTLWriterInitialValues} [initialValues] for pre-setting some of its content
*/
export function newInstance(
initialValues?: ISTLWriterInitialValues
): vtkSTLWriter;
/**
*
* @param {vktPolyData} polyData
* @param {FormatTypes} [format]
* @param {mat4} [transform]
*/
export function writeSTL(
polyData: vtkPolyData,
format?: FormatTypes,
transform?: mat4
): vtkPolyData;
/**
* vtkSTLWriter writes stereo lithography (.stl) files in either ASCII or binary
* form. Stereo lithography files contain only triangles. Since VTK 8.1, this
* writer converts non-triangle polygons into triangles, so there is no longer a
* need to use vtkTriangleFilter prior to using this writer if the input
* contains polygons with more than three vertices.
*/
export declare const vtkSTLWriter: {
newInstance: typeof newInstance;
extend: typeof extend;
writeSTL: typeof writeSTL;
};
export default vtkSTLWriter;
``` | /content/code_sandbox/Sources/IO/Geometry/STLWriter/index.d.ts | xml | 2016-05-02T15:44:11 | 2024-08-15T19:53:44 | vtk-js | Kitware/vtk-js | 1,200 | 549 |
```xml
<resources>
<string name="app_name">UsingFirebaseJobDispatcher</string>
<string name="action_settings">Settings</string>
</resources>
``` | /content/code_sandbox/UsingFirebaseJobDispatcher/app/src/main/res/values/strings.xml | xml | 2016-02-25T11:06:48 | 2024-08-07T21:41:59 | android-examples | nisrulz/android-examples | 1,747 | 34 |
```xml
import * as React from 'react';
import { DemoPage } from '../DemoPage';
import { SpinButtonPageProps } from '@fluentui/react-examples/lib/react/SpinButton/SpinButton.doc';
export const SpinButtonPage = (props: { isHeaderVisible: boolean }) => (
<DemoPage
jsonDocs={require('../../../dist/api/react/SpinButton.page.json')}
{...{ ...SpinButtonPageProps, ...props }}
/>
);
``` | /content/code_sandbox/apps/public-docsite-resources/src/components/pages/SpinButtonPage.tsx | xml | 2016-06-06T15:03:44 | 2024-08-16T18:49:29 | fluentui | microsoft/fluentui | 18,221 | 97 |
```xml
<project xmlns="path_to_url" xmlns:xsi="path_to_url"
xsi:schemaLocation="path_to_url path_to_url">
<modelVersion>4.0.0</modelVersion>
<description>Spring Security OAuth Authorization Server</description>
<groupId>com.baeldung</groupId>
<artifactId>oauth-authorization-server</artifactId>
<version>0.1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
<module>spring-authorization-server</module>
<module>resource-server</module>
<module>client-server</module>
</modules>
<properties>
<java.version>17</java.version>
</properties>
</project>
``` | /content/code_sandbox/oauth-authorization-server/pom.xml | xml | 2016-03-02T09:04:07 | 2024-08-06T03:02:12 | spring-security-oauth | Baeldung/spring-security-oauth | 1,982 | 163 |
```xml
export interface DtoHeader {
id?: string;
key?: string;
value?: string;
isActive: boolean;
isFav?: boolean;
description?: string;
sort?: number;
}
``` | /content/code_sandbox/client/src/common/interfaces/dto_header.ts | xml | 2016-09-26T02:47:43 | 2024-07-24T09:32:20 | Hitchhiker | brookshi/Hitchhiker | 2,193 | 45 |
```xml
<query-profile-type id="type1">
<field name="ranking.features.query(tensor_1)" type="tensor<float>(x[1])" />
<field name="ranking.features.query(tensor_4)" type="tensor(key{})" />
</query-profile-type>
``` | /content/code_sandbox/container-search/src/test/java/com/yahoo/search/query/profile/config/test/tensortypes/types/type1.xml | xml | 2016-06-03T20:54:20 | 2024-08-16T15:32:01 | vespa | vespa-engine/vespa | 5,524 | 60 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.preference.PreferenceScreen
xmlns:android="path_to_url"
xmlns:app="path_to_url"
android:key="general_preference_screen">
<androidx.preference.PreferenceCategory
android:key="settings_appearance"
android:title="@string/settings_appearance"
app:allowDividerAbove="false"
app:allowDividerBelow="false">
<androidx.preference.ListPreference
android:key="settings_appearance_color_theme"
android:title="@string/set_color_theme_label"
app:defaultValue="default"
android:defaultValue="default"
app:entries="@array/theme_list_array"
app:entryValues="@array/theme_entry_array"
app:useSimpleSummaryProvider="true"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
</androidx.preference.PreferenceCategory>
<androidx.preference.PreferenceCategory
android:key="settings_features"
android:title="@string/settings_features"
app:allowDividerAbove="false"
app:allowDividerBelow="false">
<androidx.preference.Preference
android:key="settings_features_camera_upload"
android:title="@string/section_photo_sync"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_features_sync"
android:title="@string/settings_section_sync"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_features_chat"
android:title="@string/section_chat"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_features_calls"
android:title="@string/settings_calls_preferences"
app:allowDividerAbove="true"
app:allowDividerBelow="false"
app:iconSpaceReserved="false" />
</androidx.preference.PreferenceCategory>
<androidx.preference.PreferenceCategory
android:key="settings_storage"
android:title="@string/settings_storage"
app:allowDividerAbove="false"
app:allowDividerBelow="false">
<androidx.preference.Preference
android:key="settings_nested_download_location"
android:title="@string/download_location"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_storage_file_management"
android:title="@string/settings_file_management_category"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
</androidx.preference.PreferenceCategory>
<androidx.preference.PreferenceCategory
android:key="settings_ui"
android:title="@string/user_interface_setting"
app:allowDividerAbove="false"
app:allowDividerBelow="false">
<Preference
android:defaultValue="default"
android:key="settings_start_screen"
android:title="@string/start_screen_setting"
android:summary="@string/home_section"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false"
app:useSimpleSummaryProvider="true" />
<mega.privacy.android.app.presentation.settings.MegaSwitchPreference
android:defaultValue="false"
android:key="settings_hide_recent_activity"
android:summary="@string/hide_recent_setting_context"
android:title="@string/hide_recent_setting"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<mega.privacy.android.app.presentation.settings.MegaSwitchPreference
android:defaultValue="false"
android:key="settings_media_discovery_view"
android:summary="@string/settings_media_discovery_view_context"
android:title="@string/settings_media_discovery_view_title"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<mega.privacy.android.app.presentation.settings.MegaSwitchPreference
android:defaultValue="false"
android:key="settings_sub_folder_media_discovery"
android:summary="@string/settings_media_discovery_sub_folder_context"
android:title="@string/settings_media_discovery_sub_folder_title"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<mega.privacy.android.app.presentation.settings.MegaSwitchPreference
android:defaultValue="true"
android:key="settings_hidden_items"
android:summary="@string/hidden_nodes_show_items_description"
android:title="@string/hidden_nodes_show_items"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
</androidx.preference.PreferenceCategory>
<androidx.preference.PreferenceCategory
android:key="settings_media"
android:title="@string/settings_media"
app:allowDividerAbove="false"
app:allowDividerBelow="false">
<mega.privacy.android.app.presentation.settings.MegaSwitchPreference
android:key="settings_audio_background_play_enabled"
android:summary="@string/settings_background_play_hint"
android:title="@string/settings_media_audio_files"
android:defaultValue="true"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
</androidx.preference.PreferenceCategory>
<androidx.preference.PreferenceCategory
android:key="settings_security"
android:title="@string/settings_security_options_title"
app:allowDividerAbove="false"
app:allowDividerBelow="false">
<androidx.preference.Preference
android:key="settings_recovery_key"
android:title="@string/settings_recovery_key_title"
android:summary="@string/settings_recovery_key_summary"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_passcode_lock"
android:title="@string/settings_passcode_lock_switch"
android:defaultValue="false"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_change_password"
android:title="@string/my_account_change_password"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<mega.privacy.android.app.presentation.settings.MegaSwitchPreference
android:key="settings_2fa_activated"
android:title="@string/settings_2fa"
android:summary="@string/setting_subtitle_2fa"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<mega.privacy.android.app.presentation.settings.MegaSwitchPreference
android:key="settings_qrcode_autoaccept"
android:title="@string/section_qr_code"
android:summary="@string/setting_subtitle_qrcode_autoccept"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:fragment="mega.privacy.android.app.presentation.settings.advanced.SettingsAdvancedFragment"
android:key="settings_security_advanced"
android:title="@string/settings_advanced_features"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
</androidx.preference.PreferenceCategory>
<androidx.preference.PreferenceCategory
android:key="settings_help"
android:title="@string/settings_help"
app:allowDividerAbove="false"
app:allowDividerBelow="false">
<androidx.preference.Preference
android:key="settings_help_centre"
android:title="@string/settings_help_centre"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_help_send_feedback"
android:title="@string/settings_help_preference"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_help_report_issue"
android:title="@string/settings_help_report_issue"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false"
android:fragment="mega.privacy.android.app.presentation.settings.reportissue.ReportIssueFragment"
/>
</androidx.preference.PreferenceCategory>
<androidx.preference.PreferenceCategory
android:key="settings_about"
android:title="@string/settings_about"
app:allowDividerAbove="false"
app:allowDividerBelow="false">
<androidx.preference.Preference
android:key="settings_about_privacy_policy"
android:title="@string/settings_about_privacy_policy"
android:summary=""
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_about_cookie_policy"
android:title="@string/settings_about_cookie_policy"
android:summary=""
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_cookie"
android:title="@string/settings_about_cookie_settings"
android:summary=""
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_about_terms_of_service"
android:title="@string/settings_about_terms_of_service"
android:summary=""
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_about_code_link"
android:title="@string/settings_about_code_link_title"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_about_sdk_version"
android:title="@string/settings_about_sdk_version"
android:summary="@string/sdk_version"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_about_karere_version"
android:title="@string/settings_about_karere_version"
android:summary="@string/karere_version"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_about_app_version"
android:title="@string/settings_about_app_version"
android:summary="@string/app_version"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
<androidx.preference.Preference
android:key="settings_about_cancel_account"
android:layout="@layout/cancel_account_preferences"
android:title="@string/settings_delete_account"
app:allowDividerAbove="true"
app:allowDividerBelow="true"
app:iconSpaceReserved="false" />
</androidx.preference.PreferenceCategory>
</androidx.preference.PreferenceScreen>
``` | /content/code_sandbox/app/src/main/res/xml/preferences.xml | xml | 2016-05-04T11:46:20 | 2024-08-15T16:29:10 | android | meganz/android | 1,537 | 2,628 |
```xml
import { deduplicateBusySlots } from './busySlotsSelectors.helpers';
import type { BusySlot } from './busySlotsSlice';
describe('deduplicateBusySlots', () => {
it('should deduplicate equal busy slots', () => {
const busySlots = [
{ Start: 1, End: 2 },
{ Start: 1, End: 2 },
{ Start: 1, End: 2 },
{ Start: 2, End: 3 },
] as BusySlot[];
expect(deduplicateBusySlots(busySlots)).toEqual([
{ Start: 1, End: 2 },
{ Start: 2, End: 3 },
]);
});
});
``` | /content/code_sandbox/applications/calendar/src/app/store/busySlots/busySlotsSelectors.helpers.test.ts | xml | 2016-06-08T11:16:51 | 2024-08-16T14:14:27 | WebClients | ProtonMail/WebClients | 4,300 | 152 |
```xml
import * as React from "react"
import * as types from "vscode-languageserver-types"
import { getDocumentationText } from "../../Plugins/Api/LanguageClient/LanguageClientHelpers"
import {
QuickInfoDocumentation,
QuickInfoElement,
QuickInfoWrapper,
Title,
} from "./../../UI/components/QuickInfo"
import { SelectedText, Text } from "./../../UI/components/Text"
export const getElementsFromType = (signatureHelp: types.SignatureHelp): JSX.Element => {
const elements = []
const currentItem = signatureHelp.signatures[signatureHelp.activeSignature]
if (!currentItem || !currentItem.label || !currentItem.parameters) {
return null
}
const label = currentItem.label
const parameters = currentItem.parameters
let remainingSignatureString = label
let keyIndex = 0
for (let i = 0; i < parameters.length; i++) {
const parameterLabel = parameters[i].label
const parameterIndex = remainingSignatureString.indexOf(parameterLabel)
if (parameterIndex === -1) {
continue
}
keyIndex++
const nonArgumentText = remainingSignatureString.substring(0, parameterIndex)
elements.push(<Text text={nonArgumentText} key={keyIndex.toString()} />)
const argumentText = remainingSignatureString.substring(
parameterIndex,
parameterIndex + parameterLabel.length,
)
keyIndex++
if (i === signatureHelp.activeParameter) {
elements.push(<SelectedText text={argumentText} key={keyIndex.toString()} />)
} else {
elements.push(<Text text={argumentText} key={keyIndex.toString()} />)
}
remainingSignatureString = remainingSignatureString.substring(
parameterIndex + parameterLabel.length,
remainingSignatureString.length,
)
}
elements.push(<Text key={remainingSignatureString} text={remainingSignatureString} />)
const selectedIndex = Math.min(currentItem.parameters.length, signatureHelp.activeParameter)
const selectedArgument = currentItem.parameters[selectedIndex]
return (
<React.Fragment>
<Title padding="0.5rem" key={"signatureHelp.title"}>
{elements}
</Title>
{!!(selectedArgument && selectedArgument.documentation) && (
<QuickInfoDocumentation
text={getDocumentationText(selectedArgument.documentation)}
/>
)}
</React.Fragment>
)
}
export const SignatureHelpView = (props: types.SignatureHelp) => (
<QuickInfoWrapper>
<QuickInfoElement>{getElementsFromType(props)}</QuickInfoElement>
</QuickInfoWrapper>
)
export const render = (signatureHelp: types.SignatureHelp) => (
<SignatureHelpView {...signatureHelp} />
)
``` | /content/code_sandbox/browser/src/Services/Language/SignatureHelpView.tsx | xml | 2016-11-16T14:42:55 | 2024-08-14T11:48:05 | oni | onivim/oni | 11,355 | 567 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout
xmlns:android="path_to_url"
xmlns:app="path_to_url"
android:id="@+id/ll_select_folder"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<include
android:id="@+id/toolbar"
layout="@layout/toolbar"
android:background="@color/md_dark_appbar"
android:windowActionBarOverlay="true" />
<RelativeLayout
android:id="@+id/rl_ea"
android:layout_width="match_parent"
android:layout_height="match_parent">
<!--THERE IS NOTHING TO SHOW-->
<include layout="@layout/there_is_nothing_to_show"/>
<!--RECYCLE VIEW AND WHITE LIST CARD-->
<LinearLayout
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="wrap_content">
<android.support.v7.widget.CardView
android:id="@+id/white_list_decription_card"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginBottom="@dimen/card_spacing"
android:paddingBottom="@dimen/card_spacing"
app:cardCornerRadius="@dimen/card_corner_radius"
app:cardElevation="@dimen/card_elevation"
android:foreground="@drawable/ripple"
android:clickable="true"
android:visibility="gone">
<TextView
android:id="@+id/white_list_decription_txt"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textColor="@color/md_dark_primary_text"
android:text="@string/white_list_explaination"
android:textSize="@dimen/medium_text"
android:layout_gravity="center"
android:padding="@dimen/medium_spacing" />
</android.support.v7.widget.CardView>
<android.support.v7.widget.RecyclerView
android:id="@+id/excluded_albums"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:scrollbars="vertical"
android:scrollbarThumbVertical="@drawable/ic_scrollbar" />
</LinearLayout>
</RelativeLayout>
</LinearLayout>
</android.support.design.widget.CoordinatorLayout>
``` | /content/code_sandbox/app/src/main/res/layout/activity_black_white_list.xml | xml | 2016-01-07T17:24:12 | 2024-08-16T06:55:33 | LeafPic | UnevenSoftware/LeafPic | 3,258 | 539 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<style name="AppTheme" parent="Theme.MaterialComponents.DayNight.Bridge">
<!-- Customize your theme here. -->
<item name="colorPrimary">@color/colorPrimary</item>
<item name="colorPrimaryDark">@color/colorPrimaryDark</item>
<item name="colorAccent">@color/colorAccent</item>
<item name="buttonStyle">@style/SlimButton</item>
<item name="android:windowLightStatusBar">true</item>
<item name="android:navigationBarColor">@color/colorPrimary</item>
<item name="android:windowLightNavigationBar">true</item>
<item name="android:windowSplashScreenBackground">@color/colorPrimary</item>
<!-- Theme for the Preferences -->
<item name="preferenceTheme">@style/PreferenceThemeOverlay.v14.Material</item>
</style>
</resources>
``` | /content/code_sandbox/app/src/main/res/values-v31/themes.xml | xml | 2016-02-01T23:48:36 | 2024-08-15T03:35:42 | TagMo | HiddenRamblings/TagMo | 2,976 | 202 |
```xml
// *** WARNING: this file was generated by test. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
import * as outputs from "../types/output";
export interface Config {
foo?: string;
}
``` | /content/code_sandbox/tests/testdata/codegen/secrets/nodejs/types/output.ts | xml | 2016-10-31T21:02:47 | 2024-08-16T19:47:04 | pulumi | pulumi/pulumi | 20,743 | 72 |
```xml
import { InjectionToken, Provider } from '@angular/core';
import { defaultOptions } from './ng-progress-default';
export interface NgProgressOptions {
spinnerPosition?: 'left' | 'right';
direction?: 'ltr+' | 'ltr-' | 'rtl+' | 'rtl-';
relative?: boolean;
flat?: boolean;
spinner?: boolean;
max?: number;
min?: number;
speed?: number;
trickleSpeed?: number;
trickleFunc?: (n: number) => number;
debounceTime?: number;
}
export const NG_PROGRESS_OPTIONS: InjectionToken<NgProgressOptions> = new InjectionToken<NgProgressOptions>('NG_PROGRESS_OPTIONS', {
providedIn: 'root',
factory: () => defaultOptions
});
export function provideNgProgressOptions(options: NgProgressOptions): Provider {
return {
provide: NG_PROGRESS_OPTIONS,
useValue: { ...defaultOptions, ...options }
};
}
``` | /content/code_sandbox/projects/ngx-progressbar/src/lib/ng-progress.model.ts | xml | 2016-09-01T05:55:21 | 2024-08-14T12:42:02 | ngx-progressbar | MurhafSousli/ngx-progressbar | 1,007 | 196 |
```xml
'use strict';
import { inject, injectable } from 'inversify';
import { IApplicationShell, ICommandManager } from '../../common/application/types';
import '../../common/extensions';
import { IDisposableRegistry, ILogOutputChannel } from '../../common/types';
import { OutputChannelNames } from '../../common/utils/localize';
import { ILanguageServerOutputChannel } from '../types';
@injectable()
export class LanguageServerOutputChannel implements ILanguageServerOutputChannel {
public output: ILogOutputChannel | undefined;
private registered = false;
constructor(
@inject(IApplicationShell) private readonly appShell: IApplicationShell,
@inject(ICommandManager) private readonly commandManager: ICommandManager,
@inject(IDisposableRegistry) private readonly disposable: IDisposableRegistry,
) {}
public get channel(): ILogOutputChannel {
if (!this.output) {
this.output = this.appShell.createOutputChannel(OutputChannelNames.languageServer);
this.disposable.push(this.output);
this.registerCommand().ignoreErrors();
}
return this.output;
}
private async registerCommand() {
if (this.registered) {
return;
}
this.registered = true;
// This controls the visibility of the command used to display the LS Output panel.
// We don't want to display it when Jedi is used instead of LS.
await this.commandManager.executeCommand('setContext', 'python.hasLanguageServerOutputChannel', true);
this.disposable.push(
this.commandManager.registerCommand('python.viewLanguageServerOutput', () => this.output?.show(true)),
);
this.disposable.push({
dispose: () => {
this.registered = false;
},
});
}
}
``` | /content/code_sandbox/src/client/activation/common/outputChannel.ts | xml | 2016-01-19T10:50:01 | 2024-08-12T21:05:24 | pythonVSCode | DonJayamanne/pythonVSCode | 2,078 | 358 |
```xml
import {
BladeApi,
BladeController,
Controller,
createBlade,
createValue,
forceCast,
LabeledValueBladeController,
LabelPropsObject,
PlainView,
SliderController,
SliderPropsObject,
ValueMap,
ViewProps,
} from '@tweakpane/core';
import * as assert from 'assert';
import {JSDOM} from 'jsdom';
export function createTestWindow(): Window {
return forceCast(new JSDOM('').window);
}
class LabelableController implements Controller {
public readonly viewProps = ViewProps.create();
public readonly view: PlainView;
constructor(doc: Document) {
this.view = new PlainView(doc, {
viewName: '',
viewProps: this.viewProps,
});
}
}
export function createEmptyLabelableController(doc: Document) {
return new LabelableController(doc);
}
export function createLabeledValueBladeController(doc: Document) {
const vc = new SliderController(doc, {
props: ValueMap.fromObject<SliderPropsObject>({
keyScale: 1,
max: 1,
min: 0,
}),
value: createValue(0),
viewProps: ViewProps.create(),
});
return new LabeledValueBladeController(doc, {
blade: createBlade(),
props: ValueMap.fromObject<LabelPropsObject>({label: ''}),
valueController: vc,
value: vc.value,
});
}
export function createEmptyBladeController(
doc: Document,
): BladeController<PlainView> {
return new BladeController({
blade: createBlade(),
view: new PlainView(doc, {
viewName: '',
viewProps: ViewProps.create(),
}),
viewProps: ViewProps.create(),
});
}
export function assertInitialState(api: BladeApi) {
assert.strictEqual(api.disabled, false);
assert.strictEqual(api.hidden, false);
assert.strictEqual(api.controller.viewProps.get('disposed'), false);
}
export function assertDisposes(api: BladeApi) {
api.dispose();
assert.strictEqual(api.controller.viewProps.get('disposed'), true);
}
export function assertUpdates(api: BladeApi) {
api.disabled = true;
assert.strictEqual(api.disabled, true);
assert.strictEqual(
api.controller.view.element.classList.contains('tp-v-disabled'),
true,
);
api.hidden = true;
assert.strictEqual(api.hidden, true);
assert.strictEqual(
api.controller.view.element.classList.contains('tp-v-hidden'),
true,
);
}
``` | /content/code_sandbox/packages/tweakpane/src/main/ts/misc/test-util.ts | xml | 2016-05-10T15:45:13 | 2024-08-16T19:57:27 | tweakpane | cocopon/tweakpane | 3,480 | 514 |
```xml
import { observer } from "mobx-react-lite"
import { useCallback } from "react"
import { transposeSelection } from "../../actions"
import { useStores } from "../../hooks/useStores"
import { TransposeDialog } from "./TransposeDialog"
export const PianoRollTransposeDialog = observer(() => {
const rootStore = useStores()
const { pianoRollStore } = rootStore
const { openTransposeDialog } = pianoRollStore
const onClose = useCallback(
() => (pianoRollStore.openTransposeDialog = false),
[pianoRollStore],
)
const onClickOK = useCallback(
(value: number) => {
transposeSelection(rootStore)(value)
pianoRollStore.openTransposeDialog = false
},
[pianoRollStore],
)
return (
<TransposeDialog
open={openTransposeDialog}
onClose={onClose}
onClickOK={onClickOK}
/>
)
})
``` | /content/code_sandbox/app/src/components/TransposeDialog/PianoRollTransposeDialog.tsx | xml | 2016-03-06T15:19:53 | 2024-08-15T14:27:10 | signal | ryohey/signal | 1,238 | 198 |
```xml
class Greeter {
greeting: string;
constructor(message: string) {
this.greeting = message;
}
@enumerable(false)
greet() {
return "Hello, " + this.greeting;
}
}
``` | /content/code_sandbox/tests/format/typescript/decorators-ts/method-decorator.ts | xml | 2016-11-29T17:13:37 | 2024-08-16T17:29:57 | prettier | prettier/prettier | 48,913 | 50 |
```xml
// One-time usage file. You can delete me after running the codemod!
function addWithRouterImport(j, root) {
// We create an import specifier, this is the value of an import, eg:
// import {withRouter} from 'next/router
// The specifier would be `withRouter`
const withRouterSpecifier = j.importSpecifier(j.identifier('withRouter'))
// Check if this file is already import `next/router`
// so that we can just attach `withRouter` instead of creating a new `import` node
const originalRouterImport = root.find(j.ImportDeclaration, {
source: {
value: 'next/router',
},
})
if (originalRouterImport.length > 0) {
// Check if `withRouter` is already imported. In that case we don't have to do anything
if (
originalRouterImport.find(j.ImportSpecifier, {
imported: { name: 'withRouter' },
}).length > 0
) {
return
}
// Attach `withRouter` to the existing `next/router` import node
originalRouterImport.forEach((node) => {
node.value.specifiers.push(withRouterSpecifier)
})
return
}
// Create import node
// import {withRouter} from 'next/router'
const withRouterImport = j.importDeclaration(
[withRouterSpecifier],
j.stringLiteral('next/router')
)
// Find the Program, this is the top level AST node
const Program = root.find(j.Program)
// Attach the import at the top of the body
Program.forEach((node) => {
node.value.body.unshift(withRouterImport)
})
}
function getThisPropsUrlNodes(j, tree) {
return tree.find(j.MemberExpression, {
object: {
type: 'MemberExpression',
object: { type: 'ThisExpression' },
property: { name: 'props' },
},
property: { name: 'url' },
})
}
function getPropsUrlNodes(j, tree, name) {
return tree.find(j.MemberExpression, {
object: { name },
property: { name: 'url' },
})
}
// Wraps the provided node in a function call
// For example if `functionName` is `withRouter` it will wrap the provided node in `withRouter(NODE_CONTENT)`
function wrapNodeInFunction(j, functionName, args) {
const mappedArgs = args.map((node) => {
// If the node is a ClassDeclaration we have to turn it into a ClassExpression
// since ClassDeclarations can't be wrapped in a function
if (node.type === 'ClassDeclaration') {
node.type = 'ClassExpression'
}
return node
})
return j.callExpression(j.identifier(functionName), mappedArgs)
}
function turnUrlIntoRouter(j, tree) {
tree.find(j.Identifier, { name: 'url' }).replaceWith(j.identifier('router'))
}
export default function transformer(file, api) {
// j is just a shorthand for the jscodeshift api
const j = api.jscodeshift
// this is the AST root on which we can call methods like `.find`
const root = j(file.source)
// We search for `export default`
const defaultExports = root.find(j.ExportDefaultDeclaration)
// We loop over the `export default` instances
// This is just how jscodeshift works, there can only be one export default instance
defaultExports.forEach((rule) => {
// rule.value is an AST node
const { value: node } = rule
// declaration holds the AST node for what comes after `export default`
const { declaration } = node
function wrapDefaultExportInWithRouter() {
if (
j(rule).find(j.CallExpression, { callee: { name: 'withRouter' } })
.length > 0
) {
return
}
j(rule).replaceWith(
j.exportDefaultDeclaration(
wrapNodeInFunction(j, 'withRouter', [declaration])
)
)
}
// The `Identifier` type is given in this case:
// export default Test
// where `Test` is the identifier
if (declaration.type === 'Identifier') {
// the variable name
const { name } = declaration
// find the implementation of the variable, can be a class, function, etc
let implementation = root.find(j.Declaration, { id: { name } })
if (implementation.length === 0) {
implementation = root.find(j.VariableDeclarator, { id: { name } })
}
implementation
.find(j.Property, { key: { name: 'url' } })
.forEach((propertyRule) => {
const isThisPropsDestructure = j(propertyRule).closest(
j.VariableDeclarator,
{
init: {
object: {
type: 'ThisExpression',
},
property: { name: 'props' },
},
}
)
if (isThisPropsDestructure.length === 0) {
return
}
const originalKeyValue = propertyRule.value.value.name
propertyRule.value.key.name = 'router'
wrapDefaultExportInWithRouter()
addWithRouterImport(j, root)
// If the property is reassigned to another variable we don't have to transform it
if (originalKeyValue !== 'url') {
return
}
propertyRule.value.value.name = 'router'
j(propertyRule)
.closest(j.BlockStatement)
.find(j.Identifier, (identifierNode) => {
if (identifierNode.type === 'JSXIdentifier') {
return false
}
if (identifierNode.name !== 'url') {
return false
}
return true
})
.replaceWith(j.identifier('router'))
})
// Find usage of `this.props.url`
const thisPropsUrlUsage = getThisPropsUrlNodes(j, implementation)
if (thisPropsUrlUsage.length === 0) {
return
}
// rename `url` to `router`
turnUrlIntoRouter(j, thisPropsUrlUsage)
wrapDefaultExportInWithRouter()
addWithRouterImport(j, root)
return
}
const arrowFunctions = j(rule).find(j.ArrowFunctionExpression)
;(() => {
if (arrowFunctions.length === 0) {
return
}
arrowFunctions.forEach((r) => {
// This makes sure we don't match nested functions, only the top one
if (j(r).closest(j.Expression).length !== 0) {
return
}
if (!r.value.params || !r.value.params[0]) {
return
}
const name = r.value.params[0].name
const propsUrlUsage = getPropsUrlNodes(j, j(r), name)
if (propsUrlUsage.length === 0) {
return
}
turnUrlIntoRouter(j, propsUrlUsage)
wrapDefaultExportInWithRouter()
addWithRouterImport(j, root)
})
return
})()
if (declaration.type === 'CallExpression') {
j(rule)
.find(j.CallExpression, (haystack) => {
const firstArgument = haystack.arguments[0] || {}
if (firstArgument.type === 'Identifier') {
return true
}
return false
})
.forEach((callRule) => {
const { name } = callRule.value.arguments[0]
// find the implementation of the variable, can be a class, function, etc
let implementation = root.find(j.Declaration, { id: { name } })
if (implementation.length === 0) {
implementation = root.find(j.VariableDeclarator, { id: { name } })
}
// Find usage of `this.props.url`
const thisPropsUrlUsage = getThisPropsUrlNodes(j, implementation)
implementation
.find(j.Property, { key: { name: 'url' } })
.forEach((propertyRule) => {
const isThisPropsDestructure = j(propertyRule).closest(
j.VariableDeclarator,
{
init: {
object: {
type: 'ThisExpression',
},
property: { name: 'props' },
},
}
)
if (isThisPropsDestructure.length === 0) {
return
}
const originalKeyValue = propertyRule.value.value.name
propertyRule.value.key.name = 'router'
wrapDefaultExportInWithRouter()
addWithRouterImport(j, root)
// If the property is reassigned to another variable we don't have to transform it
if (originalKeyValue !== 'url') {
return
}
propertyRule.value.value.name = 'router'
j(propertyRule)
.closest(j.BlockStatement)
.find(j.Identifier, (identifierNode) => {
if (identifierNode.type === 'JSXIdentifier') {
return false
}
if (identifierNode.name !== 'url') {
return false
}
return true
})
.replaceWith(j.identifier('router'))
})
if (thisPropsUrlUsage.length === 0) {
return
}
// rename `url` to `router`
turnUrlIntoRouter(j, thisPropsUrlUsage)
wrapDefaultExportInWithRouter()
addWithRouterImport(j, root)
return
})
}
j(rule)
.find(j.Property, { key: { name: 'url' } })
.forEach((propertyRule) => {
const isThisPropsDestructure = j(propertyRule).closest(
j.VariableDeclarator,
{
init: {
object: {
type: 'ThisExpression',
},
property: { name: 'props' },
},
}
)
if (isThisPropsDestructure.length === 0) {
return
}
const originalKeyValue = propertyRule.value.value.name
propertyRule.value.key.name = 'router'
wrapDefaultExportInWithRouter()
addWithRouterImport(j, root)
// If the property is reassigned to another variable we don't have to transform it
if (originalKeyValue !== 'url') {
return
}
propertyRule.value.value.name = 'router'
j(propertyRule)
.closest(j.BlockStatement)
.find(j.Identifier, (identifierNode) => {
if (identifierNode.type === 'JSXIdentifier') {
return false
}
if (identifierNode.name !== 'url') {
return false
}
return true
})
.replaceWith(j.identifier('router'))
})
j(rule)
.find(j.MethodDefinition, { key: { name: 'componentWillReceiveProps' } })
.forEach((methodRule) => {
const func = methodRule.value.value
if (!func.params[0]) {
return
}
const firstArgumentName = func.params[0].name
const propsUrlUsage = getPropsUrlNodes(
j,
j(methodRule),
firstArgumentName
)
turnUrlIntoRouter(j, propsUrlUsage)
if (propsUrlUsage.length === 0) {
return
}
wrapDefaultExportInWithRouter()
addWithRouterImport(j, root)
})
j(rule)
.find(j.MethodDefinition, { key: { name: 'componentDidUpdate' } })
.forEach((methodRule) => {
const func = methodRule.value.value
if (!func.params[0]) {
return
}
const firstArgumentName = func.params[0].name
const propsUrlUsage = getPropsUrlNodes(
j,
j(methodRule),
firstArgumentName
)
turnUrlIntoRouter(j, propsUrlUsage)
if (propsUrlUsage.length === 0) {
return
}
wrapDefaultExportInWithRouter()
addWithRouterImport(j, root)
})
const thisPropsUrlUsage = getThisPropsUrlNodes(j, j(rule))
const propsUrlUsage = getPropsUrlNodes(j, j(rule), 'props')
// rename `url` to `router`
turnUrlIntoRouter(j, thisPropsUrlUsage)
turnUrlIntoRouter(j, propsUrlUsage)
if (thisPropsUrlUsage.length === 0 && propsUrlUsage.length === 0) {
return
}
wrapDefaultExportInWithRouter()
addWithRouterImport(j, root)
return
})
return root.toSource()
}
``` | /content/code_sandbox/packages/next-codemod/transforms/url-to-withrouter.ts | xml | 2016-10-05T23:32:51 | 2024-08-16T19:44:30 | next.js | vercel/next.js | 124,056 | 2,715 |
```xml
<!--
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
path_to_url
Unless required by applicable law or agreed to in writing,
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
specific language governing permissions and limitations
-->
<project xmlns="path_to_url" xmlns:xsi="path_to_url"
xsi:schemaLocation="path_to_url path_to_url">
<modelVersion>4.0.0</modelVersion>
<packaging>pom</packaging>
<parent>
<groupId>org.apache.pulsar</groupId>
<artifactId>pulsar</artifactId>
<version>4.0.0-SNAPSHOT</version>
</parent>
<artifactId>pulsar-transaction-parent</artifactId>
<name>Pulsar Transaction :: Parent</name>
<modules>
<module>common</module>
<module>coordinator</module>
</modules>
<build>
<plugins>
<plugin>
<groupId>com.github.spotbugs</groupId>
<artifactId>spotbugs-maven-plugin</artifactId>
<version>${spotbugs-maven-plugin.version}</version>
<executions>
<execution>
<id>spotbugs</id>
<phase>verify</phase>
<goals>
<goal>check</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
<executions>
<execution>
<id>checkstyle</id>
<phase>verify</phase>
<goals>
<goal>check</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
``` | /content/code_sandbox/pulsar-transaction/pom.xml | xml | 2016-06-28T07:00:03 | 2024-08-16T17:12:43 | pulsar | apache/pulsar | 14,047 | 427 |
```xml
import { isDesktopApplication } from '@/Utils'
import {
ApplicationInterface,
IsApplicationUsingThirdPartyHost,
LegacyApiServiceInterface,
Result,
UseCaseInterface,
} from '@standardnotes/snjs'
export class GetPurchaseFlowUrl implements UseCaseInterface<string> {
constructor(
private application: ApplicationInterface,
private legacyApi: LegacyApiServiceInterface,
private isApplicationUsingThirdPartyHostUseCase: IsApplicationUsingThirdPartyHost,
) {}
async execute(): Promise<Result<string>> {
const currentUrl = window.location.origin
const successUrl = isDesktopApplication() ? 'standardnotes://' : currentUrl
const isThirdPartyHostUsedOrError = this.isApplicationUsingThirdPartyHostUseCase.execute()
if (isThirdPartyHostUsedOrError.isFailed()) {
return Result.fail(isThirdPartyHostUsedOrError.getError()!)
}
const isThirdPartyHostUsed = isThirdPartyHostUsedOrError.getValue()
if (this.application.sessions.isSignedOut() || isThirdPartyHostUsed) {
return Result.ok(`${window.purchaseUrl}/offline?&success_url=${successUrl}`)
}
const token = await this.legacyApi.getNewSubscriptionToken()
if (token) {
return Result.ok(`${window.purchaseUrl}?subscription_token=${token}&success_url=${successUrl}`)
}
return Result.fail('Could not get purchase flow URL.')
}
}
``` | /content/code_sandbox/packages/web/src/javascripts/Application/UseCase/GetPurchaseFlowUrl.ts | xml | 2016-12-05T23:31:33 | 2024-08-16T06:51:19 | app | standardnotes/app | 5,180 | 300 |
```xml
<?xml version="1.0" encoding="UTF-8"?>
<document filename="bm_eu-015-str.xml">
<table id="1">
<region col-increment="0" id="1" row-increment="0" page='1'>
<cell id="1" start-col="0" start-row="0">
<bounding-box x1="60" x2="82" y1="742" y2="752"/>
<content>Topic</content>
<instruction instr-id="51" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="0">
<bounding-box x1="310" x2="349" y1="742" y2="752"/>
<content>Enquiries</content>
<instruction instr-id="51" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="1">
<bounding-box x1="60" x2="120" y1="723" y2="734"/>
<content>EU Institutions</content>
<instruction instr-id="56" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="1">
<bounding-box x1="333" x2="356" y1="724" y2="735"/>
<content>3.597</content>
<instruction instr-id="60" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="2">
<bounding-box x1="60" x2="187" y1="705" y2="715"/>
<content>EU general and Member States</content>
<instruction instr-id="64" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="2">
<bounding-box x1="333" x2="356" y1="706" y2="716"/>
<content>1.847</content>
<instruction instr-id="68" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="3">
<bounding-box x1="60" x2="268" y1="686" y2="697"/>
<content>Employment, social affairs and equal opportunities</content>
<instruction instr-id="72" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="3">
<bounding-box x1="333" x2="356" y1="688" y2="698"/>
<content>1.783</content>
<instruction instr-id="76" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="4">
<bounding-box x1="60" x2="145" y1="668" y2="678"/>
<content>Air passengers rights</content>
<instruction instr-id="80" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="4">
<bounding-box x1="333" x2="356" y1="669" y2="679"/>
<content>1.726</content>
<instruction instr-id="84" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="5">
<bounding-box x1="60" x2="179" y1="649" y2="660"/>
<content>Justice Freedom and Security</content>
<instruction instr-id="88" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="5">
<bounding-box x1="333" x2="356" y1="651" y2="661"/>
<content>1.451</content>
<instruction instr-id="92" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="6">
<bounding-box x1="60" x2="219" y1="631" y2="641"/>
<content>Consumer / Food safety / Public health</content>
<instruction instr-id="96" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="6">
<bounding-box x1="333" x2="356" y1="632" y2="642"/>
<content>1.241</content>
<instruction instr-id="100" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="7">
<bounding-box x1="60" x2="156" y1="613" y2="623"/>
<content>Enterprise and industry</content>
<instruction instr-id="104" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="7">
<bounding-box x1="333" x2="356" y1="614" y2="624"/>
<content>1.215</content>
<instruction instr-id="108" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="8">
<bounding-box x1="60" x2="206" y1="594" y2="604"/>
<content>External relations and development</content>
<instruction instr-id="112" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="8">
<bounding-box x1="340" x2="356" y1="595" y2="605"/>
<content>732</content>
<instruction instr-id="116" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="9">
<bounding-box x1="60" x2="175" y1="576" y2="586"/>
<content>Education / Training / Youth</content>
<instruction instr-id="120" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="9">
<bounding-box x1="340" x2="356" y1="577" y2="587"/>
<content>714</content>
<instruction instr-id="124" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="10">
<bounding-box x1="60" x2="149" y1="557" y2="567"/>
<content>Customs and taxation</content>
<instruction instr-id="128" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="10">
<bounding-box x1="340" x2="356" y1="558" y2="568"/>
<content>556</content>
<instruction instr-id="132" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="11">
<bounding-box x1="60" x2="81" y1="539" y2="549"/>
<content>Total</content>
<instruction instr-id="137" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="11">
<bounding-box x1="324" x2="352" y1="539" y2="549"/>
<content>14.862</content>
<instruction instr-id="137" subinstr-id="2"/>
</cell>
</region>
</table>
<table id="2">
<region col-increment="0" id="1" row-increment="0" page='1'>
<cell id="1" start-col="0" start-row="0">
<bounding-box x1="60" x2="82" y1="511" y2="521"/>
<content>Topic</content>
<instruction instr-id="147" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="0">
<bounding-box x1="310" x2="349" y1="511" y2="521"/>
<content>Enquiries</content>
<instruction instr-id="147" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="1">
<bounding-box x1="60" x2="303" y1="430" y2="506"/>
<content>Other specific policies including Competition, External
trade, Enlargement, Agriculture and rural development,
Regional policy, Information Society and media, Culture,
Economic and monetary affairs, Research and innovation,
Fisheries and maritime affairs, Internal Market and services
and Environment</content>
<instruction instr-id="152" subinstr-id="-1"/>
<instruction instr-id="156" subinstr-id="-1"/>
<instruction instr-id="159" subinstr-id="-1"/>
<instruction instr-id="162" subinstr-id="-1"/>
<instruction instr-id="165" subinstr-id="-1"/>
<instruction instr-id="168" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="1">
<bounding-box x1="333" x2="356" y1="463" y2="474"/>
<content>4.330</content>
<instruction instr-id="172" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="2">
<bounding-box x1="60" x2="72" y1="411" y2="421"/>
<content>EIT</content>
<instruction instr-id="176" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="2">
<bounding-box x1="340" x2="356" y1="413" y2="424"/>
<content>119</content>
<instruction instr-id="180" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="3">
<bounding-box x1="60" x2="162" y1="392" y2="402"/>
<content>Research enquiry service</content>
<instruction instr-id="184" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="3">
<bounding-box x1="333" x2="356" y1="395" y2="405"/>
<content>2.003</content>
<instruction instr-id="188" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="4">
<bounding-box x1="60" x2="127" y1="374" y2="384"/>
<content>Export Helpdesk</content>
<instruction instr-id="192" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="4">
<bounding-box x1="340" x2="356" y1="376" y2="386"/>
<content>169</content>
<instruction instr-id="196" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="5">
<bounding-box x1="60" x2="307" y1="321" y2="371"/>
<content>Practicalities (Including complaints, OPOCE, mission, history,
issues not related to the EU, bilateral agreements, national
authorities, request for contact details and request for
clarification)</content>
<instruction instr-id="200" subinstr-id="-1"/>
<instruction instr-id="204" subinstr-id="-1"/>
<instruction instr-id="207" subinstr-id="-1"/>
<instruction instr-id="210" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="5">
<bounding-box x1="333" x2="356" y1="340" y2="351"/>
<content>2.417</content>
<instruction instr-id="214" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="6">
<bounding-box x1="60" x2="109" y1="308" y2="318"/>
<content>Grand Total</content>
<instruction instr-id="219" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="6">
<bounding-box x1="324" x2="352" y1="308" y2="318"/>
<content>23.900</content>
<instruction instr-id="219" subinstr-id="2"/>
</cell>
</region>
</table>
<table id="3">
<region col-increment="0" id="1" row-increment="0" page='2'>
<cell id="1" start-col="0" start-row="0">
<bounding-box x1="58" x2="123" y1="745" y2="752"/>
<content>Airpassengersrights</content>
<instruction instr-id="65" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="0">
<bounding-box x1="137" x2="166" y1="745" y2="752"/>
<content>Enquiries</content>
<instruction instr-id="65" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="1">
<bounding-box x1="58" x2="74" y1="735" y2="742"/>
<content>Spain</content>
<instruction instr-id="94" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="1">
<bounding-box x1="158" x2="170" y1="735" y2="742"/>
<content>268</content>
<instruction instr-id="94" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="2">
<bounding-box x1="58" x2="86" y1="725" y2="733"/>
<content>Germany</content>
<instruction instr-id="97" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="2">
<bounding-box x1="158" x2="170" y1="725" y2="733"/>
<content>233</content>
<instruction instr-id="97" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="3">
<bounding-box x1="58" x2="107" y1="715" y2="723"/>
<content>UnitedKingdom</content>
<instruction instr-id="100" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="3">
<bounding-box x1="158" x2="170" y1="715" y2="723"/>
<content>139</content>
<instruction instr-id="100" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="4">
<bounding-box x1="58" x2="78" y1="705" y2="713"/>
<content>France</content>
<instruction instr-id="103" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="4">
<bounding-box x1="158" x2="170" y1="705" y2="713"/>
<content>136</content>
<instruction instr-id="103" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="5">
<bounding-box x1="58" x2="71" y1="696" y2="703"/>
<content>Italy</content>
<instruction instr-id="106" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="5">
<bounding-box x1="162" x2="170" y1="696" y2="703"/>
<content>92</content>
<instruction instr-id="106" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="6">
<bounding-box x1="58" x2="95" y1="686" y2="693"/>
<content>Netherlands</content>
<instruction instr-id="109" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="6">
<bounding-box x1="162" x2="170" y1="686" y2="693"/>
<content>79</content>
<instruction instr-id="109" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="7">
<bounding-box x1="58" x2="82" y1="676" y2="683"/>
<content>Belgium</content>
<instruction instr-id="112" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="7">
<bounding-box x1="162" x2="170" y1="676" y2="683"/>
<content>66</content>
<instruction instr-id="112" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="8">
<bounding-box x1="58" x2="84" y1="666" y2="674"/>
<content>Portugal</content>
<instruction instr-id="115" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="8">
<bounding-box x1="162" x2="170" y1="666" y2="674"/>
<content>44</content>
<instruction instr-id="115" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="9">
<bounding-box x1="58" x2="79" y1="656" y2="664"/>
<content>Austria</content>
<instruction instr-id="118" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="9">
<bounding-box x1="162" x2="170" y1="656" y2="664"/>
<content>28</content>
<instruction instr-id="118" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="10">
<bounding-box x1="58" x2="80" y1="646" y2="654"/>
<content>Finland</content>
<instruction instr-id="121" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="10">
<bounding-box x1="162" x2="170" y1="646" y2="654"/>
<content>25</content>
<instruction instr-id="121" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="11">
<bounding-box x1="58" x2="79" y1="637" y2="644"/>
<content>Greece</content>
<instruction instr-id="124" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="11">
<bounding-box x1="162" x2="170" y1="637" y2="644"/>
<content>22</content>
<instruction instr-id="124" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="12">
<bounding-box x1="58" x2="79" y1="627" y2="634"/>
<content>Ireland</content>
<instruction instr-id="127" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="12">
<bounding-box x1="162" x2="170" y1="627" y2="634"/>
<content>14</content>
<instruction instr-id="127" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="13">
<bounding-box x1="58" x2="86" y1="617" y2="624"/>
<content>Denmark</content>
<instruction instr-id="130" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="13">
<bounding-box x1="162" x2="170" y1="617" y2="624"/>
<content>12</content>
<instruction instr-id="130" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="14">
<bounding-box x1="58" x2="82" y1="607" y2="615"/>
<content>Sweden</content>
<instruction instr-id="133" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="14">
<bounding-box x1="162" x2="170" y1="607" y2="615"/>
<content>11</content>
<instruction instr-id="133" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="15">
<bounding-box x1="58" x2="96" y1="597" y2="605"/>
<content>Luxembourg</content>
<instruction instr-id="136" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="15">
<bounding-box x1="166" x2="170" y1="597" y2="605"/>
<content>9</content>
<instruction instr-id="136" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="16">
<bounding-box x1="58" x2="94" y1="587" y2="595"/>
<content>TotalEU-15</content>
<instruction instr-id="140" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="16">
<bounding-box x1="152" x2="170" y1="587" y2="595"/>
<content>1.178</content>
<instruction instr-id="140" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="17">
<bounding-box x1="58" x2="83" y1="577" y2="585"/>
<content>Hungary</content>
<instruction instr-id="144" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="17">
<bounding-box x1="162" x2="170" y1="577" y2="585"/>
<content>17</content>
<instruction instr-id="144" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="18">
<bounding-box x1="58" x2="85" y1="568" y2="575"/>
<content>Romania</content>
<instruction instr-id="147" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="18">
<bounding-box x1="162" x2="170" y1="568" y2="575"/>
<content>16</content>
<instruction instr-id="147" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="19">
<bounding-box x1="58" x2="79" y1="558" y2="565"/>
<content>Cyprus</content>
<instruction instr-id="150" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="19">
<bounding-box x1="162" x2="170" y1="558" y2="565"/>
<content>12</content>
<instruction instr-id="150" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="20">
<bounding-box x1="58" x2="83" y1="548" y2="556"/>
<content>Bulgaria</content>
<instruction instr-id="153" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="20">
<bounding-box x1="166" x2="170" y1="548" y2="556"/>
<content>9</content>
<instruction instr-id="153" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="21">
<bounding-box x1="58" x2="104" y1="538" y2="546"/>
<content>CzechRepublic</content>
<instruction instr-id="156" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="21">
<bounding-box x1="166" x2="170" y1="538" y2="546"/>
<content>7</content>
<instruction instr-id="156" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="22">
<bounding-box x1="58" x2="80" y1="528" y2="536"/>
<content>Estonia</content>
<instruction instr-id="159" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="22">
<bounding-box x1="166" x2="170" y1="528" y2="536"/>
<content>7</content>
<instruction instr-id="159" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="23">
<bounding-box x1="58" x2="79" y1="518" y2="526"/>
<content>Poland</content>
<instruction instr-id="162" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="23">
<bounding-box x1="166" x2="170" y1="518" y2="526"/>
<content>7</content>
<instruction instr-id="162" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="24">
<bounding-box x1="58" x2="76" y1="509" y2="516"/>
<content>Malta</content>
<instruction instr-id="165" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="24">
<bounding-box x1="166" x2="170" y1="509" y2="516"/>
<content>5</content>
<instruction instr-id="165" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="25">
<bounding-box x1="58" x2="76" y1="499" y2="506"/>
<content>Latvia</content>
<instruction instr-id="168" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="25">
<bounding-box x1="166" x2="170" y1="499" y2="506"/>
<content>3</content>
<instruction instr-id="168" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="26">
<bounding-box x1="58" x2="83" y1="489" y2="496"/>
<content>Slovakia</content>
<instruction instr-id="171" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="26">
<bounding-box x1="166" x2="170" y1="489" y2="496"/>
<content>3</content>
<instruction instr-id="171" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="27">
<bounding-box x1="58" x2="83" y1="479" y2="487"/>
<content>Slovenia</content>
<instruction instr-id="174" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="27">
<bounding-box x1="166" x2="170" y1="479" y2="487"/>
<content>2</content>
<instruction instr-id="174" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="28">
<bounding-box x1="58" x2="94" y1="469" y2="477"/>
<content>TotalEU-12</content>
<instruction instr-id="178" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="28">
<bounding-box x1="162" x2="170" y1="469" y2="477"/>
<content>88</content>
<instruction instr-id="178" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="29">
<bounding-box x1="58" x2="80" y1="459" y2="467"/>
<content>non-EU</content>
<instruction instr-id="187" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="29">
<bounding-box x1="162" x2="170" y1="459" y2="467"/>
<content>97</content>
<instruction instr-id="187" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="30">
<bounding-box x1="58" x2="94" y1="450" y2="457"/>
<content>Unspecified</content>
<instruction instr-id="197" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="30">
<bounding-box x1="158" x2="170" y1="450" y2="457"/>
<content>363</content>
<instruction instr-id="197" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="31">
<bounding-box x1="58" x2="95" y1="440" y2="447"/>
<content>GrandTotal</content>
<instruction instr-id="201" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="31">
<bounding-box x1="152" x2="170" y1="440" y2="447"/>
<content>1.726</content>
<instruction instr-id="201" subinstr-id="2"/>
</cell>
</region>
</table>
<table id="4">
<region col-increment="0" id="1" row-increment="0" page='2'>
<cell id="1" start-col="0" start-row="0">
<bounding-box x1="184" x2="242" y1="745" y2="762"/>
<content>Freemovementof
persons/workers</content>
<instruction instr-id="69" subinstr-id="-1"/>
<instruction instr-id="73" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="0">
<bounding-box x1="264" x2="293" y1="745" y2="752"/>
<content>Enquiries</content>
<instruction instr-id="77" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="1">
<bounding-box x1="184" x2="201" y1="735" y2="742"/>
<content>Spain</content>
<instruction instr-id="94" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="1">
<bounding-box x1="285" x2="297" y1="735" y2="742"/>
<content>153</content>
<instruction instr-id="94" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="2">
<bounding-box x1="184" x2="213" y1="725" y2="733"/>
<content>Germany</content>
<instruction instr-id="97" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="2">
<bounding-box x1="285" x2="297" y1="725" y2="733"/>
<content>119</content>
<instruction instr-id="97" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="3">
<bounding-box x1="184" x2="234" y1="715" y2="723"/>
<content>UnitedKingdom</content>
<instruction instr-id="100" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="3">
<bounding-box x1="285" x2="297" y1="715" y2="723"/>
<content>114</content>
<instruction instr-id="100" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="4">
<bounding-box x1="184" x2="205" y1="705" y2="713"/>
<content>France</content>
<instruction instr-id="103" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="4">
<bounding-box x1="289" x2="297" y1="705" y2="713"/>
<content>99</content>
<instruction instr-id="103" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="5">
<bounding-box x1="184" x2="198" y1="696" y2="703"/>
<content>Italy</content>
<instruction instr-id="106" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="5">
<bounding-box x1="289" x2="297" y1="696" y2="703"/>
<content>82</content>
<instruction instr-id="106" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="6">
<bounding-box x1="184" x2="209" y1="686" y2="693"/>
<content>Belgium</content>
<instruction instr-id="109" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="6">
<bounding-box x1="289" x2="297" y1="686" y2="693"/>
<content>49</content>
<instruction instr-id="109" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="7">
<bounding-box x1="184" x2="222" y1="676" y2="683"/>
<content>Netherlands</content>
<instruction instr-id="112" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="7">
<bounding-box x1="289" x2="297" y1="676" y2="683"/>
<content>45</content>
<instruction instr-id="112" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="8">
<bounding-box x1="184" x2="206" y1="666" y2="674"/>
<content>Greece</content>
<instruction instr-id="115" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="8">
<bounding-box x1="289" x2="297" y1="666" y2="674"/>
<content>40</content>
<instruction instr-id="115" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="9">
<bounding-box x1="184" x2="210" y1="656" y2="664"/>
<content>Portugal</content>
<instruction instr-id="118" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="9">
<bounding-box x1="289" x2="297" y1="656" y2="664"/>
<content>26</content>
<instruction instr-id="118" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="10">
<bounding-box x1="184" x2="206" y1="646" y2="654"/>
<content>Ireland</content>
<instruction instr-id="121" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="10">
<bounding-box x1="289" x2="297" y1="646" y2="654"/>
<content>23</content>
<instruction instr-id="121" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="11">
<bounding-box x1="184" x2="206" y1="637" y2="644"/>
<content>Austria</content>
<instruction instr-id="124" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="11">
<bounding-box x1="289" x2="297" y1="637" y2="644"/>
<content>22</content>
<instruction instr-id="124" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="12">
<bounding-box x1="184" x2="209" y1="627" y2="634"/>
<content>Sweden</content>
<instruction instr-id="127" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="12">
<bounding-box x1="289" x2="297" y1="627" y2="634"/>
<content>20</content>
<instruction instr-id="127" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="13">
<bounding-box x1="184" x2="207" y1="617" y2="624"/>
<content>Finland</content>
<instruction instr-id="130" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="13">
<bounding-box x1="289" x2="297" y1="617" y2="624"/>
<content>10</content>
<instruction instr-id="130" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="14">
<bounding-box x1="184" x2="213" y1="607" y2="615"/>
<content>Denmark</content>
<instruction instr-id="133" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="14">
<bounding-box x1="293" x2="297" y1="607" y2="615"/>
<content>9</content>
<instruction instr-id="133" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="15">
<bounding-box x1="184" x2="223" y1="597" y2="605"/>
<content>Luxembourg</content>
<instruction instr-id="136" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="15">
<bounding-box x1="293" x2="297" y1="597" y2="605"/>
<content>2</content>
<instruction instr-id="136" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="16">
<bounding-box x1="184" x2="221" y1="587" y2="595"/>
<content>TotalEU-15</content>
<instruction instr-id="140" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="16">
<bounding-box x1="285" x2="297" y1="587" y2="595"/>
<content>813</content>
<instruction instr-id="140" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="17">
<bounding-box x1="184" x2="209" y1="577" y2="585"/>
<content>Bulgaria</content>
<instruction instr-id="144" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="17">
<bounding-box x1="289" x2="297" y1="577" y2="585"/>
<content>32</content>
<instruction instr-id="144" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="18">
<bounding-box x1="184" x2="211" y1="568" y2="575"/>
<content>Romania</content>
<instruction instr-id="147" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="18">
<bounding-box x1="289" x2="297" y1="568" y2="575"/>
<content>30</content>
<instruction instr-id="147" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="19">
<bounding-box x1="184" x2="205" y1="558" y2="565"/>
<content>Cyprus</content>
<instruction instr-id="150" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="19">
<bounding-box x1="289" x2="297" y1="558" y2="565"/>
<content>22</content>
<instruction instr-id="150" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="20">
<bounding-box x1="184" x2="206" y1="548" y2="556"/>
<content>Poland</content>
<instruction instr-id="153" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="20">
<bounding-box x1="289" x2="297" y1="548" y2="556"/>
<content>20</content>
<instruction instr-id="153" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="21">
<bounding-box x1="184" x2="230" y1="538" y2="546"/>
<content>CzechRepublic</content>
<instruction instr-id="156" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="21">
<bounding-box x1="289" x2="297" y1="538" y2="546"/>
<content>12</content>
<instruction instr-id="156" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="22">
<bounding-box x1="184" x2="210" y1="528" y2="536"/>
<content>Hungary</content>
<instruction instr-id="159" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="22">
<bounding-box x1="289" x2="297" y1="528" y2="536"/>
<content>11</content>
<instruction instr-id="159" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="23">
<bounding-box x1="184" x2="203" y1="518" y2="526"/>
<content>Latvia</content>
<instruction instr-id="162" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="23">
<bounding-box x1="289" x2="297" y1="518" y2="526"/>
<content>11</content>
<instruction instr-id="162" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="24">
<bounding-box x1="184" x2="209" y1="509" y2="516"/>
<content>Slovakia</content>
<instruction instr-id="165" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="24">
<bounding-box x1="293" x2="297" y1="509" y2="516"/>
<content>8</content>
<instruction instr-id="165" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="25">
<bounding-box x1="184" x2="213" y1="499" y2="506"/>
<content>Lithuania</content>
<instruction instr-id="168" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="25">
<bounding-box x1="293" x2="297" y1="499" y2="506"/>
<content>7</content>
<instruction instr-id="168" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="26">
<bounding-box x1="184" x2="207" y1="489" y2="496"/>
<content>Estonia</content>
<instruction instr-id="171" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="26">
<bounding-box x1="293" x2="297" y1="489" y2="496"/>
<content>4</content>
<instruction instr-id="171" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="27">
<bounding-box x1="184" x2="210" y1="479" y2="487"/>
<content>Slovenia</content>
<instruction instr-id="174" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="27">
<bounding-box x1="293" x2="297" y1="479" y2="487"/>
<content>2</content>
<instruction instr-id="174" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="28">
<bounding-box x1="184" x2="202" y1="469" y2="477"/>
<content>Malta</content>
<instruction instr-id="183" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="28">
<bounding-box x1="293" x2="297" y1="469" y2="477"/>
<content>1</content>
<instruction instr-id="183" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="29">
<bounding-box x1="184" x2="221" y1="459" y2="467"/>
<content>TotalEU-12</content>
<instruction instr-id="192" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="29">
<bounding-box x1="285" x2="297" y1="459" y2="467"/>
<content>159</content>
<instruction instr-id="192" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="30">
<bounding-box x1="184" x2="207" y1="450" y2="457"/>
<content>non-EU</content>
<instruction instr-id="197" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="30">
<bounding-box x1="285" x2="297" y1="450" y2="457"/>
<content>102</content>
<instruction instr-id="197" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="31">
<bounding-box x1="184" x2="221" y1="440" y2="447"/>
<content>Unspecified</content>
<instruction instr-id="206" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="31">
<bounding-box x1="285" x2="297" y1="440" y2="447"/>
<content>182</content>
<instruction instr-id="206" subinstr-id="2"/>
</cell>
<cell id="1" start-col="0" start-row="32">
<bounding-box x1="184" x2="222" y1="430" y2="437"/>
<content>GrandTotal</content>
<instruction instr-id="211" subinstr-id="0"/>
</cell>
<cell id="1" start-col="1" start-row="32">
<bounding-box x1="279" x2="297" y1="430" y2="437"/>
<content>1.256</content>
<instruction instr-id="211" subinstr-id="2"/>
</cell>
</region>
</table>
<table id="5">
<region col-increment="0" id="1" row-increment="0" page='2'>
<cell id="1" start-col="0" start-row="0">
<bounding-box x1="316" x2="382" y1="745" y2="762"/>
<content>Treatyreform/IGC/
LisbonTreaty</content>
<instruction instr-id="81" subinstr-id="-1"/>
<instruction instr-id="85" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="1" start-row="0">
<bounding-box x1="395" x2="424" y1="745" y2="752"/>
<content>Enquiries</content>
<instruction instr-id="89" subinstr-id="-1"/>
</cell>
<cell id="1" start-col="0" start-row="1">
<bounding-box x1="316" x2="344" y1="735" y2="742"/>
<content>Germany</content>
<instruction instr-id="94" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="1">
<bounding-box x1="420" x2="428" y1="735" y2="742"/>
<content>91</content>
<instruction instr-id="94" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="2">
<bounding-box x1="316" x2="332" y1="725" y2="733"/>
<content>Spain</content>
<instruction instr-id="97" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="2">
<bounding-box x1="420" x2="428" y1="725" y2="733"/>
<content>85</content>
<instruction instr-id="97" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="3">
<bounding-box x1="316" x2="365" y1="715" y2="723"/>
<content>UnitedKingdom</content>
<instruction instr-id="100" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="3">
<bounding-box x1="420" x2="428" y1="715" y2="723"/>
<content>74</content>
<instruction instr-id="100" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="4">
<bounding-box x1="316" x2="340" y1="705" y2="713"/>
<content>Belgium</content>
<instruction instr-id="103" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="4">
<bounding-box x1="420" x2="428" y1="705" y2="713"/>
<content>56</content>
<instruction instr-id="103" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="5">
<bounding-box x1="316" x2="336" y1="696" y2="703"/>
<content>France</content>
<instruction instr-id="106" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="5">
<bounding-box x1="420" x2="428" y1="696" y2="703"/>
<content>46</content>
<instruction instr-id="106" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="6">
<bounding-box x1="316" x2="329" y1="686" y2="693"/>
<content>Italy</content>
<instruction instr-id="109" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="6">
<bounding-box x1="420" x2="428" y1="686" y2="693"/>
<content>37</content>
<instruction instr-id="109" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="7">
<bounding-box x1="316" x2="353" y1="676" y2="683"/>
<content>Netherlands</content>
<instruction instr-id="112" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="7">
<bounding-box x1="420" x2="428" y1="676" y2="683"/>
<content>37</content>
<instruction instr-id="112" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="8">
<bounding-box x1="316" x2="337" y1="666" y2="674"/>
<content>Ireland</content>
<instruction instr-id="115" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="8">
<bounding-box x1="420" x2="428" y1="666" y2="674"/>
<content>29</content>
<instruction instr-id="115" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="9">
<bounding-box x1="316" x2="337" y1="656" y2="664"/>
<content>Austria</content>
<instruction instr-id="118" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="9">
<bounding-box x1="420" x2="428" y1="656" y2="664"/>
<content>17</content>
<instruction instr-id="118" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="10">
<bounding-box x1="316" x2="340" y1="646" y2="654"/>
<content>Sweden</content>
<instruction instr-id="121" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="10">
<bounding-box x1="420" x2="428" y1="646" y2="654"/>
<content>16</content>
<instruction instr-id="121" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="11">
<bounding-box x1="316" x2="342" y1="637" y2="644"/>
<content>Portugal</content>
<instruction instr-id="124" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="11">
<bounding-box x1="420" x2="428" y1="637" y2="644"/>
<content>11</content>
<instruction instr-id="124" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="12">
<bounding-box x1="316" x2="338" y1="627" y2="634"/>
<content>Finland</content>
<instruction instr-id="127" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="12">
<bounding-box x1="424" x2="428" y1="627" y2="634"/>
<content>9</content>
<instruction instr-id="127" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="13">
<bounding-box x1="316" x2="344" y1="617" y2="624"/>
<content>Denmark</content>
<instruction instr-id="130" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="13">
<bounding-box x1="424" x2="428" y1="617" y2="624"/>
<content>5</content>
<instruction instr-id="130" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="14">
<bounding-box x1="316" x2="337" y1="607" y2="615"/>
<content>Greece</content>
<instruction instr-id="133" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="14">
<bounding-box x1="424" x2="428" y1="607" y2="615"/>
<content>5</content>
<instruction instr-id="133" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="15">
<bounding-box x1="316" x2="354" y1="597" y2="605"/>
<content>Luxembourg</content>
<instruction instr-id="136" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="15">
<bounding-box x1="424" x2="428" y1="597" y2="605"/>
<content>4</content>
<instruction instr-id="136" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="16">
<bounding-box x1="316" x2="352" y1="587" y2="595"/>
<content>TotalEU-15</content>
<instruction instr-id="140" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="16">
<bounding-box x1="416" x2="428" y1="587" y2="595"/>
<content>522</content>
<instruction instr-id="140" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="17">
<bounding-box x1="316" x2="337" y1="577" y2="585"/>
<content>Poland</content>
<instruction instr-id="144" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="17">
<bounding-box x1="420" x2="428" y1="577" y2="585"/>
<content>29</content>
<instruction instr-id="144" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="18">
<bounding-box x1="316" x2="362" y1="568" y2="575"/>
<content>CzechRepublic</content>
<instruction instr-id="147" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="18">
<bounding-box x1="420" x2="428" y1="568" y2="575"/>
<content>13</content>
<instruction instr-id="147" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="19">
<bounding-box x1="316" x2="343" y1="558" y2="565"/>
<content>Romania</content>
<instruction instr-id="150" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="19">
<bounding-box x1="420" x2="428" y1="558" y2="565"/>
<content>12</content>
<instruction instr-id="150" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="20">
<bounding-box x1="316" x2="337" y1="548" y2="556"/>
<content>Cyprus</content>
<instruction instr-id="153" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="20">
<bounding-box x1="424" x2="428" y1="548" y2="556"/>
<content>9</content>
<instruction instr-id="153" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="21">
<bounding-box x1="316" x2="341" y1="538" y2="546"/>
<content>Hungary</content>
<instruction instr-id="156" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="21">
<bounding-box x1="424" x2="428" y1="538" y2="546"/>
<content>9</content>
<instruction instr-id="156" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="22">
<bounding-box x1="316" x2="341" y1="528" y2="536"/>
<content>Bulgaria</content>
<instruction instr-id="159" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="22">
<bounding-box x1="424" x2="428" y1="528" y2="536"/>
<content>6</content>
<instruction instr-id="159" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="23">
<bounding-box x1="316" x2="344" y1="518" y2="526"/>
<content>Lithuania</content>
<instruction instr-id="162" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="23">
<bounding-box x1="424" x2="428" y1="518" y2="526"/>
<content>6</content>
<instruction instr-id="162" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="24">
<bounding-box x1="316" x2="334" y1="509" y2="516"/>
<content>Latvia</content>
<instruction instr-id="165" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="24">
<bounding-box x1="424" x2="428" y1="509" y2="516"/>
<content>4</content>
<instruction instr-id="165" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="25">
<bounding-box x1="316" x2="338" y1="499" y2="506"/>
<content>Estonia</content>
<instruction instr-id="168" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="25">
<bounding-box x1="424" x2="428" y1="499" y2="506"/>
<content>3</content>
<instruction instr-id="168" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="26">
<bounding-box x1="316" x2="341" y1="489" y2="496"/>
<content>Slovakia</content>
<instruction instr-id="171" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="26">
<bounding-box x1="424" x2="428" y1="489" y2="496"/>
<content>3</content>
<instruction instr-id="171" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="27">
<bounding-box x1="316" x2="341" y1="479" y2="487"/>
<content>Slovenia</content>
<instruction instr-id="174" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="27">
<bounding-box x1="424" x2="428" y1="479" y2="487"/>
<content>2</content>
<instruction instr-id="174" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="28">
<bounding-box x1="316" x2="334" y1="469" y2="477"/>
<content>Malta</content>
<instruction instr-id="183" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="28">
<bounding-box x1="424" x2="428" y1="469" y2="477"/>
<content>1</content>
<instruction instr-id="183" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="29">
<bounding-box x1="316" x2="352" y1="459" y2="467"/>
<content>TotalEU-12</content>
<instruction instr-id="192" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="29">
<bounding-box x1="420" x2="428" y1="459" y2="467"/>
<content>97</content>
<instruction instr-id="192" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="30">
<bounding-box x1="316" x2="338" y1="450" y2="457"/>
<content>non-EU</content>
<instruction instr-id="197" subinstr-id="8"/>
</cell>
<cell id="1" start-col="1" start-row="30">
<bounding-box x1="420" x2="428" y1="450" y2="457"/>
<content>40</content>
<instruction instr-id="197" subinstr-id="10"/>
</cell>
<cell id="1" start-col="0" start-row="31">
<bounding-box x1="316" x2="352" y1="440" y2="447"/>
<content>Unspecified</content>
<instruction instr-id="206" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="31">
<bounding-box x1="416" x2="428" y1="440" y2="447"/>
<content>196</content>
<instruction instr-id="206" subinstr-id="6"/>
</cell>
<cell id="1" start-col="0" start-row="32">
<bounding-box x1="316" x2="353" y1="430" y2="437"/>
<content>GrandTotal</content>
<instruction instr-id="211" subinstr-id="4"/>
</cell>
<cell id="1" start-col="1" start-row="32">
<bounding-box x1="416" x2="428" y1="430" y2="437"/>
<content>855</content>
<instruction instr-id="211" subinstr-id="6"/>
</cell>
</region>
</table>
</document>
``` | /content/code_sandbox/tests/files/tabula/icdar2013-dataset/competition-dataset-eu/eu-015-str.xml | xml | 2016-06-18T11:48:49 | 2024-08-15T18:32:02 | camelot | atlanhq/camelot | 3,628 | 16,304 |
```xml
import WebSocket from "ws"
import { Command } from "./command"
export interface PfxServerOptions {
/**
* Path to a PFX file.
*/
pathToPfx: string
/**
* Passphrase, if required, of the PFX file.
*/
passphrase?: string
}
export interface CertServerOptions {
/**
* Path to a signing cert file.
*/
pathToCert: string
/**
* Path to a the corresponding key of the cert file.
*/
pathToKey: string
/**
* Passphrase, if required, of the key file.
*/
passphrase?: string
}
export type WssServerOptions = PfxServerOptions | CertServerOptions
/**
* Configuration options for the Reactotron server.
*/
export interface ServerOptions {
/**
* Which port to listen to. Default: 9090.
*/
port: number
/**
* Web Socket Secure Configuration
*/
wss?: WssServerOptions
}
/**
* A client which is in the process of connecting.
*/
export interface PartialConnection {
/**
* The unique id of the client.
*/
id: number
/**
* The ip address.
*/
address: string
/**
* The connecting web socket.
*/
socket: WebSocket
}
/**
* One of the events which be subscribed to.
*/
export const ServerEvent = {
/**
* When a command arrives from a client.
*/
command: "command",
/**
* The server has started.
*/
start: "start",
/**
* The server has stopped.
*/
stop: "stop",
/**
* A client has connected.
*/
connect: "connect",
/**
* A client has connected and provided us the initial detail we want.
*/
connectionEstablished: "connectionEstablished",
/**
* A client has disconnected.
*/
disconnect: "disconnect",
/**
* Port is already in use
*/
portUnavailable: "portUnavailable",
} as const
export type ServerEventKey = keyof typeof ServerEvent
type StartPayload = any
type StopPayload = any
type ConnectPayload = PartialConnection
type ConnectionEstablishedPayload = any
type DisconnectPayload = any
type PortUnavailablePayload = any
export type ServerEventMap = {
[ServerEvent.command]: Command
[ServerEvent.start]: StartPayload
[ServerEvent.stop]: StopPayload
[ServerEvent.connect]: ConnectPayload
[ServerEvent.connectionEstablished]: ConnectionEstablishedPayload
[ServerEvent.disconnect]: DisconnectPayload
[ServerEvent.portUnavailable]: PortUnavailablePayload
}
export type WebSocketEvent = (socket: WebSocket) => void
``` | /content/code_sandbox/lib/reactotron-core-contract/src/server-events.ts | xml | 2016-04-15T21:58:32 | 2024-08-16T11:39:46 | reactotron | infinitered/reactotron | 14,757 | 584 |
```xml
import { Component, Input, ViewChild, Optional } from '@angular/core';
import { Router } from '@angular/router';
import { MatSidenav, MatDrawerToggleResult } from '@angular/material/sidenav';
import { ILayoutTogglable } from '../layout-toggle.class';
@Component({
selector: 'td-layout-nav-list',
styleUrls: ['./layout-nav-list.component.scss'],
templateUrl: './layout-nav-list.component.html',
})
export class TdLayoutNavListComponent implements ILayoutTogglable {
@ViewChild(MatSidenav, { static: true }) sidenav!: MatSidenav;
/**
* toolbarTitle?: string
*
* Title set in toolbar.
*/
@Input() toolbarTitle?: string;
/**
* icon?: string
* icon name to be displayed before the title
*/
@Input() icon?: string;
/**
* logo?: string
*
* logo icon name to be displayed before the title.
* If [icon] is set, then this will not be shown.
*/
@Input() logo?: string;
/**
* color?: 'accent' | 'primary' | 'warn'
*
* toolbar color option: primary | accent | warn.
* If [color] is not set, primary is used.
*/
@Input() color?: 'accent' | 'primary' | 'warn';
/**
* mode?: 'side', 'push' or 'over'
*
* The mode or styling of the sidenav.
* Defaults to "side".
* See "MatSidenav" documentation for more info.
*
* path_to_url
*/
@Input() mode: 'side' | 'push' | 'over' = 'side';
/**
* opened?: boolean
* Whether or not the sidenav is opened. Use this binding to open/close the sidenav.
* Defaults to "true".
*
* See "MatSidenav" documentation for more info.
*
* path_to_url
*/
@Input() opened = true;
/**
* sidenavWidth?: string
*
* Sets the "width" of the sidenav in either "px" or "%"
* Defaults to "350px".
*
* path_to_url
*/
@Input() sidenavWidth = '350px';
/**
* containerAutosize?: boolean
*
* Sets "autosize" of the sidenav-container.
* Defaults to "false".
*
* See documentation for more info and potential performance risks.
*
* path_to_url#resizing-an-open-sidenav
*/
@Input() containerAutosize = false;
/**
* navigationRoute?: string
*
* option to set the combined route for the icon, logo, and toolbarTitle.
*/
@Input() navigationRoute?: string;
/**
* Checks if `ESC` should close the sidenav
* Should only close it for `push` and `over` modes
*/
get disableClose(): boolean {
return this.mode === 'side';
}
/**
* Checks if router was injected.
*/
get routerEnabled(): boolean {
return !!this._router && !!this.navigationRoute;
}
constructor(@Optional() private _router: Router) {}
handleNavigationClick(): void {
if (this.routerEnabled && this.navigationRoute) {
this._router.navigateByUrl(this.navigationRoute);
}
}
/**
* Proxy toggle method to access sidenav from outside (from td-layout template).
*/
public toggle(): Promise<MatDrawerToggleResult> {
return this.sidenav.toggle(!this.sidenav.opened);
}
/**
* Proxy open method to access sidenav from outside (from td-layout template).
*/
public open(): Promise<MatDrawerToggleResult> {
return this.sidenav.open();
}
/**
* Proxy close method to access sidenav from outside (from td-layout template).
*/
public close(): Promise<MatDrawerToggleResult> {
return this.sidenav.close();
}
}
``` | /content/code_sandbox/libs/angular/layout/src/layout-nav-list/layout-nav-list.component.ts | xml | 2016-07-11T23:30:52 | 2024-08-15T15:20:45 | covalent | Teradata/covalent | 2,228 | 874 |
```xml
import { Story } from '@storybook/react';
import {
Environment,
EnvironmentStatus,
EnvironmentType,
} from '@/react/portainer/environments/types';
import { createMockEnvironment } from '@/react-tools/test-mocks';
import { EnvironmentItem } from './EnvironmentItem';
export default {
component: EnvironmentItem,
title: 'Home/EnvironmentList/EnvironmentItem',
};
interface Args {
environment: Environment;
}
function Template({ environment }: Args) {
return (
<EnvironmentItem
environment={environment}
onClickBrowse={() => {}}
onClickDisconnect={() => {}}
isActive={false}
/>
);
}
export const DockerEnvironment: Story<Args> = Template.bind({});
DockerEnvironment.args = {
environment: mockEnvironment(EnvironmentType.Docker),
};
export const DockerAgentEnvironment: Story<Args> = Template.bind({});
DockerAgentEnvironment.args = {
environment: mockEnvironment(EnvironmentType.AgentOnDocker),
};
export const DockerEdgeEnvironment: Story<Args> = Template.bind({});
DockerEdgeEnvironment.args = {
environment: mockEnvironment(EnvironmentType.EdgeAgentOnDocker),
};
export const AzureEnvironment: Story<Args> = Template.bind({});
AzureEnvironment.args = {
environment: mockEnvironment(EnvironmentType.Azure),
};
export const KubernetesLocalEnvironment: Story<Args> = Template.bind({});
KubernetesLocalEnvironment.args = {
environment: mockEnvironment(EnvironmentType.KubernetesLocal),
};
export const KubernetesAgentEnvironment: Story<Args> = Template.bind({});
KubernetesAgentEnvironment.args = {
environment: mockEnvironment(EnvironmentType.AgentOnKubernetes),
};
export const KubernetesEdgeEnvironment: Story<Args> = Template.bind({});
KubernetesEdgeEnvironment.args = {
environment: mockEnvironment(EnvironmentType.EdgeAgentOnKubernetes),
};
function mockEnvironment(type: EnvironmentType): Environment {
const env = createMockEnvironment();
env.Type = type;
env.Status = EnvironmentStatus.Up;
return env;
}
``` | /content/code_sandbox/app/react/portainer/HomeView/EnvironmentList/EnvironmentItem/EnvironmentItem.stories.tsx | xml | 2016-05-19T20:15:28 | 2024-08-16T19:15:14 | portainer | portainer/portainer | 30,083 | 401 |
```xml
import * as path from 'path';
import { fileURLToPath } from 'url';
import { expect, it, describe } from 'vitest';
import { scanImports } from '../src/service/analyze';
import formatPath from '../src/utils/formatPath';
const __dirname = path.dirname(fileURLToPath(import.meta.url));
describe('scan import', () => {
const alias = { '@': path.join(__dirname, './fixtures/scan') };
const rootDir = path.join(__dirname, './fixtures/scan');
it('basic scan', async () => {
const deps = await scanImports([path.join(__dirname, './fixtures/scan/app.ts')], { alias, rootDir });
expect(deps['@ice/runtime'].name).toEqual('@ice/runtime');
expect(/(@ice\/)?runtime\/package\.json/.test(formatPath(deps['@ice/runtime'].pkgPath!))).toBeTruthy();
expect(deps['@ice/runtime/client'].name).toEqual('@ice/runtime/client');
expect(/(@ice\/)?runtime\/package\.json/.test(formatPath(deps['@ice/runtime/client'].pkgPath!))).toBeTruthy();
expect(deps.react.name).toEqual('react');
expect(/react\/package\.json/.test(formatPath(deps['react'].pkgPath!))).toBeTruthy();
});
it('scan with exclude', async () => {
const deps = await scanImports([path.join(__dirname, './fixtures/scan/app.ts')], { alias, rootDir, exclude: ['@ice/runtime'] });
expect(deps.react.name).toEqual('react');
expect(/react\/package\.json/.test(formatPath(deps['react'].pkgPath!))).toBeTruthy();
expect(deps['@ice/runtime']).toBeUndefined();
});
it('scan with depImports', async () => {
const deps = await scanImports(
[path.join(__dirname, './fixtures/scan/app.ts')],
{ alias, rootDir, depImports: { '@ice/runtime': { name: '@ice/runtime' }, react: { name: 'react' } } },
);
expect(deps['@ice/runtime'].name).toEqual('@ice/runtime');
expect(deps['@ice/runtime'].pkgPath).toBeUndefined();
expect(deps.react.name).toEqual('react');
expect(deps.react.pkgPath).toBeUndefined();
});
});
``` | /content/code_sandbox/packages/ice/tests/scan.test.ts | xml | 2016-11-03T06:59:15 | 2024-08-16T10:11:29 | ice | alibaba/ice | 17,815 | 496 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="about_android">Applicazione per Android di %1$s</string>
<string name="about_title">Informazioni</string>
<string name="about_version">versione %1$s</string>
<string name="about_version_with_build">versione %1$s, build #%2$s</string>
<string name="account_creation_failed">Creazione dell\'account non riuscita</string>
<string name="account_icon">Icona dell\'account</string>
<string name="account_not_found">Account non trovato</string>
<string name="action_edit">Modifica</string>
<string name="action_empty_notifications">Cancella tutte le notifiche</string>
<string name="action_empty_trashbin">Svuota cestino</string>
<string name="action_send_share">Invia/Condividi</string>
<string name="action_switch_grid_view">Vista Griglia</string>
<string name="action_switch_list_view">Vista Elenco</string>
<string name="actionbar_calendar_contacts_restore">Ripristina contatti e calendario</string>
<string name="actionbar_mkdir">Nuova cartella</string>
<string name="actionbar_move_or_copy">Sposta o copia</string>
<string name="actionbar_open_with">Apri con</string>
<string name="actionbar_search">Cerca</string>
<string name="actionbar_see_details">Dettagli</string>
<string name="actionbar_send_file">Invia</string>
<string name="actionbar_settings">Impostazioni</string>
<string name="actionbar_sort">Ordina</string>
<string name="active_user">Utente attivo</string>
<string name="activities_no_results_headline">Ancora nessuna attivit</string>
<string name="activities_no_results_message">Ancora nessun evento come aggiunte, modifiche e condivisioni.</string>
<string name="activity_chooser_send_file_title">Invia</string>
<string name="activity_chooser_title">Invia collegamento a</string>
<string name="activity_icon">Attivit</string>
<string name="add_another_public_share_link">Aggiungi un altro collegamento</string>
<string name="add_new_public_share">Aggiungi nuovo collegamento pubblico di condivisione</string>
<string name="add_new_secure_file_drop">Aggiungi un nuovo drop file sicuro</string>
<string name="add_to_cloud">Aggiungi a %1$s</string>
<string name="advanced_settings">Impostazioni avanzate</string>
<string name="allow_resharing">Consenti la ri-condivisione</string>
<string name="app_config_proxy_port_title">Porta proxy</string>
<string name="app_widget_description">Mostra un widget dal cruscotto</string>
<string name="appbar_search_in">Cerca in %s</string>
<string name="assistant_screen_all_task_type">Tutti</string>
<string name=your_sha256_hashr">Aggiungi del testo</string>
<string name="assistant_screen_delete_task_alert_dialog_description">Sei sicuro di voler rimuovere questa attivit?</string>
<string name="assistant_screen_delete_task_alert_dialog_title">Elimina attivit</string>
<string name="assistant_screen_failed_task_text">Non riuscito</string>
<string name="assistant_screen_running_task_text">In corso</string>
<string name="assistant_screen_scheduled_task_status_text">Programmato</string>
<string name="assistant_screen_successful_task_text">Completato</string>
<string name="assistant_screen_task_create_fail_message">Un errore intercorso durante la creazione del task</string>
<string name="assistant_screen_task_create_success_message">Task creato con successo</string>
<string name="assistant_screen_task_delete_fail_message">Un errore intercorso durante la cancellazione del task</string>
<string name="assistant_screen_task_delete_success_message">Task cancellato con successo</string>
<string name="assistant_screen_task_more_actions_bottom_sheet_delete_action">Cancella task</string>
<string name="assistant_screen_top_bar_title">Assistente</string>
<string name="assistant_screen_unknown_task_status_text">Sconosciuto</string>
<string name="assistant_task_detail_screen_input_button_title">Input</string>
<string name="assistant_task_detail_screen_output_button_title">Output</string>
<string name="associated_account_not_found">Account associato non trovato.</string>
<string name="auth_access_failed">Accesso non riuscito: %1$s</string>
<string name="auth_account_does_not_exist">L\'account non ancora aggiunto su questo dispositivo</string>
<string name="auth_account_not_new">Un account per lo stesso utente e server esiste gi sul dispositivo</string>
<string name="auth_account_not_the_same">L\'utente digitato non corrisponde all\'utente di questo account</string>
<string name="auth_bad_oc_version_title">Versione del server non riconosciuta</string>
<string name="auth_connection_established">Connessione stabilita</string>
<string name="auth_fail_get_user_name">Il server non restituisce un ID utente corretto, contatta un amministratore.</string>
<string name="auth_host_url">Indirizzo server https://</string>
<string name="auth_incorrect_address_title">Formato dell\'indirizzo del server errato</string>
<string name="auth_incorrect_path_title">Server non trovato</string>
<string name="auth_no_net_conn_title">Nessuna connessione di rete</string>
<string name="auth_nossl_plain_ok_title">Connessione sicura non disponibile.</string>
<string name="auth_not_configured_title">Configurazione non corretta del server</string>
<string name="auth_oauth_error">Autorizzazione non riuscita</string>
<string name="auth_oauth_error_access_denied">Accesso negato dal server di autorizzazione</string>
<string name="auth_redirect_non_secure_connection_title">Connessione sicura rediretta su un percorso non sicuro.</string>
<string name="auth_secure_connection">Connessione sicura stabilita</string>
<string name="auth_ssl_general_error_title">Inizializzazione SSL non riuscita</string>
<string name="auth_ssl_unverified_server_title">Impossibile verificare l\'identit del server SSL</string>
<string name="auth_testing_connection">Prova di connessione</string>
<string name="auth_timeout_title">Il server ha richiesto troppo tempo per rispondere</string>
<string name="auth_trying_to_login">Tentativo di accesso in corso</string>
<string name="auth_unauthorized">Nome utente o password errati</string>
<string name="auth_unknown_error_exception_title">Errore sconosciuto: %1$s</string>
<string name="auth_unknown_error_http_title">Si verificato un errore HTTP sconosciuto!</string>
<string name="auth_unknown_error_title">Si verificato un errore sconosciuto!</string>
<string name="auth_unknown_host_title">Impossibile trovare l\'host</string>
<string name="auth_unsupported_multiaccount">%1$s non supporta account multipli</string>
<string name="auth_wrong_connection_title">Impossibile stabilire la connessione</string>
<string name="authenticator_activity_cancel_login">Annulla l\'accesso</string>
<string name="authenticator_activity_login_error">C\' stato un problema nella richiesta di login. Per favore, riprova pi tardi</string>
<string name="authenticator_activity_please_complete_login_process">Completa il procedimento di login nel tuo browser</string>
<string name="auto_upload_file_behaviour_kept_in_folder">lasciato nella cartella originale, poich in sola lettura</string>
<string name="auto_upload_on_wifi">Carica solo su Wi-Fi senza limitazioni</string>
<string name="auto_upload_path">/AutoUpload</string>
<string name="autoupload_configure">Configura</string>
<string name="autoupload_create_new_custom_folder">Crea nuova configurazione di cartella personalizzata</string>
<string name="autoupload_custom_folder">Configura una cartella personalizzata</string>
<string name="autoupload_disable_power_save_check">Disabilita controllo di risparmio energetico</string>
<string name="autoupload_hide_folder">Nascondi cartella</string>
<string name="avatar">Avatar</string>
<string name="away">Assente</string>
<string name="backup_settings">Impostazioni di backup</string>
<string name="battery_optimization_close">Chiudi</string>
<string name="battery_optimization_disable">Disabilita</string>
<string name="battery_optimization_message">Il tuo dispositivo potrebbe avere l\'ottimizzazione della batteria abilitata. Il caricamento automatico funziona correttamente solo se escludi questa applicazione dall\'ottimizzazione.</string>
<string name="battery_optimization_title">Ottimizzazione batteria</string>
<string name="brute_force_delay">Ritardato a causa di troppi tentativi errati</string>
<string name="calendar">Calendario</string>
<string name="calendars">Calendari</string>
<string name="certificate_load_problem">Si verificato un problema durante il caricamento del certificato.</string>
<string name="changelog_dev_version">Novit versione di sviluppo</string>
<string name="check_back_later_or_reload">Controlla pi tardi o ricarica</string>
<string name="checkbox">Casella di selezione</string>
<string name="choose_local_folder">Scegli la cartella locale</string>
<string name="choose_remote_folder">Scegli la cartella remota</string>
<string name="choose_template_helper_text">Scegli un modello e inserisci un nome del file.</string>
<string name="choose_which_file">Scegli quale file mantenere!</string>
<string name="choose_widget">Scegli il widget</string>
<string name="clear_notifications_failed">Cancellazione notifiche non riuscita.</string>
<string name="clear_status_message">Cancella il messaggio di stato</string>
<string name="clear_status_message_after">Cancella il messaggio di stato dopo</string>
<string name="clipboard_label">Testo copiato da %1$s</string>
<string name="clipboard_no_text_to_copy">Nessun testo ricevuto da copiare negli appunti</string>
<string name="clipboard_text_copied">Collegamento copiato</string>
<string name="clipboard_unexpected_error">Errore inatteso durante la copia negli appunti</string>
<string name="common_back">Indietro</string>
<string name="common_cancel">Annulla</string>
<string name="common_cancel_sync">Annulla sincronizzazione</string>
<string name="common_choose_account">Scegli account</string>
<string name="common_confirm">Conferma</string>
<string name="common_copy">Copia</string>
<string name="common_delete">Elimina</string>
<string name="common_error">Errore</string>
<string name="common_error_out_memory">Memoria insufficiente</string>
<string name="common_error_unknown">Errore sconosciuto</string>
<string name="common_loading">Caricamento in corso</string>
<string name="common_next">Successivo</string>
<string name="common_no">No</string>
<string name="common_ok">OK</string>
<string name="common_pending">In corso</string>
<string name="common_remove">Elimina</string>
<string name="common_rename">Rinomina</string>
<string name="common_save">Salva</string>
<string name="common_send">Invia</string>
<string name="common_share">Condividi</string>
<string name="common_skip">Salta</string>
<string name="common_switch_account">Cambia account</string>
<string name="common_switch_to_account">Cambia account</string>
<string name="common_yes">S</string>
<string name="community_beta_headline">Prova la versione di sviluppo</string>
<string name="community_beta_text">Ci include tutte le funzionalit di prossima introduzione e potrebbe presentare seri problemi di stabilit. Bug/errori possono verificars. Se e quando li riscontrerai, segnalaci le tue scoperte.</string>
<string name="community_contribute_forum_forum">forum</string>
<string name="community_contribute_forum_text">Aiuta gli altri sul</string>
<string name="community_contribute_github_text">Esamina, correggi e scrivi codice, vedi %1$s per i dettagli.</string>
<string name="community_contribute_headline">Contribuisci attivamente</string>
<string name="community_contribute_translate_text">l\'applicazione</string>
<string name="community_contribute_translate_translate">Traduci</string>
<string name="community_dev_direct_download">Scarica direttamente la versione di sviluppo</string>
<string name="community_dev_fdroid">Ottieni la versione di sviluppo dall\'applicazione F-Droid</string>
<string name="community_rc_fdroid">Ottieni la candidata al rilascio dall\'applicazione F-Droid</string>
<string name="community_rc_play_store">Ottieni la candidata al rilascio da Google Play</string>
<string name="community_release_candidate_headline">Candidata al rilascio</string>
<string name="community_release_candidate_text">La candidata al rilascio (RC) un\'istantanea della versione successiva e dovrebbe essere stabile. Effettuando dei test sulla tua configurazione, puoi aiutarci a esserne sicuri. Registrati per la fase di test su Google Play o controlla manualmente nella sezione \"Versione\" di F-Droid.</string>
<string name="community_testing_bug_text">Trovato un bug? Stranezze?</string>
<string name="community_testing_headline">Aiutaci nella fase di test</string>
<string name="community_testing_report_text">Segnala un problema su GitHub</string>
<string name="configure_new_media_folder_detection_notifications">Configura</string>
<string name="confirm_removal">Rimuovi la cifratura locale</string>
<string name="confirmation_remove_file_alert">Vuoi davvero eliminare %1$s?</string>
<string name="confirmation_remove_files_alert">Vuoi davvero eliminare gli elementi selezionati?</string>
<string name="confirmation_remove_folder_alert">Vuoi davvero rimuovere %1$s e il relativo contenuto?</string>
<string name="confirmation_remove_folders_alert">Vuoi davvero eliminare gli elementi selezionati e il loro contenuto?</string>
<string name="confirmation_remove_local">Solo localmente</string>
<string name="conflict_file_headline">File %1$s in conflitto</string>
<string name="conflict_local_file">File locale</string>
<string name="conflict_message_description">Se selezioni entrambe le versioni, il file locale ha un numero aggiunto al suo nome.</string>
<string name="conflict_server_file">File su server</string>
<string name="contact_backup_title">Backup contatti</string>
<string name="contact_no_permission">Autorizzazione Contatti richiesta</string>
<string name="contactlist_item_icon">Icona utente della lista contatti</string>
<string name="contactlist_no_permission">Nessun permesso specificato, nessun elemento importato.</string>
<string name="contacts">Contatti</string>
<string name="contacts_backup_button">Esegui backup ora</string>
<string name="contacts_preferences_backup_scheduled">Backup pianificato e partir a breve</string>
<string name="contacts_preferences_import_scheduled">Importazione pianificata e partir a breve</string>
<string name="contacts_preferences_no_file_found">Nessun file trovato</string>
<string name="contacts_preferences_something_strange_happened">Non troviamo il tuo ultimo backup!</string>
<string name="copied_to_clipboard">Copiato negli appunti</string>
<string name="copy_file_error">Si verificato un errore durante il tentativo di copiare il file o la cartella</string>
<string name="copy_file_invalid_into_descendent">Impossibile copiare una cartella in una delle sue cartelle sottostanti</string>
<string name="copy_file_invalid_overwrite">Il file gi presente nella cartella di destinazione</string>
<string name="copy_file_not_found">Impossibile copiare. Assicurati che il file esista.</string>
<string name="copy_link">Copia collegamento</string>
<string name="copy_move_to_encrypted_folder_not_supported">Copia/Spostamento in una cartella cifrata attualmente non supportati.</string>
<string name="could_not_download_image">Impossibile scaricare l\'immagine completa</string>
<string name="could_not_retrieve_shares">Impossibile recuperare le condivisioni</string>
<string name="could_not_retrieve_url">Impossibile recuperare l\'URL</string>
<string name="create">Crea</string>
<string name="create_dir_fail_msg">Impossibile creare la cartella</string>
<string name="create_new">Nuovo</string>
<string name="create_new_document">Nuovo documento</string>
<string name="create_new_folder">Nuova cartella</string>
<string name="create_new_presentation">Nuova presentazione</string>
<string name="create_new_spreadsheet">Nuovo foglio elettronico</string>
<string name="create_rich_workspace">Aggiungi descrizione cartella</string>
<string name="credentials_disabled">Credenziali disabilitate</string>
<string name="daily_backup">Backup giornaliero</string>
<string name="data_to_back_up">Dati di cui eseguire il backup</string>
<string name="default_credentials_wrong">Credenziali non corrette</string>
<string name="delete_account">Rimuovi account</string>
<string name="delete_entries">Elimina voci</string>
<string name="delete_link">Elimina collegamento</string>
<string name="deselect_all">Deseleziona tutto</string>
<string name="destination_filename">Filename di destinazione</string>
<string name="dev_version_new_version_available">Nuova versione disponibile</string>
<string name="dev_version_no_information_available">Nessuna informazione disponibile.</string>
<string name="dev_version_no_new_version_available">Nessuna nuova versione disponibile.</string>
<string name="dialog_close">Chiudi</string>
<string name="did_not_check_for_dupes">Non sono stati controllati eventuali duplicati</string>
<string name="digest_algorithm_not_available">Questo algoritmo digest non disponibile sul tuo telefono.</string>
<string name="direct_login_failed">Accesso tramite collegamento diretto non riuscito!</string>
<string name="direct_login_text">Accedi con %1$s a %2$s</string>
<string name="disable_new_media_folder_detection_notifications">Disabilita</string>
<string name="dismiss">Annulla</string>
<string name="dismiss_notification_description">Cancella notifica</string>
<string name="displays_mnemonic">Visualizza la tua frase segreta di 12 parole</string>
<string name="dnd">Non disturbare</string>
<string name="document_scan_export_dialog_images">Immagini multiple</string>
<string name="document_scan_export_dialog_pdf">File PDF</string>
<string name="document_scan_export_dialog_title">Scegli il tipo di esportazione</string>
<string name="document_scan_pdf_generation_failed">Generazione PDF non riuscita</string>
<string name="document_scan_pdf_generation_in_progress">Generazione PDF...</string>
<string name="done">Fatto</string>
<string name="dontClear">Non togliere</string>
<string name="download_cannot_create_file">Impossibile creare il file locale</string>
<string name="download_download_invalid_local_file_name">Nome file non valido per il file locale</string>
<string name="download_latest_dev_version">Scarica l\'ultima versione di sviluppo</string>
<string name="downloader_download_failed_content">Impossibile scaricare %1$s</string>
<string name="downloader_download_failed_credentials_error">Scaricamento non riuscito, effettua nuovamente l\'accesso</string>
<string name="downloader_download_failed_ticker">Scaricamento non riuscito</string>
<string name="downloader_download_file_not_found">Il file non pi disponibile sul server</string>
<string name="downloader_download_in_progress">%1$d%% %2$s</string>
<string name="downloader_download_in_progress_content">%1$d%% Scaricamento di %2$s</string>
<string name="downloader_download_in_progress_ticker">Scaricamento in corso</string>
<string name="downloader_download_succeeded_content">%1$s scaricato</string>
<string name="downloader_download_succeeded_ticker">Scaricati</string>
<string name="downloader_not_downloaded_yet">Non ancora scaricato</string>
<string name="drawer_close">Chiudi barra laterale</string>
<string name="drawer_community">Comunit</string>
<string name="drawer_header_background">Immagine di sfondo sull\'intestazione del cassetto</string>
<string name="drawer_item_activities">Attivit</string>
<string name="drawer_item_all_files">Tutti i file</string>
<string name="drawer_item_assistant">Assistente</string>
<string name="drawer_item_favorites">Preferiti</string>
<string name="drawer_item_gallery">Media</string>
<string name="drawer_item_groupfolders">Cartelle di gruppo</string>
<string name="drawer_item_home">Home</string>
<string name="drawer_item_notifications">Notifiche</string>
<string name="drawer_item_on_device">Su dispositivo</string>
<string name="drawer_item_personal_files">File personali</string>
<string name="drawer_item_recently_modified">Modificato di recente</string>
<string name="drawer_item_shared">Condiviso</string>
<string name="drawer_item_trashbin">File eliminati</string>
<string name="drawer_item_uploads_list">Caricamenti</string>
<string name="drawer_logout">Esci</string>
<string name="drawer_open">Apri barra laterale</string>
<string name="drawer_quota">%1$s di %2$s utilizzati</string>
<string name="drawer_quota_unlimited">%1$s utilizzato</string>
<string name="drawer_synced_folders">Caricamento automatico</string>
<string name="e2e_not_yet_setup">L\'E2E non ancora configurato</string>
<string name="e2e_offline">Impossibile senza connessione internet</string>
<string name="ecosystem_apps_display_assistant">Assistente</string>
<string name="ecosystem_apps_display_more">Altro</string>
<string name="ecosystem_apps_display_notes">Note</string>
<string name="ecosystem_apps_more">Altre applicazioni di Nextcloud</string>
<string name="ecosystem_apps_notes">Nextcloud Note</string>
<string name="ecosystem_apps_talk">Nextcloud Talk</string>
<string name="email_pick_failed">Impossibile scegliere l\'indirizzo di posta.</string>
<string name="encrypted">Imposta come cifrato</string>
<string name="end_to_end_encryption_confirm_button">Configura la cifratura</string>
<string name="end_to_end_encryption_decrypting">Decifratura in corso</string>
<string name="end_to_end_encryption_dialog_close">Chiudi</string>
<string name="end_to_end_encryption_enter_password">Digita la password per decifrare la chiave privata.</string>
<string name="end_to_end_encryption_folder_not_empty">Questa cartella non vuota.</string>
<string name="end_to_end_encryption_generating_keys">Generazione nuove chiavi in corso</string>
<string name="end_to_end_encryption_keywords_description">Le 12 parole insieme compongono una password molto robusta, consentendo solo a te di visualizzare e utilizzare i tuoi file cifrati. Annotala e conservala in un posto sicuro.</string>
<string name="end_to_end_encryption_not_enabled">Cifratura end-to-end disabilitata sul server.</string>
<string name="end_to_end_encryption_passphrase_title">Annota la tua password di cifratura di 12 parole</string>
<string name="end_to_end_encryption_password">Password</string>
<string name="end_to_end_encryption_retrieving_keys">Recupero delle chiavi in corso</string>
<string name="end_to_end_encryption_storing_keys">Archiviazione chiavi</string>
<string name="end_to_end_encryption_title">Configura la cifratura</string>
<string name="end_to_end_encryption_unsuccessful">Impossibile salvare le chiavi, prova ancora.</string>
<string name="end_to_end_encryption_wrong_password">Errore durante la decifratura. Password errata?</string>
<string name="enter_destination_filename">Inserisci il nome file di destinazione</string>
<string name="enter_filename">Digita il nome del file</string>
<string name="error__upload__local_file_not_copied">%1$s non pu essere copiato nella cartella locale %2$s</string>
<string name="error_cant_bind_to_operations_service">Errore grave: impossibile eseguire operazioni</string>
<string name="error_choosing_date">Errore nella scelta della data</string>
<string name="error_comment_file">Errore di commento del file</string>
<string name="error_crash_title">%1$s si chiuso inaspettatamente</string>
<string name="error_creating_file_from_template">Errore nel creare il file da template</string>
<string name="error_file_actions">Errore nel mostrare le azioni del file</string>
<string name="error_file_lock">Errore nello sbloccare il file</string>
<string name="error_report_issue_action">Segnala</string>
<string name="error_report_issue_text">Segnalare problemi al sistema di tracciamento? (richiede un account GitHub)</string>
<string name="error_retrieving_file">Errore durante il recupero del file</string>
<string name="error_retrieving_templates">Errore durante il recupero dei modelli</string>
<string name="error_showing_encryption_dialog">Errore durante la visualizzazione della finestra di dialogo per l\'impostazione della crittografia!</string>
<string name="error_starting_direct_camera_upload">Errore di avvio della fotocamera</string>
<string name="error_starting_doc_scan">Errore all\'avvio della scansione del documento</string>
<string name="etm_accounts">Account</string>
<string name="etm_background_job_created">Creato il</string>
<string name="etm_background_job_name">Nome operazione</string>
<string name="etm_background_job_progress">Avanzamento</string>
<string name="etm_background_job_state">Stato</string>
<string name="etm_background_job_user">Utente</string>
<string name="etm_background_job_uuid">UUID</string>
<string name="etm_background_jobs">Operazioni in background</string>
<string name="etm_background_jobs_cancel_all">Annulla tutte le operazioni</string>
<string name="etm_background_jobs_prune">Elimina operazioni inattive</string>
<string name="etm_background_jobs_schedule_test_job">Pianifica operazione di prova</string>
<string name="etm_background_jobs_start_test_job">Avvia operazione di prova</string>
<string name="etm_background_jobs_stop_test_job">Ferma operazione di prova</string>
<string name="etm_migrations">Migrazioni (aggiornamento applicazione)</string>
<string name="etm_preferences">Preferenze</string>
<string name="etm_title">Modalit test di progettazione</string>
<string name="etm_transfer">Trasferimento file</string>
<string name="etm_transfer_enqueue_test_download">Accoda scaricamento di prova</string>
<string name="etm_transfer_enqueue_test_upload">Accoda caricamento di prova</string>
<string name="etm_transfer_remote_path">Percorso remoto</string>
<string name="etm_transfer_type">Trasferisci</string>
<string name="etm_transfer_type_download">Scarica</string>
<string name="etm_transfer_type_upload">Carica</string>
<string name="fab_label">Aggiungi o carica</string>
<string name="failed_to_download">Passaggio del file al gestore degli scaricamenti non riuscito</string>
<string name="failed_to_print">Stampa del file non riuscita</string>
<string name="failed_to_start_editor">Avvio dell\'editor non riuscito</string>
<string name="failed_update_ui">Aggiornamento interfaccia non riuscito</string>
<string name="favorite">Aggiungi ai preferiti</string>
<string name="favorite_icon">Preferito</string>
<string name="file_already_exists">Questo nome per il file esiste gi</string>
<string name="file_delete">Elimina</string>
<string name="file_detail_activity_error">Errore durante il recupero delle attivit per i file</string>
<string name="file_details_no_content">Caricamento dettagli non riuscito</string>
<string name="file_icon">File</string>
<string name="file_keep">Mantieni</string>
<string name="file_list_empty">Carica dei contenuti o sincronizza con i tuoi dispositivi.</string>
<string name="file_list_empty_favorite_headline">Ancora nessun preferito</string>
<string name="file_list_empty_favorites_filter_list">I file e le cartelle che marchi come preferiti saranno mostrati qui.</string>
<string name="file_list_empty_gallery">Nessuna immagine o video trovati</string>
<string name="file_list_empty_headline">Qui non c\' alcun file</string>
<string name="file_list_empty_headline_search">Nessun risultato in questa cartella</string>
<string name="file_list_empty_headline_server_search">Nessun risultato</string>
<string name="file_list_empty_moving">Non c\' niente qui. Puoi aggiungere una cartella.</string>
<string name="file_list_empty_on_device">I file e le cartelle scaricati saranno mostrati qui.</string>
<string name="file_list_empty_recently_modified">Non stato trovato alcun file modificato negli ultimi 7 giorni</string>
<string name="file_list_empty_search">Forse in una cartella diversa?</string>
<string name="file_list_empty_shared">I file e le cartelle che condividi saranno mostrati qui.</string>
<string name="file_list_empty_shared_headline">Ancora nessuna condivisione</string>
<string name="file_list_empty_unified_search_no_results">Nessun risultato trovato per la tua interrogazione</string>
<string name="file_list_folder">cartella</string>
<string name="file_list_live">LIVE</string>
<string name="file_list_loading">Caricamento in corso</string>
<string name="file_list_no_app_for_file_type">Nessuna applicazione configurata per gestire questo tipo di file.</string>
<string name="file_list_seconds_ago">secondi fa</string>
<string name="file_management_permission">Permessi richiesti</string>
<string name="file_management_permission_optional">Autorizzazioni di archiviazione</string>
<string name="file_management_permission_optional_text">%1$s funziona meglio con l\'autorizzazione di accedere all\'archiviazione. Puoi scegliere l\'accesso completo a tutti i file o quello in sola lettura a foto e video.</string>
<string name="file_management_permission_text">%1$s richiede l\'autorizzazione di gestione file per inviare i file. Puoi scegliere l\'accesso completo a tutti i file o quello in sola lettura a foto e video.</string>
<string name="file_migration_checking_destination">Controllo della destinazione</string>
<string name="file_migration_cleaning">Pulizia in corso</string>
<string name="file_migration_dialog_title">Aggiornamento della cartella di archiviazione dei dati</string>
<string name="file_migration_directory_already_exists">La cartella data esiste gi. Scegli una delle seguenti:</string>
<string name="file_migration_failed_dir_already_exists">La cartella di Nextcloud esiste gi</string>
<string name="file_migration_failed_not_enough_space">Altro spazio necessario</string>
<string name="file_migration_failed_not_readable">Impossibile leggere il file di origine</string>
<string name="file_migration_failed_not_writable">Impossibile scrivere il file di destinazione</string>
<string name="file_migration_failed_while_coping">Problema durante la migrazione</string>
<string name="file_migration_failed_while_updating_index">Aggiornamento dell\'indice non riuscito</string>
<string name="file_migration_migrating">Spostamento dei dati</string>
<string name="file_migration_ok_finished">Fine</string>
<string name="file_migration_override_data_folder">Sostituisci</string>
<string name="file_migration_preparing">Preparazione della migrazione</string>
<string name="file_migration_restoring_accounts_configuration">Ripristino della configurazione dell\'account</string>
<string name="file_migration_saving_accounts_configuration">Salvataggio della configurazione dell\'account</string>
<string name="file_migration_source_not_readable">Vuoi ancora cambiare la cartella di archiviazione dei dati in %1$s?\n\nNota: tutti i dati dovranno essere scaricati nuovamente.</string>
<string name="file_migration_source_not_readable_title">Cartella sorgente non disponibile!</string>
<string name="file_migration_updating_index">Aggiornamento dell\'indice</string>
<string name="file_migration_use_data_folder">Usa</string>
<string name="file_migration_waiting_for_unfinished_sync">In attesa della sincronizzazione completa</string>
<string name="file_not_found">File non trovato</string>
<string name="file_not_synced">Il file non pu essere sincronizzato. Viene mostrata l\'ultima versione disponibile.</string>
<string name="file_rename">Rinomina</string>
<string name="file_version_restored_error">Errore durante il ripristino della versione del file!</string>
<string name="file_version_restored_successfully">Versione del file ripristinata correttamente.</string>
<string name="filedetails_details">Dettagli</string>
<string name="filedetails_download">Scarica</string>
<string name="filedetails_export">Esporta</string>
<string name="filedetails_renamed_in_upload_msg">File rinominato %1$s durante il caricamento</string>
<string name="filedetails_sync_file">Sincronizzazione</string>
<string name="filedisplay_no_file_selected">Nessun file selezionato</string>
<string name="filename_empty">Il nome del file non pu essere vuoto</string>
<string name="filename_forbidden_characters">Caratteri proibiti: / \\ < > : \" | ? *</string>
<string name="filename_forbidden_charaters_from_server">Il nome del file contiene almeno un carattere non valido</string>
<string name="filename_hint">Nome file</string>
<string name="first_run_1_text">Mantieni i tuoi dati sicuri e sotto il tuo controllo</string>
<string name="folder_already_exists">La cartella esiste gi</string>
<string name="folder_confirm_create">Crea</string>
<string name="folder_list_empty_headline">Qui non c\' alcuna cartella</string>
<string name="folder_picker_choose_button_text">Scegli</string>
<string name="folder_picker_choose_caption_text">Scegli la cartella di destinazione</string>
<string name="folder_picker_copy_button_text">Copia</string>
<string name="folder_picker_move_button_text">Sposta</string>
<string name="forbidden_permissions">Non ti consentito %s</string>
<string name="forbidden_permissions_copy">per copiare questo file</string>
<string name="forbidden_permissions_create">per creare questo file</string>
<string name="forbidden_permissions_delete">per eliminare questo file</string>
<string name="forbidden_permissions_move">per spostare questo file</string>
<string name="forbidden_permissions_rename">per rinominare questo file</string>
<string name="foreground_service_upload">Caricamento file in corso</string>
<string name="foreign_files_fail">Alcuni file non possono essere spostati</string>
<string name="foreign_files_local_text">Locale: %1$s</string>
<string name="foreign_files_move">Sposta tutto</string>
<string name="foreign_files_remote_text">Remoto %1$s</string>
<string name="foreign_files_success">Tutti i file sono stati spostati</string>
<string name="forward">Inoltra</string>
<string name="fourHours">4 ore</string>
<string name="hidden_file_name_warning">Il nome render il file nascosto</string>
<string name="hint_name">Nome</string>
<string name="hint_note">Nota</string>
<string name="hint_password">Password</string>
<string name="host_not_available">Server non disponibile</string>
<string name="host_your_own_server">Ospita il tuo server</string>
<string name="icon_for_empty_list">Icona per lista vuota</string>
<string name="icon_of_dashboard_widget">Icona per widget del cruscotto</string>
<string name="icon_of_widget_entry">Icona della voce del widget</string>
<string name="image_editor_file_edited_suffix">modificato</string>
<string name="image_editor_flip_horizontal">Ribalta orizzontalmente</string>
<string name="image_editor_flip_vertical">Ribalta verticalmente</string>
<string name="image_editor_rotate_ccw">Ruota in senso anti orario</string>
<string name="image_editor_rotate_cw">Ruota in senso orario</string>
<string name="image_editor_unable_to_edit_image">Impossibile modificare l\'immagine.</string>
<string name="image_preview_filedetails">Dettagli del file</string>
<string name="image_preview_image_taking_conditions">Condizioni di cattura immagine</string>
<string name="image_preview_unit_fnumber">/%s</string>
<string name="image_preview_unit_iso">ISO %s</string>
<string name="image_preview_unit_megapixel">%s MP</string>
<string name="image_preview_unit_millimetres">%s mm</string>
<string name="image_preview_unit_seconds">%s s</string>
<string name="in_folder">nella cartella %1$s</string>
<string name="instant_upload_existing">Carica anche i file esistenti</string>
<string name="instant_upload_on_charging">Carica solo durante la ricarica</string>
<string name="instant_upload_path">/InstantUpload</string>
<string name="invalid_url">URL non valido</string>
<string name="invisible">Invisibile</string>
<string name="label_empty">L\'etichetta non pu essere vuota</string>
<string name="last_backup">Ultimo backup: %1$s</string>
<string name="link">Collegamento</string>
<string name="link_name">Nome collegamento</string>
<string name="link_share_allow_upload_and_editing">Consenti caricamento e modifica</string>
<string name="link_share_editing">Modificando</string>
<string name="link_share_file_drop">Rilascio file (solo caricamento)</string>
<string name="link_share_view_only">Sola lettura</string>
<string name="list_layout">Struttura a elenco</string>
<string name="load_more_results">Mostra altri risultati</string>
<string name="local_file_list_empty">Non ci sono file in questa cartella.</string>
<string name="local_file_not_found_message">File non trovato nel file system locale</string>
<string name="local_folder_friendly_path">%1$s/%2$s</string>
<string name="local_folder_list_empty">Non ci sono ulteriori cartelle.</string>
<string name="locate_folder">Trova cartella</string>
<string name="lock_expiration_info">Scade: %1$s</string>
<string name="lock_file">Blocca file</string>
<string name="locked_by">Bloccato da %1$s</string>
<string name="locked_by_app">Bloccato dall\'applicazione %1$s </string>
<string name="log_send_mail_subject">Registri applicazione %1$s Android</string>
<string name="log_send_no_mail_app">Non stata trovata alcuna applicazione per inviare i log. Installa un client di posta elettronica.</string>
<string name="logged_in_as">Connesso come %1$s</string>
<string name="login">Accedi</string>
<string name="login_url_helper_text">Il collegamento alla tua interfaccia web di %1$s quando la apri nel browser.</string>
<string name="logs_menu_delete">Elimina log</string>
<string name="logs_menu_refresh">Aggiorna</string>
<string name="logs_menu_search">Cerca log</string>
<string name="logs_menu_send">Invia log tramite email</string>
<string name="logs_status_filtered">Log: %1$d kB, query verificata %2$d / %3$d in %4$d ms</string>
<string name="logs_status_loading">Caricamento in corso</string>
<string name="logs_status_not_filtered">Log: %1$d kB, nessun filtro</string>
<string name="logs_title">Log</string>
<string name="maintenance_mode">Il server in modalit di manutenzione</string>
<string name="manage_space_clear_data">Cancella i dati</string>
<string name="manage_space_description">Impostazioni, database e certificati del server dai dati di %1$s saranno eliminati definitivamente.\n\nI file scaricati non saranno interessati.\n\nQuesto processo pu richiedere del tempo.</string>
<string name="manage_space_title">Gestisci lo spazio</string>
<string name="media_err_invalid_progressive_playback">Il file multimediale non pu essere trasmesso</string>
<string name="media_err_io">Impossibile leggere il file multimediale</string>
<string name="media_err_malformed">Il file multimediale ha una codifica non corretta</string>
<string name="media_err_timeout">Il tentativo di riprodurre il file scaduto</string>
<string name="media_err_unknown">Il lettore multimediale integrato non in grado di riprodurre il file</string>
<string name="media_err_unsupported">Codificatore multimediale non supportato</string>
<string name="media_forward_description">Pulsante Avanti veloce</string>
<string name="media_notif_ticker">Lettore musicale %1$s</string>
<string name="media_play_pause_description">Pulsante Riproduci o pausa</string>
<string name="media_rewind_description">Pulsante Riavvolgi</string>
<string name="media_state_playing">%1$s (in riproduzione)</string>
<string name="menu_item_sort_by_date_newest_first">Prima i pi recenti</string>
<string name="menu_item_sort_by_date_oldest_first">Prima i pi datati</string>
<string name="menu_item_sort_by_name_a_z">A - Z</string>
<string name="menu_item_sort_by_name_z_a">Z - A</string>
<string name="menu_item_sort_by_size_biggest_first">Prima i pi grandi</string>
<string name="menu_item_sort_by_size_smallest_first">Prima i pi piccoli</string>
<string name="more">Altro</string>
<string name="move_file_error">Si verificato un errore durante il tentativo di spostare il file o la cartella</string>
<string name="move_file_invalid_into_descendent">Impossibile spostare una cartella in una delle sue cartelle sottostanti</string>
<string name="move_file_invalid_overwrite">Il file gi presente nella cartella di destinazione</string>
<string name="move_file_not_found">Impossibile spostare il file. Controlla che esista.</string>
<string name="network_error_connect_timeout_exception">Si verificato un errore in attesa della risposta del server. Impossibile completare l\'operazione.</string>
<string name="network_error_socket_exception">Si verificato un errore durante la connessione al server</string>
<string name="network_error_socket_timeout_exception">Si verificato un errore in attesa della risposta del server. Impossibile completare l\'operazione.</string>
<string name="network_host_not_available">Impossibile completare l\'operazione. Server non disponibile.</string>
<string name="new_comment">Nuovo commento</string>
<string name="new_media_folder_detected">Nuova cartella multimediale %1$s rilevata</string>
<string name="new_media_folder_photos">foto</string>
<string name="new_media_folder_videos">video</string>
<string name="new_notification">Nuova notifica</string>
<string name="new_version_was_created">Una nuova versione stata creata</string>
<string name="no_actions">Nessuna azione per questo utente</string>
<string name="no_browser_available">Nessun applicazione disponibile per gestire i collegamenti</string>
<string name="no_calendar_exists">Nessun calendario esistente</string>
<string name="no_email_app_available">Nessuna applicazione disponibile per gestire l\'indirizzo email</string>
<string name="no_items">Nessun elemento</string>
<string name="no_map_app_availble">Nessuna applicazione disponibile per gestire mappe</string>
<string name="no_mutliple_accounts_allowed">Solo un account consentito</string>
<string name="no_pdf_app_available">Nessuna applicazione disponibile per gestire i PDF</string>
<string name="no_send_app">Nessuna applicazione disponibile per inviare i file selezionati</string>
<string name="no_share_permission_selected">Seleziona almeno un permesso da condividere.</string>
<string name="note_could_not_sent">Impossibile inviare la nota</string>
<string name="note_icon_hint">Icona della nota</string>
<string name="notification_action_failed">Esecuzione dell\'azione non riuscita.</string>
<string name="notification_channel_download_description">Mostra l\'avanzamento degli scaricamenti</string>
<string name="notification_channel_download_name_short">Scaricamenti</string>
<string name="notification_channel_file_sync_description">Mostra l\'avanzamento e i risultati della sincronizzazione file</string>
<string name="notification_channel_file_sync_name">Sincronizzazione file</string>
<string name="notification_channel_general_description">Mostra notifiche per le nuove cartelle multimediali e simili</string>
<string name="notification_channel_general_name">Notifiche generali</string>
<string name="notification_channel_media_description">Avanzamento del lettore musicale</string>
<string name="notification_channel_media_name">Lettore multimediale</string>
<string name="notification_channel_push_description">Mostra le notifiche push inviate dal server: menzioni nei commenti, ricezione di nuove condivisioni remote, annunci pubblicati da un amministratore ecc.</string>
<string name="notification_channel_push_name">Notifiche push</string>
<string name="notification_channel_upload_description">Mostra l\'avanzamento dei caricamenti</string>
<string name="notification_channel_upload_name_short">Upload</string>
<string name="notification_icon">Icona di notifica</string>
<string name="notifications_no_results_headline">Nessuna notifica</string>
<string name="notifications_no_results_message">Controlla nuovamente pi tardi.</string>
<string name="offline_mode">Nessuna connessione a Internet</string>
<string name="oneHour">1 ora</string>
<string name="online">In linea</string>
<string name="online_status">Stato in linea</string>
<string name="outdated_server">Il server ha raggiunto la fine della sua vita, aggiornalo!</string>
<string name="overflow_menu">Menu Altro</string>
<string name="pass_code_configure_your_pass_code">Digita il tuo codice segreto</string>
<string name="pass_code_configure_your_pass_code_explanation">Il codice segreto sar richiesto ogni volta che l\'applicazione avviata</string>
<string name="pass_code_enter_pass_code">Digita il tuo codice segreto</string>
<string name="pass_code_mismatch">I codici segreti non corrispondono</string>
<string name="pass_code_reenter_your_pass_code">Digita nuovamente il codice segreto</string>
<string name="pass_code_remove_your_pass_code">Elimina il tuo codice segreto</string>
<string name="pass_code_removed">Codice segreto eliminato</string>
<string name="pass_code_stored">Codice segreto memorizzato</string>
<string name="pass_code_wrong">Codice segreto non corretto</string>
<string name="pdf_password_protected">Impossibile aprire il PDF protetto da password. Usa un visualizzatore PDF esterno.</string>
<string name="pdf_zoom_tip">Tocca una pagina per ingrandire</string>
<string name="permission_allow">Consenti</string>
<string name="permission_deny">Nega</string>
<string name="permission_storage_access">Permessi aggiuntivi richiesti per caricare e scaricare i file.</string>
<string name="picture_set_as_no_app">Nessuna applicazione trovata per impostare un\'immagine</string>
<string name="pin_home">Appunta alla schermata iniziale</string>
<string name="pin_shortcut_label">Apri %1$s</string>
<string name="placeholder_fileSize">389 KB</string>
<string name="placeholder_filename">segnaposto.txt</string>
<string name="placeholder_media_time">12:23:45</string>
<string name="placeholder_sentence">Questo un segnaposto</string>
<string name="placeholder_timestamp">2012/05/18 12:23 PM</string>
<string name="player_stop">ferma</string>
<string name="player_toggle">attiva</string>
<string name="power_save_check_dialog_message">La disabilitazione del controllo di risparmio energetico potrebbe risultare in caricamenti di file in uno stato di bassa carica della batteria.</string>
<string name="pref_behaviour_entries_delete_file">eliminato</string>
<string name="pref_behaviour_entries_keep_file">lasciato nella cartella originale</string>
<string name="pref_behaviour_entries_move">spostato nella cartella dell\'applicazione</string>
<string name="pref_instant_name_collision_policy_dialogTitle">Cosa fare se il file esiste gi?</string>
<string name="pref_instant_name_collision_policy_entries_always_ask">Chiedimi ogni volta</string>
<string name="pref_instant_name_collision_policy_entries_cancel">Salta il caricamento</string>
<string name="pref_instant_name_collision_policy_entries_overwrite">Sovrascrivi la versione remota</string>
<string name="pref_instant_name_collision_policy_entries_rename">Rinomina la nuova versione</string>
<string name="pref_instant_name_collision_policy_title">Cosa fare se il file esiste gi?</string>
<string name="prefs_add_account">Aggiungi account</string>
<string name="prefs_calendar_contacts_no_store_error">F-Droid o Google Play non installato</string>
<string name="prefs_calendar_contacts_summary">Configura DAVx5 (originariamente conosciuto come DAVdroid) (v1.3.0+) per l\'account corrente</string>
<string name="prefs_calendar_contacts_sync_setup_successful">Sincronizzazione calendario e contatti configurata</string>
<string name="prefs_category_about">Informazioni</string>
<string name="prefs_category_details">Dettagli</string>
<string name="prefs_category_dev">Sviluppo</string>
<string name="prefs_category_general">Generale</string>
<string name="prefs_category_more">Altro</string>
<string name="prefs_daily_contact_backup_summary">Backup giornaliero dei tuoi contatti</string>
<string name="prefs_davx5_setup_error">Errore inaspettato nella configurazione di Davx5 (precedentemente DAVdroid)</string>
<string name="prefs_e2e_active">La cifratura end-to-end impostata!</string>
<string name="prefs_e2e_mnemonic">Codice mnemonico E2E</string>
<string name="prefs_e2e_no_device_credentials">Per mostrare il codice mnemonico, abilita le credenziali del dispositivo.</string>
<string name="prefs_enable_media_scan_notifications">Mostra notifiche di scansione dei supporti</string>
<string name="prefs_enable_media_scan_notifications_summary">Notifica per le nuove cartelle multimediali trovate</string>
<string name="prefs_help">Aiuto</string>
<string name="prefs_imprint">Imprint</string>
<string name="prefs_instant_behaviour_dialogTitle">Il file originale sar</string>
<string name="prefs_instant_behaviour_title">Il file originale sar</string>
<string name="prefs_instant_upload_exclude_hidden_summary">Escludi file e cartelle nascoste</string>
<string name="prefs_instant_upload_path_use_date_subfolders_summary">Archivia in sottocartelle in base alla data</string>
<string name="prefs_instant_upload_path_use_subfolders_title">Usa sottocartelle</string>
<string name="prefs_instant_upload_subfolder_rule_title">Opzioni sottocartella</string>
<string name="prefs_keys_exist">Abilit la cifratura end-to-end a questo client</string>
<string name="prefs_license">Licenza</string>
<string name="prefs_lock">Codice di sicurezza</string>
<string name="prefs_lock_device_credentials_enabled">Credenziali di dispositivo abilitate</string>
<string name="prefs_lock_device_credentials_not_setup">Non son state configurate credenziali di dispositivo</string>
<string name="prefs_lock_none">Nessuno</string>
<string name="prefs_lock_title">Proteggi l\'applicazione utilizzando</string>
<string name="prefs_lock_using_device_credentials">Credenziali di dispositivo</string>
<string name="prefs_lock_using_passcode">Codice di sicurezza</string>
<string name="prefs_manage_accounts">Gestisci account</string>
<string name="prefs_recommend">Consiglia a un amico</string>
<string name="prefs_remove_e2e">Rimuovi la cifratura localmente</string>
<string name="prefs_setup_e2e">Configura la cifratura end-to-end</string>
<string name="prefs_show_ecosystem_apps">Mostra il selettore delle applicazioni</string>
<string name="prefs_show_ecosystem_apps_summary">Consigli delle applicazioni di Nextcloud nell\'intestazione di navigazione</string>
<string name="prefs_show_hidden_files">Mostra i file nascosti</string>
<string name="prefs_sourcecode">Ottieni codice sorgente</string>
<string name="prefs_storage_path">Cartella di archiviazione dei dati</string>
<string name="prefs_sycned_folders_summary">Gestisci le cartelle per il caricamento automatico</string>
<string name="prefs_synced_folders_local_path_title">Cartella locale</string>
<string name="prefs_synced_folders_remote_path_title">Cartella remota</string>
<string name="prefs_theme_title">Tema</string>
<string name="prefs_value_theme_dark">Scuro</string>
<string name="prefs_value_theme_light">Chiaro</string>
<string name="prefs_value_theme_system">Segui il sistema</string>
<string name="preview_image_description">Anteprima dell\'immagine</string>
<string name="preview_image_error_no_local_file">Non esiste un file locale per l\'anteprima</string>
<string name="preview_image_error_unknown_format">Impossibile mostrare l\'immagine</string>
<string name="preview_image_file_is_not_exist">Il file non esiste</string>
<string name="preview_sorry">Spiacenti</string>
<string name="privacy">Riservatezza</string>
<string name="public_share_name">Nuovo nome</string>
<string name="push_notifications_not_implemented">Notifiche push disabilitate a causa delle dipendenze dai servizi proprietari di Google Play.</string>
<string name="push_notifications_old_login">Nessuna notifica push a causa della sessione di accesso scaduta. Considera di aggiungere nuovamente il tuo account.</string>
<string name="push_notifications_temp_error">Notifiche push attualmente non disponibili.</string>
<string name="qr_could_not_be_read">Il codice QR non pu essere letto!</string>
<string name="recommend_subject">Prova %1$s sul tuo dispositivo!</string>
<string name="recommend_text">Vorrei invitarti a utilizzare %1$s sul tuo dispositivo.\nScaricalo qui:%2$s</string>
<string name="recommend_urls">%1$s o %2$s</string>
<string name="refresh_content">Ricarica il contenuto</string>
<string name="reload">Ricarica</string>
<string name="remote">(remota)</string>
<string name="remote_file_fetch_failed">File non trovato!</string>
<string name="remove_e2e">Su questo client puoi rimuovere localmente la cifratura end-to-end</string>
<string name="remove_e2e_message">Su questo client puoi rimuovere localmente la cifratura end-to-end. I file cifrati rimarranno sul server, ma non verranno pi sincronizzati su questo computer.</string>
<string name="remove_fail_msg">Eliminazione non riuscita</string>
<string name="remove_local_account">Rimuovi account locale</string>
<string name="remove_local_account_details">Rimuovi account dal dispositivo e elimina tutti i file locali</string>
<string name="remove_notification_failed">Rimozione notifica non riuscita.</string>
<string name="remove_push_notification">Rimuovi</string>
<string name="remove_success_msg">Eliminato</string>
<string name="rename_dialog_title">Digita un nuovo nome</string>
<string name="rename_local_fail_msg">La copia locale non pu essere rinominata, prova un nome diverso</string>
<string name="rename_server_fail_msg">Rinomina non consentita, nome gi utilizzato</string>
<string name="request_account_deletion">Richiesta di eliminazione account</string>
<string name="request_account_deletion_button">Richiedi eliminazione</string>
<string name="request_account_deletion_details">Richiedi l\'eliminazione permanente dell\'account al fornitore del servizio</string>
<string name="reshare_not_allowed">La ri-condivisione non consentita</string>
<string name="resharing_is_not_allowed">La ri-condivisione non consentita</string>
<string name="resized_image_not_possible_download">Immagine ridimensionata non disponibile. Scaricare l\'immagine completa?</string>
<string name="restore">Ripristina file</string>
<string name="restore_backup">Ripristina backup</string>
<string name="restore_button_description">Ripristina file eliminato</string>
<string name="restore_selected">Ripristina selezionato</string>
<string name="retrieving_file">Recupero file</string>
<string name="richdocuments_failed_to_load_document">Caricamento del documento non riuscito!</string>
<string name="scanQR_description">Accedi tramite codice QR</string>
<string name="scan_page">Scansiona la pagina</string>
<string name="screenshot_01_gridView_heading">Proteggere i tuoi dati</string>
<string name="screenshot_01_gridView_subline">produttivit auto-gestita</string>
<string name="screenshot_02_listView_heading">Sfoglia e condividi</string>
<string name="screenshot_02_listView_subline">tutte le azioni a portata di mano</string>
<string name="screenshot_03_drawer_heading">Attivit, condivisioni, ...</string>
<string name="screenshot_03_drawer_subline">tutto rapidamente accessibile</string>
<string name="screenshot_04_accounts_heading">Tutti i tuoi account</string>
<string name="screenshot_04_accounts_subline">in un posto</string>
<string name="screenshot_05_autoUpload_heading">Caricamento automatico</string>
<string name="screenshot_05_autoUpload_subline">per le tue foto e video</string>
<string name="screenshot_06_davdroid_subline">Sincronizza con DAVx5</string>
<string name="search_error">Errore nel recuperare i risultati della ricerca</string>
<string name="select_all">Seleziona tutto</string>
<string name="select_media_folder">Imposta cartella multimediale</string>
<string name="select_one_template">Scegli un modello</string>
<string name="select_template">Seleziona modello</string>
<string name="send">Invia</string>
<string name="send_share">Invia condivisione</string>
<string name="sendbutton_description">Icona pulsante di invio</string>
<string name="set_as">Imposta come</string>
<string name="set_note">Imposta nota</string>
<string name="set_picture_as">Usa immagine come</string>
<string name="set_status">Imposta stato</string>
<string name="set_status_message">Imposta messaggio di stato</string>
<string name="setup_e2e">Configurando la cifratura end-to-end, riceverai una frase di 12 parole mnemoniche casuali, che ti servir per aprire i tuoi file su altri dispositivi. Questa sar conservata solo su questo dispositivo, e pu essere mostrata di nuovo in questa schermata. Annotala in un posto sicuro!</string>
<string name="share">Condividi</string>
<string name="share_copy_link">Condividi e copia il collegamento</string>
<string name="share_dialog_title">Condivisione</string>
<string name="share_expiration_date_format">%1$s</string>
<string name="share_expiration_date_label">Scade il %1$s</string>
<string name="share_file">Condividi %1$s</string>
<string name="share_group_clarification">%1$s (gruppo)</string>
<string name="share_internal_link">Condividi collegamento interno</string>
<string name="share_internal_link_to_file_text">Il collegamento di condivisione funziona solo per gli utenti con accesso a questo file</string>
<string name="share_internal_link_to_folder_text">Il collegamento di condivisione funziona solo per gli utenti con accesso a questa cartella</string>
<string name="share_known_remote_on_clarification">su %1$s</string>
<string name="share_link">Condividi collegamento</string>
<string name="share_link_empty_password">Devi digitare una password</string>
<string name="share_link_file_error">Si verificato un errore durante il tentativo di condivisione del file o della cartella.</string>
<string name="share_link_file_no_exist">Impossibile condividere. Assicurati che il file esista.</string>
<string name="share_link_forbidden_permissions">per condividere questo file</string>
<string name="share_link_optional_password_title">Digita una password facoltativa</string>
<string name="share_link_password_title">Digita una password</string>
<string name="share_link_with_label">Collegamento di condivisione (%1$s)</string>
<string name="share_no_expiration_date_label">Imposta data di scadenza</string>
<string name="share_no_password_title">Imposta password</string>
<string name="share_password_title">Protetta da password</string>
<string name="share_permission_can_edit">Pu modificare</string>
<string name="share_permission_file_drop">Elimina file</string>
<string name="share_permission_secure_file_drop">File drop sicuro</string>
<string name="share_permission_view_only">Sola lettura</string>
<string name="share_permissions">Condividi permessi</string>
<string name="share_remote_clarification">%1$s (remota)</string>
<string name="share_room_clarification">%1$s (conversazione)</string>
<string name="share_search">Nome, ID di cloud federata o indirizzo email</string>
<string name="share_send_new_email">Invia una nuova email</string>
<string name="share_send_note">Nota per destinatario</string>
<string name="share_settings">Impostazioni</string>
<string name="share_via_link_hide_download">Nascondi scaricamento</string>
<string name="share_via_link_section_title">Condividi collegamento</string>
<string name="share_via_link_send_link_label">Invia collegamento</string>
<string name="share_via_link_unset_password">Rimuovi</string>
<string name="share_with_title">Condividi con</string>
<string name="shared_avatar_desc">Avatar da un utente condiviso</string>
<string name="shared_icon_share">condivisione</string>
<string name="shared_icon_shared">condiviso</string>
<string name="shared_icon_shared_via_link">condiviso tramite collegamento</string>
<string name="shared_with_you_by">Condiviso con te da %1$s</string>
<string name="sharee_add_failed">Aggiunta condivisione non riuscita</string>
<string name="show_images">Mostra le foto</string>
<string name="show_video">Mostra i video</string>
<string name="signup_with_provider">Registrati a un fornitore</string>
<string name="single_sign_on_request_token" formatted="true">Vuoi consentire a %1$s di accedere al tuo account Nextcloud %2$s?</string>
<string name="sort_by">Ordina per</string>
<string name="ssl_validator_btn_details_hide">Nascondi</string>
<string name="ssl_validator_btn_details_see">Dettagli</string>
<string name="ssl_validator_header">L\'identit del server non pu essere verificata</string>
<string name="ssl_validator_label_C">Nazione:</string>
<string name="ssl_validator_label_CN">Nome comune:</string>
<string name="ssl_validator_label_L">Posizione:</string>
<string name="ssl_validator_label_O">Organizzazione:</string>
<string name="ssl_validator_label_OU">Unit organizzativa:</string>
<string name="ssl_validator_label_ST">Stato:</string>
<string name="ssl_validator_label_certificate_fingerprint">Impronta digitale:</string>
<string name="ssl_validator_label_issuer">Emesso da:</string>
<string name="ssl_validator_label_signature">Firma:</string>
<string name="ssl_validator_label_signature_algorithm">Algoritmo:</string>
<string name="ssl_validator_label_subject">Emesso a:</string>
<string name="ssl_validator_label_validity">Validit:</string>
<string name="ssl_validator_label_validity_from">Da:</string>
<string name="ssl_validator_label_validity_to">A:</string>
<string name="ssl_validator_no_info_about_error">- Nessuna informazione sull\'errore</string>
<string name="ssl_validator_not_saved">Impossibile salvare il certificato</string>
<string name="ssl_validator_null_cert">Il certificato non pu essere mostrato.</string>
<string name="ssl_validator_question">Vuoi fidarti comunque di questo certificato?</string>
<string name="ssl_validator_reason_cert_expired">- Il certificato del server scaduto</string>
<string name="ssl_validator_reason_cert_not_trusted">- Il certificato del server non affidabile</string>
<string name="ssl_validator_reason_cert_not_yet_valid">- Il certificato del server troppo recente</string>
<string name="ssl_validator_reason_hostname_not_verified">- L\'URL non corrisponde al nome host nel certificato</string>
<string name="status_message">Messaggio di stato</string>
<string name="storage_camera">Fotocamera</string>
<string name="storage_choose_location">Scegli la posizione di archiviazione</string>
<string name="storage_description_default">Predefinito</string>
<string name="storage_documents">Documenti</string>
<string name="storage_downloads">Scaricamenti</string>
<string name="storage_internal_storage">Archiviazione interna</string>
<string name="storage_movies">Video</string>
<string name="storage_music">Musica</string>
<string name="storage_permission_full_access">Accesso completo</string>
<string name="storage_permission_media_read_only">Multimediali in sola lettura</string>
<string name="storage_pictures">Immagini</string>
<string name="store_full_dev_desc">La piattaforma di produttivit auto-gestita che ti lascia al comando.\nQuesta la versione di sviluppo ufficiale e include funzionalit nuove, non testate che potrebbero provocare instabilit e perdite di dati. Questa applicazione pensata per gli utenti che desiderano provare le nuove funzionalit e segnalare bug, se si verificano. Non utilizzarla in ambienti di produzione!\n\nSia la versione di sviluppo che quella normale sono disponibili su F-droid, e possono essere installate contemporaneamente.</string>
<string name="store_short_desc">La piattaforma di produttivit auto-gestita che ti lascia al comando</string>
<string name="store_short_dev_desc">La piattaforma di produttivit auto-gestita che ti lascia al comando (versione in anteprima di sviluppo)</string>
<string name="stream">Trasmetti con</string>
<string name="stream_not_possible_headline">Trasmissione interna non possibile</string>
<string name="stream_not_possible_message">Scarica invece il media o usa un\'applicazione esterna.</string>
<string name="strict_mode">Modalit rigorosa: nessuna connessione HTTP consentita! </string>
<string name="sub_folder_rule_day">Anno/Mese/Giorno</string>
<string name="sub_folder_rule_month">Anno/Mese</string>
<string name="sub_folder_rule_year">Anno</string>
<string name="subject_shared_with_you">\"%1$s\" stato condiviso con te</string>
<string name="subject_user_shared_with_you">%1$s ha condiviso \"%2$s\" con te</string>
<string name="subtitle_photos_only">Solo foto</string>
<string name="subtitle_photos_videos">Foto e video</string>
<string name="subtitle_videos_only">Solo video</string>
<string name="suggest">Suggerisci</string>
<string name="sync_conflicts_in_favourites_ticker">Conflitti rilevati</string>
<string name="sync_current_folder_was_removed">La cartella %1$s non esiste pi</string>
<string name="sync_fail_content">Impossibile sincronizzare %1$s</string>
<string name="sync_fail_content_unauthorized">Password errata per %1$s</string>
<string name="sync_fail_in_favourites_ticker">Sincronizzazione dei file non riuscita</string>
<string name="sync_fail_ticker">Sincronizzazione non riuscita</string>
<string name="sync_fail_ticker_unauthorized">Sincronizzazione non riuscita, effettua nuovamente l\'accesso</string>
<string name="sync_file_nothing_to_do_msg">Contenuti del file gi sincronizzati</string>
<string name="sync_folder_failed_content">La sincronizzazione della cartella %1$s non pu essere completata</string>
<string name="sync_foreign_files_forgotten_explanation">Dalla versione 1.3.16, i file caricati da questo dispositivo sono copiati nella cartella locale %1$s per evitare perdite di dati quando un singolo file sincronizzato con pi account.\n\nA causa di questa modifica, tutti i file caricati con versioni precedenti di questa applicazione sono stati copiati nella cartella %2$s. Tuttavia, un errore ha impedito il completamento di questa operazione durante la sincronizzazione dell\'account. Puoi sia lasciare i file come sono ed eliminare il collegamento a %3$s, o spostare i file nella cartella %1$s e mantenere il collegamento a %4$s.\n\nSotto sono elencati i file locali e i file remoti in %5$sai quali erano collegati.</string>
<string name="sync_foreign_files_forgotten_ticker">Alcuni file locali sono stati trascurati</string>
<string name="sync_in_progress">Recupero della versione pi recente del file in corso.</string>
<string name="sync_not_enough_space_dialog_action_choose">Scegli cosa sincronizzare</string>
<string name="sync_not_enough_space_dialog_action_free_space">Libera spazio</string>
<string name="sync_not_enough_space_dialog_placeholder">%1$s %2$s, ma c\' solo %3$s disponibile su questo dispositivo.</string>
<string name="sync_not_enough_space_dialog_title">Spazio insufficiente</string>
<string name="sync_status_button">Pulsante stato di sincronizzazione</string>
<string name="sync_string_files">File</string>
<string name="synced_folder_settings_button">Pulsante impostazioni</string>
<string name="synced_folders_configure_folders">Configura cartelle</string>
<string name="synced_folders_new_info">Il caricamento istantaneo stato riscritto completamente. Riconfigura il caricamento automatico dal menu principale.\n\nGoditi il nuovo ed esteso caricamento automatico.</string>
<string name="synced_folders_no_results">Nessuna cartella multimediale trovata</string>
<string name="synced_folders_preferences_folder_path">Per %1$s</string>
<string name="synced_folders_type">Tipo</string>
<string name="synced_icon">Sincronizzato</string>
<string name="tags">Etichette</string>
<string name="test_server_button">Prova di connessione al server</string>
<string name="thirtyMinutes">30 minuti</string>
<string name="thisWeek">Questa settimana</string>
<string name="thumbnail">Miniatura</string>
<string name="thumbnail_for_existing_file_description">Miniatura per il file esistente</string>
<string name="thumbnail_for_new_file_desc">Miniatura per il nuovo file</string>
<string name="timeout_richDocuments">Il caricamento sta impiegando pi del previsto</string>
<string name="today">Oggi</string>
<string name="trashbin_activity_title">File eliminati</string>
<string name="trashbin_empty_headline">Nessun file eliminato</string>
<string name="trashbin_empty_message">Potrai ripristinare i file eliminati da qui.</string>
<string name="trashbin_file_not_deleted">Il file %1$s non pu essere eliminato!</string>
<string name="trashbin_file_not_restored">Il file %1$s non pu essere ripristinato!</string>
<string name="trashbin_file_remove">Elimina permanentemente</string>
<string name="trashbin_loading_failed">Caricamento cestino non riuscito!</string>
<string name="trashbin_not_emptied">I file non possono essere scaricati definitivamente!</string>
<string name="unlock_file">Sblocca file</string>
<string name="unread_comments">Sono presenti commenti non letti</string>
<string name="unset_encrypted">Rimuovi cifratura</string>
<string name="unset_favorite">Rimuovi dai preferiti</string>
<string name="unshare_link_file_error">Si verificato un errore durante il tentativo di rimozione della condivisione del file o della cartella.</string>
<string name="unshare_link_file_no_exist">Impossibile rimuovere la condivisione. Assicurati che il file esista.</string>
<string name="unshare_link_forbidden_permissions">per rimuovere la condivisione di questo file</string>
<string name="unsharing_failed">Rimozione condivisione non riuscita</string>
<string name="untrusted_domain">Accesso tramite un dominio non fidato. Vedi la documentazione per ulteriori informazioni.</string>
<string name="update_link_file_error">Si verificato un errore durante il tentativo di aggiornare la condivisione.</string>
<string name="update_link_file_no_exist">Impossibile aggiornare. Assicurati che il file esista.</string>
<string name="update_link_forbidden_permissions">per aggiornare questa condivisione</string>
<string name="updating_share_failed">Aggiornamento condivisione non riuscito</string>
<string name="upload_action_failed_clear">Cancella caricamenti non riusciti</string>
<string name="upload_action_failed_retry">Riprova caricamenti non riusciti</string>
<string name="upload_cannot_create_file">Impossibile creare il file locale</string>
<string name="upload_chooser_title">Carica da</string>
<string name="upload_content_from_other_apps">Carica contenuti da altre applicazioni</string>
<string name="upload_direct_camera_upload">Carica dalla fotocamera</string>
<string name="upload_file_dialog_filename">Nome file</string>
<string name="upload_file_dialog_filetype">Tipo file</string>
<string name="upload_file_dialog_filetype_googlemap_shortcut">File di scorciatoia Google Maps (%s)</string>
<string name="upload_file_dialog_filetype_internet_shortcut">File di scorciatoia Internet (%s)</string>
<string name="upload_file_dialog_filetype_snippet_text">File di frammento di testo(.txt)</string>
<string name="upload_file_dialog_title">Digita il nome e il tipo di file da caricare</string>
<string name="upload_files">Carica file</string>
<string name="upload_item_action_button">Pulsante azione Carica elemento</string>
<string name="upload_list_delete">Elimina</string>
<string name="upload_list_empty_headline">Nessun caricamento disponibile</string>
<string name="upload_list_empty_text_auto_upload">Carica dei contenuti o attiva il caricamento automatico.</string>
<string name="upload_list_resolve_conflict">Risolvi conflitto</string>
<string name="upload_local_storage_full">Archiviazione locale piena</string>
<string name="upload_local_storage_not_copied">Il file non pu essere copiato nell\'archiviazione locale</string>
<string name="upload_lock_failed">Blocco della cartella non riuscito</string>
<string name="upload_manually_cancelled">Caricamento annullato dall\'utente</string>
<string name="upload_old_android">La cifratura possibile solo con >= Android 5.0</string>
<string name="upload_query_move_foreign_files">La mancanza di spazio impedisce di copiare i file selezionati nella cartella %1$s. Vuoi spostarli in quella cartella?</string>
<string name="upload_quota_exceeded">Quota di archiviazione superata</string>
<string name="upload_scan_doc_upload">Scansiona il documento dalla fotocamera</string>
<string name="upload_sync_conflict">Conflitto di sincronizzazione, risolvi manualmente</string>
<string name="upload_unknown_error">Errore sconosciuto</string>
<string name="uploader_btn_alternative_text">Scegli</string>
<string name="uploader_btn_upload_text">Carica</string>
<string name="uploader_error_message_no_file_to_upload">I dati ricevuti non includono alcun file valido.</string>
<string name="uploader_error_message_read_permission_not_granted">%1$s non ha il permesso di leggere un file ricevuto</string>
<string name="uploader_error_message_source_file_not_copied">Impossibile copiare il file in una cartella temporanea. Prova a inviarlo nuovamente.</string>
<string name="uploader_error_message_source_file_not_found">File selezionato per il caricamento non trovato. Controlla se il file esiste.</string>
<string name="uploader_error_title_file_cannot_be_uploaded">Questo file non pu essere caricato</string>
<string name="uploader_error_title_no_file_to_upload">Nessun file da caricare</string>
<string name="uploader_info_dirname">Nome della cartella</string>
<string name="uploader_top_message">Scegli la cartella di caricamento</string>
<string name="uploader_upload_failed_content_single">Impossibile caricare %1$s</string>
<string name="uploader_upload_failed_credentials_error">Caricamento non riuscito, effettua nuovamente l\'accesso</string>
<string name="uploader_upload_failed_sync_conflict_error">Conflitto caricamento file</string>
<string name="uploader_upload_failed_sync_conflict_error_content">Scegli quale versione mantenere di %1$s</string>
<string name="uploader_upload_failed_ticker">Caricamento non riuscito</string>
<string name="uploader_upload_files_behaviour">Opzione di caricamento:</string>
<string name="uploader_upload_files_behaviour_move_to_nextcloud_folder">Sposta il file nella cartella %1$s</string>
<string name="uploader_upload_files_behaviour_not_writable">la cartella di origine in sola lettura, i file saranno solo caricati</string>
<string name="uploader_upload_files_behaviour_only_upload">Mantieni il file nella cartella di origine</string>
<string name="uploader_upload_files_behaviour_upload_and_delete_from_source">Elimina il file dalla cartella di origine</string>
<string name="uploader_upload_forbidden_permissions">per caricare in questa cartella</string>
<string name="uploader_upload_in_progress">%1$d%% %2$s</string>
<string name="uploader_upload_in_progress_content">%1$d%% Caricamento di %2$s</string>
<string name="uploader_upload_in_progress_ticker">Caricamento in corso</string>
<string name="uploader_upload_succeeded_content_single">%1$s caricato</string>
<string name="uploader_wrn_no_account_quit_btn_text">Esci</string>
<string name="uploader_wrn_no_account_setup_btn_text">Configurazione</string>
<string name="uploader_wrn_no_account_text">Non ci sono account %1$s sul tuo dispositivo. Configura prima un account.</string>
<string name="uploader_wrn_no_account_title">Nessun account trovato</string>
<string name="uploads_view_group_current_uploads">Attuale</string>
<string name="uploads_view_group_failed_uploads">Riavvio non riuscito/in corso</string>
<string name="uploads_view_group_finished_uploads">Caricati</string>
<string name="uploads_view_group_manually_cancelled_uploads">Annullato</string>
<string name="uploads_view_later_waiting_to_upload">In attesa di caricamento</string>
<string name="uploads_view_title">Caricamenti</string>
<string name="uploads_view_upload_status_cancelled">Annullati</string>
<string name="uploads_view_upload_status_conflict">Conflitto</string>
<string name="uploads_view_upload_status_failed_connection_error">Errore di connessione</string>
<string name="uploads_view_upload_status_failed_credentials_error">Errore di credenziali</string>
<string name="uploads_view_upload_status_failed_file_error">Errore di file</string>
<string name="uploads_view_upload_status_failed_folder_error">Errore di cartella</string>
<string name="uploads_view_upload_status_failed_localfile_error">File locale non trovato</string>
<string name="uploads_view_upload_status_failed_permission_error">Errore di permessi</string>
<string name="uploads_view_upload_status_failed_ssl_certificate_not_trusted">Certificato server non fidato</string>
<string name="uploads_view_upload_status_fetching_server_version">Recupero versione del server</string>
<string name="uploads_view_upload_status_service_interrupted">Applicazione terminata</string>
<string name="uploads_view_upload_status_succeeded">Completati</string>
<string name="uploads_view_upload_status_unknown_fail">Errore sconosciuto</string>
<string name="uploads_view_upload_status_virus_detected">Virus rilevato! Impossibile caricare il file!</string>
<string name="uploads_view_upload_status_waiting_exit_power_save_mode">In attesa di uscire dal risparmio energetico</string>
<string name="uploads_view_upload_status_waiting_for_charging">In attesa della carica</string>
<string name="uploads_view_upload_status_waiting_for_wifi">In attesa di Wi-Fi senza limitazioni</string>
<string name="user_icon">Utente</string>
<string name="user_info_address">Indirizzo</string>
<string name="user_info_email">Email</string>
<string name="user_info_phone">Numero di telefono</string>
<string name="user_info_twitter">Twitter</string>
<string name="user_info_website">Sito web</string>
<string name="user_information_retrieval_error">Errore durante il recupero delle informazioni utente</string>
<string name="userinfo_no_info_headline">Nessuna informazione personale impostata</string>
<string name="userinfo_no_info_text">Aggiungi nome, immagine e dettagli di contatto sulla tua pagina di profilo.</string>
<string name="username">Nome utente</string>
<string name="version_dev_download">Scarica</string>
<string name="video_overlay_icon">Icona di sovrapposizione video</string>
<string name="wait_a_moment">Attendi</string>
<string name="wait_checking_credentials">Controllo delle credenziali memorizzate</string>
<string name="wait_for_tmp_copy_from_private_storage">Copia file dall\'archiviazione privata</string>
<string name="webview_version_check_alert_dialog_message">Aggiorna l\'applicazione System WebView di Android per accedere</string>
<string name="webview_version_check_alert_dialog_positive_button_title">Aggiorna</string>
<string name="webview_version_check_alert_dialog_title">Aggiorna System WebView di Android</string>
<string name="what_s_new_image">Immagine Cosa c\' di nuovo</string>
<string name="whats_new_skip">Salta</string>
<string name="whats_new_title">Prima volta su %1$s</string>
<string name="whats_your_status">Qual il tuo stato?</string>
<string name="widgets_not_available">I widget sono disponibili solo su %1$s 25 o dopo </string>
<string name="widgets_not_available_title">Non disponibile</string>
<string name="worker_download">Scaricamento file in corso</string>
<string name="write_email">Invia email</string>
<string name="wrong_storage_path">La cartella di archiviazione dei dati non esiste!</string>
<string name="wrong_storage_path_desc">Ci potrebbe essere dovuto a un ripristino di backup su un altro dispositivo. Ripristino del valore predefinito. Controlla le impostazioni per modificare la cartella di archiviazione dei dati.</string>
<plurals name="sync_fail_in_favourites_content">
<item quantity="one">Impossibile sincronizzare %1$d file (conflitto con: %2$d)</item>
<item quantity="many">Impossibile sincronizzare %1$d file (conflitto con: %2$d)</item>
<item quantity="other">Impossibile sincronizzare %1$d file (conflitto con: %2$d)</item>
</plurals>
<plurals name="sync_foreign_files_forgotten_content">
<item quantity="one">Copia di %1$d file fallita dalla cartella %2$s a</item>
<item quantity="many">Copia di %1$d file fallita dalla cartella %2$s a</item>
<item quantity="other">Copia di %1$d file fallita dalla cartella %2$s a</item>
</plurals>
<plurals name="wrote_n_events_to">
<item quantity="one">Scritto %1$d evento in %2$s</item>
<item quantity="many">Scritti %1$d eventi in %2$s</item>
<item quantity="other">Scritti %1$d eventi in %2$s</item>
</plurals>
<plurals name="created_n_uids_to">
<item quantity="one">Creato %1$d UID nuovo</item>
<item quantity="many">Creati %1$d UID nuovi</item>
<item quantity="other">Creati %1$d UID nuovi</item>
</plurals>
<plurals name="processed_n_entries">
<item quantity="one">Processata %d voce</item>
<item quantity="many">Processate %d voci</item>
<item quantity="other">Processate %d voci</item>
</plurals>
<plurals name="found_n_duplicates">
<item quantity="one">Trovata %d voce duplicata</item>
<item quantity="many">Trovate %d voci duplicate</item>
<item quantity="other">Trovate %d voci duplicate</item>
</plurals>
<plurals name="export_successful">
<item quantity="one">%d File esportato</item>
<item quantity="many">%d file esportati</item>
<item quantity="other">%d file esportati</item>
</plurals>
<plurals name="export_failed">
<item quantity="one">Esportazione non riuscita di %d file</item>
<item quantity="many">Esportazione non riuscita di %d file</item>
<item quantity="other">Esportazione non riuscita di %d file</item>
</plurals>
<plurals name="export_partially_failed">
<item quantity="one">Esportato %dfile , il resto saltato a causa di un errore</item>
<item quantity="many">Esportati %d files, il resto saltato a causa di un errore</item>
<item quantity="other">Esportati %d file, il resto saltato a causa di un errore</item>
</plurals>
<plurals name="export_start">
<item quantity="one">%dfile sar esportato. Vedi la notifica per i dettagli.</item>
<item quantity="many">%dfile saranno esportati. Vedi la notifica per i dettagli.</item>
<item quantity="other">%d file saranno esportati. Vedi la notifica per i dettagli.</item>
</plurals>
<plurals name="file_list__footer__folder">
<item quantity="one">%1$d cartella</item>
<item quantity="many">%1$d cartelle</item>
<item quantity="other">%1$d cartelle</item>
</plurals>
<plurals name="file_list__footer__file">
<item quantity="one">%1$d file</item>
<item quantity="many">%1$d file</item>
<item quantity="other">%1$d file</item>
</plurals>
<plurals name="synced_folders_show_hidden_folders">
<item quantity="one">Mostra %1$d cartella nascosta</item>
<item quantity="many">Mostra %1$d cartelle nascoste</item>
<item quantity="other">Mostra %1$d cartelle nascoste</item>
</plurals>
<plurals name="items_selected_count">
<item quantity="one">%d selezionato</item>
<item quantity="many">%d selezionati</item>
<item quantity="other">%d selezionati</item>
</plurals>
</resources>
``` | /content/code_sandbox/app/src/main/res/values-it/strings.xml | xml | 2016-06-06T21:23:36 | 2024-08-16T18:22:36 | android | nextcloud/android | 4,122 | 22,198 |
```xml
import { Platform } from '@standardnotes/snjs'
import { KeyboardModifier } from './KeyboardModifier'
function isMacPlatform(platform: Platform) {
return platform === Platform.MacDesktop || platform === Platform.MacWeb
}
export function keyboardCharacterForModifier(modifier: KeyboardModifier, platform: Platform) {
const isMac = isMacPlatform(platform)
if (modifier === KeyboardModifier.Meta) {
return isMac ? '' : ''
} else if (modifier === KeyboardModifier.Ctrl) {
return isMac ? '' : 'Ctrl'
} else if (modifier === KeyboardModifier.Alt) {
return isMac ? '' : 'Alt'
} else if (modifier === KeyboardModifier.Shift) {
return isMac ? '' : 'Shift'
} else {
return KeyboardModifier[modifier]
}
}
``` | /content/code_sandbox/packages/ui-services/src/Keyboard/keyboardCharacterForModifier.ts | xml | 2016-12-05T23:31:33 | 2024-08-16T06:51:19 | app | standardnotes/app | 5,180 | 176 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="path_to_url" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
<file datatype="xml" source-language="en" target-language="it" original="../FSStrings.resx">
<body>
<trans-unit id="ArgumentsInSigAndImplMismatch">
<source>The argument names in the signature '{0}' and implementation '{1}' do not match. The argument name from the signature file will be used. This may cause problems when debugging or profiling.</source>
<target state="translated">I nomi degli argomenti nella firma '{0}' e nell'implementazione '{1}' non corrispondono. Verr usato il nome dell'argomento del file di firma. Questa situazione potrebbe causare problemi durante il debug o la profilatura.</target>
<note />
</trans-unit>
<trans-unit id="ErrorFromAddingTypeEquationTuples">
<source>Type mismatch. Expecting a tuple of length {0} of type\n {1} \nbut given a tuple of length {2} of type\n {3} {4}\n</source>
<target state="translated">Tipo non corrispondente. prevista una tupla di lunghezza {0} di tipo\n {1} \n, ma stata specificata una tupla di lunghezza {2} di tipo\n {3}{4}\n</target>
<note />
</trans-unit>
<trans-unit id="HashLoadedSourceHasIssues0">
<source>One or more informational messages in loaded file.\n</source>
<target state="translated">Uno o pi messaggi informativi nel file caricato.\n</target>
<note />
</trans-unit>
<trans-unit id="NotUpperCaseConstructorWithoutRQA">
<source>Lowercase discriminated union cases are only allowed when using RequireQualifiedAccess attribute</source>
<target state="translated">I casi di unione discriminati minuscoli sono consentiti solo quando si usa l'attributo RequireQualifiedAccess</target>
<note />
</trans-unit>
<trans-unit id="OverrideShouldBeInstance">
<source> Non-static member is expected.</source>
<target state="new"> Non-static member is expected.</target>
<note />
</trans-unit>
<trans-unit id="OverrideShouldBeStatic">
<source> Static member is expected.</source>
<target state="new"> Static member is expected.</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.DOT.DOT.HAT">
<source>symbol '..^'</source>
<target state="translated">simbolo '..^'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INTERP.STRING.BEGIN.END">
<source>interpolated string</source>
<target state="translated">stringa interpolata</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INTERP.STRING.BEGIN.PART">
<source>interpolated string (first part)</source>
<target state="translated">stringa interpolata (prima parte)</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INTERP.STRING.END">
<source>interpolated string (final part)</source>
<target state="translated">stringa interpolata (ultima parte)</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INTERP.STRING.PART">
<source>interpolated string (part)</source>
<target state="translated">stringa interpolata (parte)</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.WHILE.BANG">
<source>keyword 'while!'</source>
<target state="translated">parola chiave "while"</target>
<note />
</trans-unit>
<trans-unit id="SeeAlso">
<source>. See also {0}.</source>
<target state="translated">. Vedere anche {0}.</target>
<note />
</trans-unit>
<trans-unit id="ConstraintSolverTupleDiffLengths">
<source>The tuples have differing lengths of {0} and {1}</source>
<target state="translated">Le tuple sono di lunghezza diversa, ovvero {0} e {1}</target>
<note />
</trans-unit>
<trans-unit id="ConstraintSolverInfiniteTypes">
<source>The types '{0}' and '{1}' cannot be unified.</source>
<target state="translated">Non possibile unificare i tipi '{0}' e '{1}'.</target>
<note />
</trans-unit>
<trans-unit id="ConstraintSolverMissingConstraint">
<source>A type parameter is missing a constraint '{0}'</source>
<target state="translated">Vincolo '{0}' mancante in un parametro di tipo</target>
<note />
</trans-unit>
<trans-unit id="ConstraintSolverTypesNotInEqualityRelation1">
<source>The unit of measure '{0}' does not match the unit of measure '{1}'</source>
<target state="translated">L'unit di misura '{0}' non corrisponde all'unit di misura '{1}'</target>
<note />
</trans-unit>
<trans-unit id="ConstraintSolverTypesNotInEqualityRelation2">
<source>The type '{0}' does not match the type '{1}'</source>
<target state="translated">Il tipo '{0}' non corrisponde al tipo '{1}'</target>
<note />
</trans-unit>
<trans-unit id="ConstraintSolverTypesNotInSubsumptionRelation">
<source>The type '{0}' is not compatible with the type '{1}'{2}</source>
<target state="translated">Il tipo '{0}' non compatibile con il tipo '{1}'{2}</target>
<note />
</trans-unit>
<trans-unit id="ErrorFromAddingTypeEquation1">
<source>This expression was expected to have type\n '{1}' \nbut here has type\n '{0}' {2}</source>
<target state="translated">Il tipo previsto di questa espressione \n '{1}' \nma quello effettivo \n '{0}' {2}</target>
<note />
</trans-unit>
<trans-unit id="ErrorFromAddingTypeEquation2">
<source>Type mismatch. Expecting a\n '{0}' \nbut given a\n '{1}' {2}\n</source>
<target state="translated">Tipo non corrispondente. Il tipo previsto \n '{0}' \nma quello specificato \n '{1}' {2}\n</target>
<note />
</trans-unit>
<trans-unit id="ErrorFromApplyingDefault1">
<source>Type constraint mismatch when applying the default type '{0}' for a type inference variable. </source>
<target state="translated">Vincolo di tipo non corrispondente all'applicazione del tipo predefinito '{0}' per una variabile di inferenza del tipo. </target>
<note />
</trans-unit>
<trans-unit id="ErrorFromApplyingDefault2">
<source> Consider adding further type constraints</source>
<target state="translated"> Provare ad aggiungere ulteriori vincoli di tipo</target>
<note />
</trans-unit>
<trans-unit id="ErrorsFromAddingSubsumptionConstraint">
<source>Type constraint mismatch. The type \n '{0}' \nis not compatible with type\n '{1}' {2}\n</source>
<target state="translated">Vincolo di tipo non corrispondente. Il tipo \n '{0}' \nnon compatibile con il tipo\n '{1}' {2}\n</target>
<note />
</trans-unit>
<trans-unit id="UpperCaseIdentifierInPattern">
<source>Uppercase variable identifiers should not generally be used in patterns, and may indicate a missing open declaration or a misspelt pattern name.</source>
<target state="translated">In genere consigliabile non usare identificatori di variabili scritti in maiuscolo nei criteri perch potrebbero indicare una dichiarazione OPEN mancante o un nome di criterio con ortografia errata.</target>
<note />
</trans-unit>
<trans-unit id="NotUpperCaseConstructor">
<source>Discriminated union cases and exception labels must be uppercase identifiers</source>
<target state="translated">I case di unione discriminati e le etichette di eccezioni devono essere identificatori in lettere maiuscole</target>
<note />
</trans-unit>
<trans-unit id="FunctionExpected">
<source>This function takes too many arguments, or is used in a context where a function is not expected</source>
<target state="translated">Questa funzione utilizza troppi argomenti oppure utilizzata in un contesto in cui non prevista una funzione</target>
<note />
</trans-unit>
<trans-unit id="BakedInMemberConstraintName">
<source>Member constraints with the name '{0}' are given special status by the F# compiler as certain .NET types are implicitly augmented with this member. This may result in runtime failures if you attempt to invoke the member constraint from your own code.</source>
<target state="translated">Ai vincoli di membro con nome '{0}' assegnato uno stato speciale dal compilatore F# perch determinati tipi .NET sono aumentati in modo implicito con il membro. Ci potrebbe causare errori di runtime se si prova a richiamare il vincolo del membro dal codice.</target>
<note />
</trans-unit>
<trans-unit id="BadEventTransformation">
<source>A definition to be compiled as a .NET event does not have the expected form. Only property members can be compiled as .NET events.</source>
<target state="translated">Una definizione da compilare come evento .NET non nel formato previsto. possibile compilare come eventi .NET solo membri di propriet.</target>
<note />
</trans-unit>
<trans-unit id="ParameterlessStructCtor">
<source>Implicit object constructors for structs must take at least one argument</source>
<target state="translated">I costruttori di oggetto impliciti per gli struct devono utilizzare almeno un argomento</target>
<note />
</trans-unit>
<trans-unit id="InterfaceNotRevealed">
<source>The type implements the interface '{0}' but this is not revealed by the signature. You should list the interface in the signature, as the interface will be discoverable via dynamic type casts and/or reflection.</source>
<target state="translated">Il tipo implementa l'interfaccia '{0}', ma questo non indicato dalla firma. necessario elencare l'interfaccia nella firma, perch sar individuabile tramite cast e/o reflection di tipi dinamici.</target>
<note />
</trans-unit>
<trans-unit id="TyconBadArgs">
<source>The type '{0}' expects {1} type argument(s) but is given {2}</source>
<target state="translated">Il tipo '{0}' prevede {1} argomento/i tipo, tuttavia il numero di argomenti tipo specificati pari a {2}</target>
<note />
</trans-unit>
<trans-unit id="IndeterminateType">
<source>Lookup on object of indeterminate type based on information prior to this program point. A type annotation may be needed prior to this program point to constrain the type of the object. This may allow the lookup to be resolved.</source>
<target state="translated">Ricerca in un oggetto di tipo non determinato basato su informazioni che si trovano prima di questo punto del programma. Potrebbe essere necessaria un'annotazione di tipo prima di questo punto del programma per vincolare il tipo dell'oggetto. Questa modifica potrebbe consentire la risoluzione della ricerca.</target>
<note />
</trans-unit>
<trans-unit id="NameClash1">
<source>Duplicate definition of {0} '{1}'</source>
<target state="translated">Definizione duplicata di {0} '{1}'</target>
<note />
</trans-unit>
<trans-unit id="NameClash2">
<source>The {0} '{1}' can not be defined because the name '{2}' clashes with the {3} '{4}' in this type or module</source>
<target state="translated">Non possibile definire {0} '{1}' perch il nome '{2}' in conflitto con {3} '{4}' in questo tipo o modulo</target>
<note />
</trans-unit>
<trans-unit id="Duplicate1">
<source>Two members called '{0}' have the same signature</source>
<target state="translated">Due membri denominati '{0}' hanno la stessa firma</target>
<note />
</trans-unit>
<trans-unit id="Duplicate2">
<source>Duplicate definition of {0} '{1}'</source>
<target state="translated">Definizione duplicata di {0} '{1}'</target>
<note />
</trans-unit>
<trans-unit id="UndefinedName2">
<source> A construct with this name was found in FSharp.PowerPack.dll, which contains some modules and types that were implicitly referenced in some previous versions of F#. You may need to add an explicit reference to this DLL in order to compile this code.</source>
<target state="translated"> Trovato costrutto con questo nome in FSharp.PowerPack.dll, contenente alcuni moduli e tipi a cui viene fatto riferimento implicito in alcune versioni precedenti di F#. Potrebbe essere necessario aggiungere un riferimento esplicito a questa DLL per compilare il codice.</target>
<note />
</trans-unit>
<trans-unit id="FieldNotMutable">
<source>This field is not mutable</source>
<target state="translated">Questo campo non modificabile</target>
<note />
</trans-unit>
<trans-unit id="FieldsFromDifferentTypes">
<source>The fields '{0}' and '{1}' are from different types</source>
<target state="translated">I campi '{0}' e '{1}' sono di tipi diversi</target>
<note />
</trans-unit>
<trans-unit id="VarBoundTwice">
<source>'{0}' is bound twice in this pattern</source>
<target state="translated">'{0}' associato due volte in questo criterio</target>
<note />
</trans-unit>
<trans-unit id="Recursion">
<source>A use of the function '{0}' does not match a type inferred elsewhere. The inferred type of the function is\n {1}. \nThe type of the function required at this point of use is\n {2} {3}\nThis error may be due to limitations associated with generic recursion within a 'let rec' collection or within a group of classes. Consider giving a full type signature for the targets of recursive calls including type annotations for both argument and return types.</source>
<target state="translated">Un utilizzo della funzione '{0}' non corrisponde a un tipo dedotto in un'altra posizione. Il tipo dedotto della funzione \n {1}. \nIl tipo della funzione richiesto in questo punto dell'utilizzo \n {2} {3}\nQuesto errore potrebbe essere dovuto a limitazioni associate alla ricorsione generica in una raccolta 'let rec' o in un gruppo di classi. Provare a specificare una firma di tipo completa per le destinazioni delle chiamate ricorsive con annotazioni di tipo per i tipi restituiti e di argomento.</target>
<note />
</trans-unit>
<trans-unit id="InvalidRuntimeCoercion">
<source>Invalid runtime coercion or type test from type {0} to {1}\n{2}</source>
<target state="translated">Test di tipo o coercizione di runtime non valido del tipo {0} in {1}\n{2}</target>
<note />
</trans-unit>
<trans-unit id="IndeterminateRuntimeCoercion">
<source>This runtime coercion or type test from type\n {0} \n to \n {1} \ninvolves an indeterminate type based on information prior to this program point. Runtime type tests are not allowed on some types. Further type annotations are needed.</source>
<target state="translated">Questo test di tipo o coercizione di runtime del tipo \n {0} \n in \n {1} \nprevede un tipo non determinato basato su informazioni che si trovano prima di questo punto del programma. I test dei tipi di runtime non sono consentiti per alcuni tipi. Sono necessarie ulteriori annotazioni di tipo.</target>
<note />
</trans-unit>
<trans-unit id="IndeterminateStaticCoercion">
<source>The static coercion from type\n {0} \nto \n {1} \n involves an indeterminate type based on information prior to this program point. Static coercions are not allowed on some types. Further type annotations are needed.</source>
<target state="translated">Questa coercizione statica del tipo\n {0} \nin \n {1} \n prevede un tipo non determinato basato su informazioni che si trovano prima di questo punto del programma. Le coercizioni statiche non sono consentite per alcuni tipi. Sono necessarie ulteriori annotazioni di tipo.</target>
<note />
</trans-unit>
<trans-unit id="StaticCoercionShouldUseBox">
<source>A coercion from the value type \n {0} \nto the type \n {1} \nwill involve boxing. Consider using 'box' instead</source>
<target state="translated">Una coercizione dal tipo di valore \n {0} \nal tipo \n {1} \nimplica una conversione boxing. Provare a utilizzare invece 'box'</target>
<note />
</trans-unit>
<trans-unit id="TypeIsImplicitlyAbstract">
<source>This type is 'abstract' since some abstract members have not been given an implementation. If this is intentional then add the '[<AbstractClass>]' attribute to your type.</source>
<target state="translated">Questo tipo 'abstract' perch non stata specificata un'implementazione per alcuni membri astratti. Se questa scelta intenzionale, aggiungere l'attributo '[<AbstractClass>]' al tipo.</target>
<note />
</trans-unit>
<trans-unit id="NonRigidTypar1">
<source>This construct causes code to be less generic than indicated by its type annotations. The type variable implied by the use of a '#', '_' or other type annotation at or near '{0}' has been constrained to be type '{1}'.</source>
<target state="translated">Questo costrutto rende il codice meno generico di quanto indicato dalle relative annotazioni di tipo. La variabile di tipo prevista in base all'uso di un'annotazione di tipo '#', '_' o altra in corrispondenza o in prossimit di '{0}' stata vincolata in modo da essere di tipo '{1}'.</target>
<note />
</trans-unit>
<trans-unit id="NonRigidTypar2">
<source>This construct causes code to be less generic than indicated by the type annotations. The unit-of-measure variable '{0} has been constrained to be measure '{1}'.</source>
<target state="translated">Questo costrutto rende il codice meno generico di quanto indicato dalle annotazioni di tipo. La variabile di unit di misura '{0} stata vincolata in modo da essere la misura '{1}'.</target>
<note />
</trans-unit>
<trans-unit id="NonRigidTypar3">
<source>This construct causes code to be less generic than indicated by the type annotations. The type variable '{0} has been constrained to be type '{1}'.</source>
<target state="translated">Questo costrutto rende il codice meno generico di quanto indicato dalle annotazioni di tipo. La variabile di tipo '{0} stata vincolata in modo da essere il tipo '{1}'.</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.IDENT">
<source>identifier</source>
<target state="translated">identificatore</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INT">
<source>integer literal</source>
<target state="translated">valore letterale Integer</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.FLOAT">
<source>floating point literal</source>
<target state="translated">valore letterale a virgola mobile</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.DECIMAL">
<source>decimal literal</source>
<target state="translated">valore letterale decimale</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.CHAR">
<source>character literal</source>
<target state="translated">valore letterale carattere</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.BASE">
<source>keyword 'base'</source>
<target state="translated">parola chiave 'base'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LPAREN.STAR.RPAREN">
<source>symbol '(*)'</source>
<target state="translated">simbolo '(*)'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.DOLLAR">
<source>symbol '$'</source>
<target state="translated">simbolo '$'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INFIX.STAR.STAR.OP">
<source>infix operator</source>
<target state="translated">operatore infisso</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INFIX.COMPARE.OP">
<source>infix operator</source>
<target state="translated">operatore infisso</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.COLON.GREATER">
<source>symbol ':>'</source>
<target state="translated">simbolo ':>'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.COLON.COLON">
<source>symbol '::'</source>
<target state="translated">simbolo '::'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.PERCENT.OP">
<source>symbol '{0}</source>
<target state="translated">simbolo '{0}</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INFIX.AT.HAT.OP">
<source>infix operator</source>
<target state="translated">operatore infisso</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INFIX.BAR.OP">
<source>infix operator</source>
<target state="translated">operatore infisso</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.PLUS.MINUS.OP">
<source>infix operator</source>
<target state="translated">operatore infisso</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.PREFIX.OP">
<source>prefix operator</source>
<target state="translated">operatore prefisso</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.COLON.QMARK.GREATER">
<source>symbol ':?>'</source>
<target state="translated">simbolo ':?>'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INFIX.STAR.DIV.MOD.OP">
<source>infix operator</source>
<target state="translated">operatore infisso</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INFIX.AMP.OP">
<source>infix operator</source>
<target state="translated">operatore infisso</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.AMP">
<source>symbol '&'</source>
<target state="translated">simbolo '&'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.AMP.AMP">
<source>symbol '&&'</source>
<target state="translated">simbolo '&&'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.BAR.BAR">
<source>symbol '||'</source>
<target state="translated">simbolo '||'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LESS">
<source>symbol '<'</source>
<target state="translated">simbolo '<'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.GREATER">
<source>symbol '>'</source>
<target state="translated">simbolo '>'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.QMARK">
<source>symbol '?'</source>
<target state="translated">simbolo '?'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.QMARK.QMARK">
<source>symbol '??'</source>
<target state="translated">simbolo '??'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.COLON.QMARK">
<source>symbol ':?'</source>
<target state="translated">simbolo ':?'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INT32.DOT.DOT">
<source>integer..</source>
<target state="translated">Integer..</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.DOT.DOT">
<source>symbol '..'</source>
<target state="translated">simbolo '..'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.QUOTE">
<source>quote symbol</source>
<target state="translated">simbolo di quotation</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.STAR">
<source>symbol '*'</source>
<target state="translated">simbolo '*'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.HIGH.PRECEDENCE.TYAPP">
<source>type application </source>
<target state="translated">applicazione tipo </target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.COLON">
<source>symbol ':'</source>
<target state="translated">simbolo ':'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.COLON.EQUALS">
<source>symbol ':='</source>
<target state="translated">simbolo ':='</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LARROW">
<source>symbol '<-'</source>
<target state="translated">simbolo '<-'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.EQUALS">
<source>symbol '='</source>
<target state="translated">simbolo '='</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.GREATER.BAR.RBRACK">
<source>symbol '>|]'</source>
<target state="translated">simbolo '>|]'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.MINUS">
<source>symbol '-'</source>
<target state="translated">simbolo '-'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.ADJACENT.PREFIX.OP">
<source>prefix operator</source>
<target state="translated">operatore prefisso</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.FUNKY.OPERATOR.NAME">
<source>operator name</source>
<target state="translated">nome operatore</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.COMMA">
<source>symbol ','</source>
<target state="translated">simbolo ','</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.DOT">
<source>symbol '.'</source>
<target state="translated">simbolo '.'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.BAR">
<source>symbol '|'</source>
<target state="translated">simbolo '|'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.HASH">
<source>symbol #</source>
<target state="translated">simbolo #</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.UNDERSCORE">
<source>symbol '_'</source>
<target state="translated">simbolo '_'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.SEMICOLON">
<source>symbol ';'</source>
<target state="translated">simbolo ';'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.SEMICOLON.SEMICOLON">
<source>symbol ';;'</source>
<target state="translated">simbolo ';;'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LPAREN">
<source>symbol '('</source>
<target state="translated">simbolo '('</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.RPAREN">
<source>symbol ')'</source>
<target state="translated">simbolo ')'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.SPLICE.SYMBOL">
<source>symbol 'splice'</source>
<target state="translated">simbolo 'splice'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LQUOTE">
<source>start of quotation</source>
<target state="translated">inizio quotation</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LBRACK">
<source>symbol '['</source>
<target state="translated">simbolo '['</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LBRACK.BAR">
<source>symbol '[|'</source>
<target state="translated">simbolo '[|'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LBRACK.LESS">
<source>symbol '[<'</source>
<target state="translated">simbolo '[<'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LBRACE">
<source>symbol '{'</source>
<target state="translated">simbolo '{'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LBRACE.LESS">
<source>symbol '{<'</source>
<target state="translated">simbolo '{<'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.BAR.RBRACK">
<source>symbol '|]'</source>
<target state="translated">simbolo '|]'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.GREATER.RBRACE">
<source>symbol '>}'</source>
<target state="translated">simbolo '>}'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.GREATER.RBRACK">
<source>symbol '>]'</source>
<target state="translated">simbolo '>]'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.RQUOTE">
<source>end of quotation</source>
<target state="translated">fine quotation</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.RBRACK">
<source>symbol ']'</source>
<target state="translated">simbolo ']'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.RBRACE">
<source>symbol '}'</source>
<target state="translated">simbolo '}'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.PUBLIC">
<source>keyword 'public'</source>
<target state="translated">parola chiave 'public'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.PRIVATE">
<source>keyword 'private'</source>
<target state="translated">parola chiave 'private'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INTERNAL">
<source>keyword 'internal'</source>
<target state="translated">parola chiave 'internal'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.FIXED">
<source>keyword 'fixed'</source>
<target state="translated">parola chiave 'fixed'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.CONSTRAINT">
<source>keyword 'constraint'</source>
<target state="translated">parola chiave 'constraint'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INSTANCE">
<source>keyword 'instance'</source>
<target state="translated">parola chiave 'instance'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.DELEGATE">
<source>keyword 'delegate'</source>
<target state="translated">parola chiave 'delegate'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INHERIT">
<source>keyword 'inherit'</source>
<target state="translated">parola chiave 'inherit'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.CONSTRUCTOR">
<source>keyword 'constructor'</source>
<target state="translated">parola chiave 'constructor'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.DEFAULT">
<source>keyword 'default'</source>
<target state="translated">parola chiave 'default'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OVERRIDE">
<source>keyword 'override'</source>
<target state="translated">parola chiave 'override'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.ABSTRACT">
<source>keyword 'abstract'</source>
<target state="translated">parola chiave 'abstract'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.CLASS">
<source>keyword 'class'</source>
<target state="translated">parola chiave 'class'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.MEMBER">
<source>keyword 'member'</source>
<target state="translated">parola chiave 'member'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.STATIC">
<source>keyword 'static'</source>
<target state="translated">parola chiave 'static'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.NAMESPACE">
<source>keyword 'namespace'</source>
<target state="translated">parola chiave 'namespace'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OBLOCKBEGIN">
<source>start of structured construct</source>
<target state="translated">inizio costrutto strutturato</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OBLOCKEND">
<source>incomplete structured construct at or before this point</source>
<target state="translated">costrutto strutturato incompleto in questo punto o prima di esso</target>
<note />
</trans-unit>
<trans-unit id="BlockEndSentence">
<source>Incomplete structured construct at or before this point</source>
<target state="translated">Costrutto strutturato incompleto in questo punto o prima di esso</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OTHEN">
<source>keyword 'then'</source>
<target state="translated">parola chiave 'then'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OELSE">
<source>keyword 'else'</source>
<target state="translated">parola chiave 'else'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OLET">
<source>keyword 'let' or 'use'</source>
<target state="translated">parola chiave 'let' o 'use'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.BINDER">
<source>binder keyword</source>
<target state="translated">parola chiave binder</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.ODO">
<source>keyword 'do'</source>
<target state="translated">parola chiave 'do'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.CONST">
<source>keyword 'const'</source>
<target state="translated">parola chiave 'const'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OWITH">
<source>keyword 'with'</source>
<target state="translated">parola chiave 'with'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OFUNCTION">
<source>keyword 'function'</source>
<target state="translated">parola chiave 'function'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OFUN">
<source>keyword 'fun'</source>
<target state="translated">parola chiave 'fun'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.ORESET">
<source>end of input</source>
<target state="translated">fine input</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.ODUMMY">
<source>internal dummy token</source>
<target state="translated">token fittizio interno</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.ODO.BANG">
<source>keyword 'do!'</source>
<target state="translated">parola chiave 'do!'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.YIELD">
<source>yield</source>
<target state="translated">yield</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.YIELD.BANG">
<source>yield!</source>
<target state="translated">yield!</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OINTERFACE.MEMBER">
<source>keyword 'interface'</source>
<target state="translated">parola chiave 'interface'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.ELIF">
<source>keyword 'elif'</source>
<target state="translated">parola chiave 'elif'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.RARROW">
<source>symbol '->'</source>
<target state="translated">simbolo '->'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.SIG">
<source>keyword 'sig'</source>
<target state="translated">parola chiave 'sig'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.STRUCT">
<source>keyword 'struct'</source>
<target state="translated">parola chiave 'struct'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.UPCAST">
<source>keyword 'upcast'</source>
<target state="translated">parola chiave 'upcast'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.DOWNCAST">
<source>keyword 'downcast'</source>
<target state="translated">parola chiave 'downcast'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.NULL">
<source>keyword 'null'</source>
<target state="translated">parola chiave 'null'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.RESERVED">
<source>reserved keyword</source>
<target state="translated">parola chiave riservata</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.MODULE">
<source>keyword 'module'</source>
<target state="translated">parola chiave 'module'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.AND">
<source>keyword 'and'</source>
<target state="translated">parola chiave 'and'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.AS">
<source>keyword 'as'</source>
<target state="translated">parola chiave 'as'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.ASSERT">
<source>keyword 'assert'</source>
<target state="translated">parola chiave 'assert'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.ASR">
<source>keyword 'asr'</source>
<target state="translated">parola chiave 'asr'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.DOWNTO">
<source>keyword 'downto'</source>
<target state="translated">parola chiave 'downto'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.EXCEPTION">
<source>keyword 'exception'</source>
<target state="translated">parola chiave 'exception'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.FALSE">
<source>keyword 'false'</source>
<target state="translated">parola chiave 'false'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.FOR">
<source>keyword 'for'</source>
<target state="translated">parola chiave 'for'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.FUN">
<source>keyword 'fun'</source>
<target state="translated">parola chiave 'fun'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.FUNCTION">
<source>keyword 'function'</source>
<target state="translated">parola chiave 'function'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.FINALLY">
<source>keyword 'finally'</source>
<target state="translated">parola chiave 'finally'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LAZY">
<source>keyword 'lazy'</source>
<target state="translated">parola chiave 'lazy'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.MATCH">
<source>keyword 'match'</source>
<target state="translated">parola chiave 'match'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.MATCH.BANG">
<source>keyword 'match!'</source>
<target state="translated">parola chiave 'match!'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.MUTABLE">
<source>keyword 'mutable'</source>
<target state="translated">parola chiave 'mutable'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.NEW">
<source>keyword 'new'</source>
<target state="translated">parola chiave 'new'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OF">
<source>keyword 'of'</source>
<target state="translated">parola chiave 'of'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OPEN">
<source>keyword 'open'</source>
<target state="translated">parola chiave 'open'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.OR">
<source>keyword 'or'</source>
<target state="translated">parola chiave 'or'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.VOID">
<source>keyword 'void'</source>
<target state="translated">parola chiave 'void'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.EXTERN">
<source>keyword 'extern'</source>
<target state="translated">parola chiave 'extern'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INTERFACE">
<source>keyword 'interface'</source>
<target state="translated">parola chiave 'interface'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.REC">
<source>keyword 'rec'</source>
<target state="translated">parola chiave 'rec'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.TO">
<source>keyword 'to'</source>
<target state="translated">parola chiave 'to'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.TRUE">
<source>keyword 'true'</source>
<target state="translated">parola chiave 'true'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.TRY">
<source>keyword 'try'</source>
<target state="translated">parola chiave 'try'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.TYPE">
<source>keyword 'type'</source>
<target state="translated">parola chiave 'type'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.VAL">
<source>keyword 'val'</source>
<target state="translated">parola chiave 'val'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INLINE">
<source>keyword 'inline'</source>
<target state="translated">parola chiave 'inline'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.WHEN">
<source>keyword 'when'</source>
<target state="translated">parola chiave 'when'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.WHILE">
<source>keyword 'while'</source>
<target state="translated">parola chiave 'while'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.WITH">
<source>keyword 'with'</source>
<target state="translated">parola chiave 'with'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.IF">
<source>keyword 'if'</source>
<target state="translated">parola chiave 'if'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.DO">
<source>keyword 'do'</source>
<target state="translated">parola chiave 'do'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.GLOBAL">
<source>keyword 'global'</source>
<target state="translated">parola chiave 'global'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.DONE">
<source>keyword 'done'</source>
<target state="translated">parola chiave 'done'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.IN">
<source>keyword 'in'</source>
<target state="translated">parola chiave 'in'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.HIGH.PRECEDENCE.PAREN.APP">
<source>symbol '('</source>
<target state="translated">simbolo '('</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.HIGH.PRECEDENCE.BRACK.APP">
<source>symbol'['</source>
<target state="translated">simbolo '['</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.BEGIN">
<source>keyword 'begin'</source>
<target state="translated">parola chiave 'begin'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.END">
<source>keyword 'end'</source>
<target state="translated">parola chiave 'end'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.HASH.ENDIF">
<source>directive</source>
<target state="translated">direttiva</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.INACTIVECODE">
<source>inactive code</source>
<target state="translated">codice inattivo</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LEX.FAILURE">
<source>lex failure</source>
<target state="translated">errore lex</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.WHITESPACE">
<source>whitespace</source>
<target state="translated">spazio vuoto</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.COMMENT">
<source>comment</source>
<target state="translated">commento</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LINE.COMMENT">
<source>line comment</source>
<target state="translated">commento riga</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.STRING.TEXT">
<source>string text</source>
<target state="translated">testo stringa</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.KEYWORD_STRING">
<source>compiler generated literal</source>
<target state="translated">valore letterale generato dal compilatore</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.BYTEARRAY">
<source>byte array literal</source>
<target state="translated">valore letterale della matrice di byte</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.STRING">
<source>string literal</source>
<target state="translated">valore letterale stringa</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.EOF">
<source>end of input</source>
<target state="translated">fine input</target>
<note />
</trans-unit>
<trans-unit id="UnexpectedEndOfInput">
<source>Unexpected end of input</source>
<target state="translated">Fine di input non prevista</target>
<note />
</trans-unit>
<trans-unit id="Unexpected">
<source>Unexpected {0}</source>
<target state="translated">{0} imprevisto/a</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.interaction">
<source> in interaction</source>
<target state="translated"> durante l'interazione</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.hashDirective">
<source> in directive</source>
<target state="translated"> in una direttiva</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.fieldDecl">
<source> in field declaration</source>
<target state="translated"> in una dichiarazione di campo</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.unionCaseRepr">
<source> in discriminated union case declaration</source>
<target state="translated"> in una dichiarazione di case di unione discriminato</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.localBinding">
<source> in binding</source>
<target state="translated"> nel binding</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.hardwhiteLetBindings">
<source> in binding</source>
<target state="translated"> nel binding</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.classDefnMember">
<source> in member definition</source>
<target state="translated"> in una definizione di membro</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.defnBindings">
<source> in definitions</source>
<target state="translated"> in definizioni</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.classMemberSpfn">
<source> in member signature</source>
<target state="translated"> in una firma di membro</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.valSpfn">
<source> in value signature</source>
<target state="translated"> in una firma di valore</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.tyconSpfn">
<source> in type signature</source>
<target state="translated"> in una firma di tipo</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.anonLambdaExpr">
<source> in lambda expression</source>
<target state="translated"> in un'espressione lambda</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.attrUnionCaseDecl">
<source> in union case</source>
<target state="translated"> in un case di unione</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.cPrototype">
<source> in extern declaration</source>
<target state="translated"> in una dichiarazione extern</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.objectImplementationMembers">
<source> in object expression</source>
<target state="translated"> in un'espressione dell'oggetto</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.ifExprCases">
<source> in if/then/else expression</source>
<target state="translated"> in un'espressione if/then/else</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.openDecl">
<source> in open declaration</source>
<target state="translated"> in una dichiarazione aperta</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.fileModuleSpec">
<source> in module or namespace signature</source>
<target state="translated"> in una firma di modulo o spazio dei nomi</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.patternClauses">
<source> in pattern matching</source>
<target state="translated"> in criteri di ricerca</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.beginEndExpr">
<source> in begin/end expression</source>
<target state="translated"> in un'espressione iniziale/finale</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.recdExpr">
<source> in record expression</source>
<target state="translated"> in un'espressione di record</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.tyconDefn">
<source> in type definition</source>
<target state="translated"> in una definizione di tipo</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.exconCore">
<source> in exception definition</source>
<target state="translated"> in una definizione di eccezione</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.typeNameInfo">
<source> in type name</source>
<target state="translated"> in un nome di tipo</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.attributeList">
<source> in attribute list</source>
<target state="translated"> in un elenco di attributi</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.quoteExpr">
<source> in quotation literal</source>
<target state="translated"> in valori letterali di quotation</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.typeConstraint">
<source> in type constraint</source>
<target state="translated"> in un vincolo di tipo</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.Category.ImplementationFile">
<source> in implementation file</source>
<target state="translated"> in un file di implementazione</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.Category.Definition">
<source> in definition</source>
<target state="translated"> in una definizione</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.Category.SignatureFile">
<source> in signature file</source>
<target state="translated"> in un file di firma</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.Category.Pattern">
<source> in pattern</source>
<target state="translated"> in un criterio</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.Category.Expr">
<source> in expression</source>
<target state="translated"> in un'espressione</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.Category.Type">
<source> in type</source>
<target state="translated"> in un tipo</target>
<note />
</trans-unit>
<trans-unit id="NONTERM.typeArgsActual">
<source> in type arguments</source>
<target state="translated"> in argomenti tipo</target>
<note />
</trans-unit>
<trans-unit id="FixKeyword">
<source>keyword </source>
<target state="translated">parola chiave </target>
<note />
</trans-unit>
<trans-unit id="FixSymbol">
<source>symbol </source>
<target state="translated">simbolo </target>
<note />
</trans-unit>
<trans-unit id="FixReplace">
<source> (due to indentation-aware syntax)</source>
<target state="translated"> (a causa di sintassi dipendente dal rientro)</target>
<note />
</trans-unit>
<trans-unit id="TokenName1">
<source>. Expected {0} or other token.</source>
<target state="translated">. Previsto {0} o altro token.</target>
<note />
</trans-unit>
<trans-unit id="TokenName1TokenName2">
<source>. Expected {0}, {1} or other token.</source>
<target state="translated">. Previsto {0}, {1} o altro token.</target>
<note />
</trans-unit>
<trans-unit id="TokenName1TokenName2TokenName3">
<source>. Expected {0}, {1}, {2} or other token.</source>
<target state="translated">. Previsto {0}, {1}, {2} o altro token.</target>
<note />
</trans-unit>
<trans-unit id="RuntimeCoercionSourceSealed1">
<source>The type '{0}' cannot be used as the source of a type test or runtime coercion</source>
<target state="translated">Non possibile usare il tipo '{0}' come origine di un test del tipo o di una coercizione di runtime</target>
<note />
</trans-unit>
<trans-unit id="RuntimeCoercionSourceSealed2">
<source>The type '{0}' does not have any proper subtypes and cannot be used as the source of a type test or runtime coercion.</source>
<target state="translated">Il tipo '{0}' non dispone di alcun sottotipo appropriato e non pu essere utilizzato come origine di un test del tipo o di coercizione di runtime.</target>
<note />
</trans-unit>
<trans-unit id="CoercionTargetSealed">
<source>The type '{0}' does not have any proper subtypes and need not be used as the target of a static coercion</source>
<target state="translated">Il tipo '{0}' non dispone di alcun sottotipo appropriato e non deve essere utilizzato come destinazione di una coercizione statica</target>
<note />
</trans-unit>
<trans-unit id="UpcastUnnecessary">
<source>This upcast is unnecessary - the types are identical</source>
<target state="translated">Upcast non necessario: i tipi sono identici</target>
<note />
</trans-unit>
<trans-unit id="TypeTestUnnecessary">
<source>This type test or downcast will always hold</source>
<target state="translated">Questo downcast o test di tipo sar sempre sospeso</target>
<note />
</trans-unit>
<trans-unit id="OverrideDoesntOverride1">
<source>The member '{0}' does not have the correct type to override any given virtual method</source>
<target state="translated">Il membro '{0}' non dispone del tipo corretto per eseguire l'override di eventuali metodi virtuali specificati</target>
<note />
</trans-unit>
<trans-unit id="OverrideDoesntOverride2">
<source>The member '{0}' does not have the correct type to override the corresponding abstract method.</source>
<target state="translated">Il membro '{0}' non dispone del tipo corretto per eseguire l'override del metodo astratto corrispondente.</target>
<note />
</trans-unit>
<trans-unit id="OverrideDoesntOverride3">
<source> The required signature is '{0}'.</source>
<target state="translated"> La firma necessaria '{0}'.</target>
<note />
</trans-unit>
<trans-unit id="OverrideDoesntOverride4">
<source>The member '{0}' is specialized with 'unit' but 'unit' can't be used as return type of an abstract method parameterized on return type.</source>
<target state="translated">Il membro '{0}' specializzato con 'unit' ma non possibile usare 'unit' come tipo restituito di un metodo astratto con parametri basati sul tipo restituito.</target>
<note />
</trans-unit>
<trans-unit id="UnionCaseWrongArguments">
<source>This constructor is applied to {0} argument(s) but expects {1}</source>
<target state="translated">Questo costruttore applicato a {0} argomento/i, tuttavia il numero di argomenti previsto pari a {1}</target>
<note />
</trans-unit>
<trans-unit id="UnionPatternsBindDifferentNames">
<source>The two sides of this 'or' pattern bind different sets of variables</source>
<target state="translated">I due lati di questo criterio 'or' consentono di eseguire il binding di set di variabili diversi</target>
<note />
</trans-unit>
<trans-unit id="ValueNotContained">
<source>Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \n{3}.</source>
<target state="translated">Il modulo '{0}' contiene\n {1} \ntuttavia la relativa firma specifica\n {2} \n{3}.</target>
<note />
</trans-unit>
<trans-unit id="RequiredButNotSpecified">
<source>Module '{0}' requires a {1} '{2}'</source>
<target state="translated">Il modulo '{0}' richiede {1} '{2}'</target>
<note />
</trans-unit>
<trans-unit id="UseOfAddressOfOperator">
<source>The use of native pointers may result in unverifiable .NET IL code</source>
<target state="translated">L'utilizzo di puntatori nativi potrebbe rendere il codice IL .NET non verificabile</target>
<note />
</trans-unit>
<trans-unit id="DefensiveCopyWarning">
<source>{0}</source>
<target state="translated">{0}</target>
<note />
</trans-unit>
<trans-unit id="DeprecatedThreadStaticBindingWarning">
<source>Thread static and context static 'let' bindings are deprecated. Instead use a declaration of the form 'static val mutable <ident> : <type>' in a class. Add the 'DefaultValue' attribute to this declaration to indicate that the value is initialized to the default value on each new thread.</source>
<target state="translated">I binding 'let' statici a livello di thread e a livello di contesto sono deprecati. Usare invece una dichiarazione nel formato 'static val mutable <ident> : <type>' in una classe. Aggiungere l'attributo 'DefaultValue' alla dichiarazione per indicare che il valore deve essere inizializzato con il valore predefinito in ogni nuovo thread.</target>
<note />
</trans-unit>
<trans-unit id="FunctionValueUnexpected">
<source>This expression is a function value, i.e. is missing arguments. Its type is {0}.</source>
<target state="translated">Questa espressione un valore di funzione, ovvero sono assenti argomenti. Il relativo tipo {0}.</target>
<note />
</trans-unit>
<trans-unit id="UnitTypeExpected">
<source>The result of this expression has type '{0}' and is implicitly ignored. Consider using 'ignore' to discard this value explicitly, e.g. 'expr |> ignore', or 'let' to bind the result to a name, e.g. 'let result = expr'.</source>
<target state="translated">Il risultato di questa espressione di tipo '{0}' e viene ignorato in modo implicito. Provare a usare 'ignore' per rimuovere esplicitamente questo valore, ad esempio 'expr |> ignore', oppure 'let' per eseguire il binding del risultato a un nome, ad esempio 'let result = expr'.</target>
<note />
</trans-unit>
<trans-unit id="UnitTypeExpectedWithEquality">
<source>The result of this equality expression has type '{0}' and is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'.</source>
<target state="translated">Il risultato di questa espressione di uguaglianza di tipo '{0}' e viene rimosso in modo implicito. Provare a usare 'let' per eseguire il binding del risultato a un nome, ad esempio 'let result = espressione'.</target>
<note />
</trans-unit>
<trans-unit id="UnitTypeExpectedWithPossiblePropertySetter">
<source>The result of this equality expression has type '{0}' and is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to set a value to a property, then use the '<-' operator e.g. '{1}.{2} <- expression'.</source>
<target state="translated">Il risultato di questa espressione di uguaglianza di tipo '{0}' e viene rimosso in modo implicito. Provare a usare 'let' per eseguire il binding del risultato a un nome, ad esempio 'let result = expression'. Se si intende impostare un valore su una propriet, usare l'operatore '<-', ad esempio '{1}.{2} <- expression'.</target>
<note />
</trans-unit>
<trans-unit id="UnitTypeExpectedWithPossibleAssignment">
<source>The result of this equality expression has type '{0}' and is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to mutate a value, then mark the value 'mutable' and use the '<-' operator e.g. '{1} <- expression'.</source>
<target state="translated">Il risultato di questa espressione di uguaglianza di tipo '{0}' e viene rimosso in modo implicito. Provare a usare 'let' per eseguire il binding del risultato a un nome, ad esempio 'let result = expression'. Se si intende modificare un valore, contrassegnare il valore 'mutable' e usare l'operatore '<-', ad esempio '{1} <- expression'.</target>
<note />
</trans-unit>
<trans-unit id="UnitTypeExpectedWithPossibleAssignmentToMutable">
<source>The result of this equality expression has type '{0}' and is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to mutate a value, then use the '<-' operator e.g. '{1} <- expression'.</source>
<target state="translated">Il risultato di questa espressione di uguaglianza di tipo '{0}' e viene rimosso in modo implicito. Provare a usare 'let' per eseguire il binding del risultato a un nome, ad esempio 'let result = expression'. Se si intende modificare un valore, usare l'operatore '<-', ad esempio '{1} <- expression'.</target>
<note />
</trans-unit>
<trans-unit id="RecursiveUseCheckedAtRuntime">
<source>This recursive use will be checked for initialization-soundness at runtime. This warning is usually harmless, and may be suppressed by using '#nowarn "21"' or '--nowarn:21'.</source>
<target state="translated">La correttezza dell'inizializzazione al runtime di questo utilizzo ricorsivo verr verificata. Questo avviso non indica in genere un problema concreto e pu essere disabilitato mediante '#nowarn "21"' o '--nowarn:21'.</target>
<note />
</trans-unit>
<trans-unit id="LetRecUnsound1">
<source>The value '{0}' will be evaluated as part of its own definition</source>
<target state="translated">Il valore '{0}' verr valutato come parte della propria definizione</target>
<note />
</trans-unit>
<trans-unit id="LetRecUnsound2">
<source>This value will be eventually evaluated as part of its own definition. You may need to make the value lazy or a function. Value '{0}'{1}.</source>
<target state="translated">Questo valore verr in seguito valutato come parte della propria definizione. Potrebbe essere necessario rendere il valore lazy o una funzione. Valore '{0}'{1}.</target>
<note />
</trans-unit>
<trans-unit id="LetRecUnsoundInner">
<source> will evaluate '{0}'</source>
<target state="translated"> valuter '{0}'</target>
<note />
</trans-unit>
<trans-unit id="LetRecEvaluatedOutOfOrder">
<source>Bindings may be executed out-of-order because of this forward reference.</source>
<target state="translated">I binding potrebbero non essere eseguiti nell'ordine corretto a causa di questo riferimento in avanti.</target>
<note />
</trans-unit>
<trans-unit id="LetRecCheckedAtRuntime">
<source>This and other recursive references to the object(s) being defined will be checked for initialization-soundness at runtime through the use of a delayed reference. This is because you are defining one or more recursive objects, rather than recursive functions. This warning may be suppressed by using '#nowarn "40"' or '--nowarn:40'.</source>
<target state="translated">Questo e altri riferimenti ricorsivi a uno o pi oggetti in fase di definizione verranno controllati per verificare la correttezza dell'inizializzazione al runtime tramite un riferimento ritardato. Tale verifica necessaria perch si stanno definendo uno o pi oggetti ricorsivi, invece di funzioni ricorsive. La visualizzazione di questo avviso pu essere impedita mediante '#nowarn "40"' o '--nowarn:40'.</target>
<note />
</trans-unit>
<trans-unit id="SelfRefObjCtor1">
<source>Recursive references to the object being defined will be checked for initialization soundness at runtime through the use of a delayed reference. Consider placing self-references in members or within a trailing expression of the form '<ctor-expr> then <expr>'.</source>
<target state="translated">I riferimenti ricorsivi all'oggetto in fase di definizione verranno controllati per verificare la correttezza dell'inizializzazione al runtime tramite l'uso di un riferimento ritardato. Provare a inserire autoriferimenti nei membri o in un'espressione finale nel formato '<ctor-expr> then <expr>'.</target>
<note />
</trans-unit>
<trans-unit id="SelfRefObjCtor2">
<source>Recursive references to the object being defined will be checked for initialization soundness at runtime through the use of a delayed reference. Consider placing self-references within 'do' statements after the last 'let' binding in the construction sequence.</source>
<target state="translated">I riferimenti ricorsivi all'oggetto in fase di definizione verranno controllati per verificare la correttezza dell'inizializzazione al runtime tramite un riferimento ritardato. Provare a inserire autoriferimenti in istruzioni 'do' dopo l'ultimo binding 'let' nella sequenza di costruzione.</target>
<note />
</trans-unit>
<trans-unit id="VirtualAugmentationOnNullValuedType">
<source>The containing type can use 'null' as a representation value for its nullary union case. Invoking an abstract or virtual member or an interface implementation on a null value will lead to an exception. If necessary add a dummy data value to the nullary constructor to avoid 'null' being used as a representation for this type.</source>
<target state="translated">Il tipo contenitore pu utilizzare 'null' come valore di rappresentazione per il relativo case di unione nullary. Se si richiama un membro astratto o virtuale oppure un'implementazione di interfaccia su un valore Null, verr generata un'eccezione. Se necessario, aggiungere un valore di dati fittizio al costruttore nullary in modo da evitare che sia utilizzato 'null' come rappresentazione per il tipo.</target>
<note />
</trans-unit>
<trans-unit id="NonVirtualAugmentationOnNullValuedType">
<source>The containing type can use 'null' as a representation value for its nullary union case. This member will be compiled as a static member.</source>
<target state="translated">Il tipo contenitore pu utilizzare 'null' come valore di rappresentazione per il relativo case di unione nullary. Questo membro verr compilato come membro statico.</target>
<note />
</trans-unit>
<trans-unit id="NonUniqueInferredAbstractSlot1">
<source>The member '{0}' doesn't correspond to a unique abstract slot based on name and argument count alone</source>
<target state="translated">Il membro '{0}' non corrisponde a uno slot astratto univoco in base al conteggio di argomenti e al nome</target>
<note />
</trans-unit>
<trans-unit id="NonUniqueInferredAbstractSlot2">
<source>. Multiple implemented interfaces have a member with this name and argument count</source>
<target state="translated">. Pi interfacce implementate hanno un membro con questo conteggio di argomenti e nome</target>
<note />
</trans-unit>
<trans-unit id="NonUniqueInferredAbstractSlot3">
<source>. Consider implementing interfaces '{0}' and '{1}' explicitly.</source>
<target state="translated">. Provare a implementare le interfacce '{0}' e '{1}' in modo esplicito.</target>
<note />
</trans-unit>
<trans-unit id="NonUniqueInferredAbstractSlot4">
<source>. Additional type annotations may be required to indicate the relevant override. This warning can be disabled using '#nowarn "70"' or '--nowarn:70'.</source>
<target state="translated">. Potrebbero essere necessarie ulteriori annotazioni di tipo per indicare l'override rilevante. Questo avviso pu essere disabilitato mediante '#nowarn "70"' o '--nowarn:70'.</target>
<note />
</trans-unit>
<trans-unit id="Failure1">
<source>parse error</source>
<target state="translated">errore di analisi</target>
<note />
</trans-unit>
<trans-unit id="Failure2">
<source>parse error: unexpected end of file</source>
<target state="translated">errore di analisi: fine del file non prevista</target>
<note />
</trans-unit>
<trans-unit id="Failure3">
<source>{0}</source>
<target state="translated">{0}</target>
<note />
</trans-unit>
<trans-unit id="Failure4">
<source>internal error: {0}</source>
<target state="translated">errore interno: {0}</target>
<note />
</trans-unit>
<trans-unit id="FullAbstraction">
<source>{0}</source>
<target state="translated">{0}</target>
<note />
</trans-unit>
<trans-unit id="MatchIncomplete1">
<source>Incomplete pattern matches on this expression.</source>
<target state="translated">Criteri di ricerca incompleti in questa espressione.</target>
<note />
</trans-unit>
<trans-unit id="MatchIncomplete2">
<source> For example, the value '{0}' may indicate a case not covered by the pattern(s).</source>
<target state="translated"> Ad esempio, il valore '{0}' pu indicare un caso non previsto dai criteri.</target>
<note />
</trans-unit>
<trans-unit id="MatchIncomplete3">
<source> For example, the value '{0}' may indicate a case not covered by the pattern(s). However, a pattern rule with a 'when' clause might successfully match this value.</source>
<target state="translated"> Ad esempio, il valore '{0}' pu indicare un caso non previsto dai criteri. Tuttavia, la corrispondenza con il valore potrebbe essere individuata mediante una regola criteri con clausola 'when'.</target>
<note />
</trans-unit>
<trans-unit id="MatchIncomplete4">
<source> Unmatched elements will be ignored.</source>
<target state="translated"> Gli elementi senza corrispondenza verranno ignorati.</target>
<note />
</trans-unit>
<trans-unit id="EnumMatchIncomplete1">
<source>Enums may take values outside known cases.</source>
<target state="translated">Le enumerazioni possono accettare valori esterni a casi noti.</target>
<note />
</trans-unit>
<trans-unit id="RuleNeverMatched">
<source>This rule will never be matched</source>
<target state="translated">Questa regola non avr mai alcuna corrispondenza</target>
<note />
</trans-unit>
<trans-unit id="ValNotMutable">
<source>This value is not mutable. Consider using the mutable keyword, e.g. 'let mutable {0} = expression'.</source>
<target state="translated">Questo valore non modificabile. Provare a usare la parola chiave mutable, ad esempio 'let mutable {0} = espressione'.</target>
<note />
</trans-unit>
<trans-unit id="ValNotLocal">
<source>This value is not local</source>
<target state="translated">Questo valore non locale</target>
<note />
</trans-unit>
<trans-unit id="Obsolete1">
<source>This construct is deprecated</source>
<target state="translated">Questo costrutto deprecato</target>
<note />
</trans-unit>
<trans-unit id="Obsolete2">
<source>. {0}</source>
<target state="translated">. {0}</target>
<note />
</trans-unit>
<trans-unit id="Experimental">
<source>{0}. This warning can be disabled using '--nowarn:57' or '#nowarn "57"'.</source>
<target state="translated">{0}. Questo avviso pu essere disabilitato mediante '--nowarn:57' o '#nowarn "57"'.</target>
<note />
</trans-unit>
<trans-unit id="PossibleUnverifiableCode">
<source>Uses of this construct may result in the generation of unverifiable .NET IL code. This warning can be disabled using '--nowarn:9' or '#nowarn "9"'.</source>
<target state="translated">Gli utilizzi di questo costruttore potrebbero determinare la generazione di codice IL .NET non verificabile. Questo avviso pu essere disabilitato mediante '--nowarn:9' o '#nowarn "9"'.</target>
<note />
</trans-unit>
<trans-unit id="Deprecated">
<source>This construct is deprecated: {0}</source>
<target state="translated">Costrutto deprecato: {0}</target>
<note />
</trans-unit>
<trans-unit id="LibraryUseOnly">
<source>This construct is deprecated: it is only for use in the F# library</source>
<target state="translated">Costrutto deprecato: destinato esclusivamente all'uso nella libreria F#</target>
<note />
</trans-unit>
<trans-unit id="MissingFields">
<source>The following fields require values: {0}</source>
<target state="translated">Immissione valori obbligatoria per i campi seguenti: {0}</target>
<note />
</trans-unit>
<trans-unit id="ValueRestriction1">
<source>Value restriction. The value '{0}' has generic type\n {1} \nEither make the arguments to '{2}' explicit or, if you do not intend for it to be generic, add a type annotation.</source>
<target state="translated">Limitazione valore. Il valore '{0}' ha il tipo generico\n {1} \nRendere gli argomenti di '{2}' espliciti oppure, se non si intende renderlo generico, aggiungere un'annotazione di tipo.</target>
<note />
</trans-unit>
<trans-unit id="ValueRestriction2">
<source>Value restriction. The value '{0}' has generic type\n {1} \nEither make '{2}' into a function with explicit arguments or, if you do not intend for it to be generic, add a type annotation.</source>
<target state="translated">Limitazione valore. Il valore '{0}' ha il tipo generico\n {1} \nRendere '{2}' una funzione con argomenti espliciti oppure, se non si intende renderlo generico, aggiungere un'annotazione di tipo.</target>
<note />
</trans-unit>
<trans-unit id="ValueRestriction3">
<source>Value restriction. This member has been inferred to have generic type\n {0} \nConstructors and property getters/setters cannot be more generic than the enclosing type. Add a type annotation to indicate the exact types involved.</source>
<target state="translated">Restrizione relativa ai valori. stato dedotto che il membro ha il tipo generico\n {0} \nI getter/setter di propriet e i costruttori non possono essere pi generici del tipo di inclusione. Aggiungere un'annotazione di tipo per indicare i tipi esatti previsti.</target>
<note />
</trans-unit>
<trans-unit id="ValueRestriction4">
<source>Value restriction. The value '{0}' has been inferred to have generic type\n {1} \nEither make the arguments to '{2}' explicit or, if you do not intend for it to be generic, add a type annotation.</source>
<target state="translated">Limitazione valore. stato dedotto che il valore '{0}' ha il tipo generico\n {1} \nRendere gli argomenti di '{2}' espliciti, oppure se non si intende renderlo generico, aggiungere un'annotazione di tipo.</target>
<note />
</trans-unit>
<trans-unit id="ValueRestriction5">
<source>Value restriction. The value '{0}' has been inferred to have generic type\n {1} \nEither define '{2}' as a simple data term, make it a function with explicit arguments or, if you do not intend for it to be generic, add a type annotation.</source>
<target state="translated">Limitazione valore. stato dedotto che il valore '{0}' ha il tipo generico\n {1} \nDefinire '{2}' come termine di dati semplice, renderlo una funzione con argomenti espliciti oppure, se non si intende renderlo generico, aggiungere un'annotazione di tipo.</target>
<note />
</trans-unit>
<trans-unit id="RecoverableParseError">
<source>syntax error</source>
<target state="translated">errore di sintassi</target>
<note />
</trans-unit>
<trans-unit id="ReservedKeyword">
<source>{0}</source>
<target state="translated">{0}</target>
<note />
</trans-unit>
<trans-unit id="IndentationProblem">
<source>{0}</source>
<target state="translated">{0}</target>
<note />
</trans-unit>
<trans-unit id="OverrideInIntrinsicAugmentation">
<source>Override implementations in augmentations are now deprecated. Override implementations should be given as part of the initial declaration of a type.</source>
<target state="translated">Le implementazioni degli override negli aumenti sono ora deprecate. Le implementazioni degli override devono essere specificate all'interno della dichiarazione iniziale di un tipo.</target>
<note />
</trans-unit>
<trans-unit id="OverrideInExtrinsicAugmentation">
<source>Override implementations should be given as part of the initial declaration of a type.</source>
<target state="translated">Le implementazioni degli override devono essere specificate all'interno della dichiarazione iniziale di un tipo.</target>
<note />
</trans-unit>
<trans-unit id="IntfImplInIntrinsicAugmentation">
<source>Interface implementations should normally be given on the initial declaration of a type. Interface implementations in augmentations may lead to accessing static bindings before they are initialized, though only if the interface implementation is invoked during initialization of the static data, and in turn access the static data. You may remove this warning using #nowarn "69" if you have checked this is not the case.</source>
<target state="translated">In genere, le implementazioni di interfaccia devono essere specificate nella dichiarazione iniziale di un tipo. Le implementazioni di interfaccia negli aumenti possono portare all'accesso ai binding statici prima dell'inizializzazione, anche se l'implementazione dell'interfaccia viene richiamata durante l'inizializzazione dei dati statici e a sua volta accede ai dati statici. possibile rimuovere questo avviso utilizzando #nowarn "69" se stato verificato che il caso specifico non lo richiede.</target>
<note />
</trans-unit>
<trans-unit id="IntfImplInExtrinsicAugmentation">
<source>Interface implementations should be given on the initial declaration of a type.</source>
<target state="translated">Le implementazioni di interfaccia devono essere specificate nella dichiarazione iniziale di un tipo.</target>
<note />
</trans-unit>
<trans-unit id="UnresolvedReferenceNoRange">
<source>A required assembly reference is missing. You must add a reference to assembly '{0}'.</source>
<target state="translated">Riferimento ad assembly mancante. Aggiungere un riferimento all'assembly '{0}'.</target>
<note />
</trans-unit>
<trans-unit id="UnresolvedPathReferenceNoRange">
<source>The type referenced through '{0}' is defined in an assembly that is not referenced. You must add a reference to assembly '{1}'.</source>
<target state="translated">Il tipo a cui viene fatto riferimento tramite '{0}' definito in un assembly a cui non viene fatto riferimento. Aggiungere un riferimento all'assembly '{1}'.</target>
<note />
</trans-unit>
<trans-unit id="HashIncludeNotAllowedInNonScript">
<source>#I directives may only occur in F# script files (extensions .fsx or .fsscript). Either move this code to a script file, add a '-I' compiler option for this reference or delimit the directive with delimit it with '#if INTERACTIVE'/'#endif'.</source>
<target state="translated">Le direttive #I possono trovarsi solo in file di script F# (estensioni fsx o fsscript). Spostare il codice in un file di script, aggiungere un'opzione di compilazione '-I' per questo riferimento oppure delimitare la direttiva con '#if INTERACTIVE'/'#endif'.</target>
<note />
</trans-unit>
<trans-unit id="HashReferenceNotAllowedInNonScript">
<source>#r directives may only occur in F# script files (extensions .fsx or .fsscript). Either move this code to a script file or replace this reference with the '-r' compiler option. If this directive is being executed as user input, you may delimit it with '#if INTERACTIVE'/'#endif'.</source>
<target state="translated">Le direttive #r possono trovarsi solo in file di script F# (estensioni fsx o fsscript). Spostare il codice in un file di script oppure sostituire questo riferimento con l'opzione del compilatore '-r'. Se questa direttiva viene eseguita come input utente, possibile delimitarla con '#if INTERACTIVE'/'#endif'.</target>
<note />
</trans-unit>
<trans-unit id="HashDirectiveNotAllowedInNonScript">
<source>This directive may only be used in F# script files (extensions .fsx or .fsscript). Either remove the directive, move this code to a script file or delimit the directive with '#if INTERACTIVE'/'#endif'.</source>
<target state="translated">Questa direttiva pu essere utilizzata solo in file di script F# (estensioni fsx o fsscript). Rimuovere la direttiva, spostare il codice in un file di script oppure delimitarla con '#if INTERACTIVE'/'#endif'.</target>
<note />
</trans-unit>
<trans-unit id="FileNameNotResolved">
<source>Unable to find the file '{0}' in any of\n {1}</source>
<target state="translated">Il file '{0}' non stato trovato in \n {1}</target>
<note />
</trans-unit>
<trans-unit id="AssemblyNotResolved">
<source>Assembly reference '{0}' was not found or is invalid</source>
<target state="translated">Riferimento ad assembly '{0}' non trovato o non valido</target>
<note />
</trans-unit>
<trans-unit id="HashLoadedSourceHasIssues1">
<source>One or more warnings in loaded file.\n</source>
<target state="translated">Uno o pi avvisi nel file caricato.\n</target>
<note />
</trans-unit>
<trans-unit id="HashLoadedSourceHasIssues2">
<source>One or more errors in loaded file.\n</source>
<target state="translated">Uno o pi errori nel file caricato.\n</target>
<note />
</trans-unit>
<trans-unit id="HashLoadedScriptConsideredSource">
<source>Loaded files may only be F# source files (extension .fs). This F# script file (.fsx or .fsscript) will be treated as an F# source file</source>
<target state="translated">I file caricati possono essere solo file di origine F# (estensione fs). Questo file di script F# (fsx o fsscript) verr considerato come un file di origine F#</target>
<note />
</trans-unit>
<trans-unit id="InvalidInternalsVisibleToAssemblyName1">
<source>Invalid assembly name '{0}' from InternalsVisibleTo attribute in {1}</source>
<target state="translated">Nome assembly non valido '{0}' dall'attributo InternalsVisibleTo in {1}</target>
<note />
</trans-unit>
<trans-unit id="InvalidInternalsVisibleToAssemblyName2">
<source>Invalid assembly name '{0}' from InternalsVisibleTo attribute (assembly filename not available)</source>
<target state="translated">Nome assembly non valido '{0}' dall'attributo InternalsVisibleTo (nome file di assembly non disponibile)</target>
<note />
</trans-unit>
<trans-unit id="LoadedSourceNotFoundIgnoring">
<source>Could not load file '{0}' because it does not exist or is inaccessible</source>
<target state="translated">Non stato possibile caricare il file '{0}' perch non esiste o non accessibile</target>
<note />
</trans-unit>
<trans-unit id="MSBuildReferenceResolutionError">
<source>{0} (Code={1})</source>
<target state="translated">{0} (codice={1})</target>
<note />
</trans-unit>
<trans-unit id="TargetInvocationExceptionWrapper">
<source>internal error: {0}</source>
<target state="translated">errore interno: {0}</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.LBRACE.BAR">
<source>symbol '{|'</source>
<target state="translated">simbolo '{|'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.BAR.RBRACE">
<source>symbol '|}'</source>
<target state="translated">simbolo '|}'</target>
<note />
</trans-unit>
<trans-unit id="Parser.TOKEN.AND.BANG">
<source>keyword 'and!'</source>
<target state="translated">parola chiave 'and!'</target>
<note />
</trans-unit>
</body>
</file>
</xliff>
``` | /content/code_sandbox/src/fcs-fable/src/Compiler/xlf/FSStrings.it.xlf | xml | 2016-01-11T10:10:13 | 2024-08-15T11:42:55 | Fable | fable-compiler/Fable | 2,874 | 22,477 |
```xml
export const featureId = "state-provider";
export const featureSubId = "react-query";
``` | /content/code_sandbox/packages/xarc-react-query/src/common/feature-info.ts | xml | 2016-09-06T19:02:39 | 2024-08-11T11:43:11 | electrode | electrode-io/electrode | 2,103 | 20 |
```xml
export enum eServiceType {
All = 'all',
Application = 'application',
Integration = 'integration',
}
export const defaultEServiceType = eServiceType.Application;
``` | /content/code_sandbox/npm/ng-packs/packages/schematics/src/enums/service-types.ts | xml | 2016-12-03T22:56:24 | 2024-08-16T16:24:05 | abp | abpframework/abp | 12,657 | 38 |
```xml
<RelativeLayout xmlns:android="path_to_url"
xmlns:app="path_to_url"
xmlns:tools="path_to_url"
android:id="@+id/provider_container"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:fitsSystemWindows="true"
tools:context=".providers.FileProviderActivity">
<com.google.android.material.appbar.AppBarLayout
android:id="@+id/app_bar_layout_provider"
android:layout_width="match_parent"
android:layout_height="wrap_content"
app:elevation="0dp">
<com.google.android.material.appbar.MaterialToolbar
android:id="@+id/toolbar_provider"
android:layout_width="match_parent"
android:layout_height="?attr/actionBarSize"
android:background="@android:color/transparent" />
<com.google.android.material.tabs.TabLayout
android:id="@+id/sliding_tabs_provider"
style="@style/Widget.Mega.TabLayout"
android:layout_width="match_parent"
android:layout_height="wrap_content" />
</com.google.android.material.appbar.AppBarLayout>
<mega.privacy.android.app.components.CustomViewPager
android:id="@+id/provider_tabs_pager"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_above="@+id/separator"
android:layout_below="@+id/app_bar_layout_provider" />
<View
android:id="@+id/separator"
android:layout_width="match_parent"
android:layout_height="1dp"
android:layout_above="@id/options_provider_layout"
android:background="@color/grey_012_white_012" />
<LinearLayout
android:id="@+id/options_provider_layout"
android:layout_width="match_parent"
android:layout_height="48dp"
android:layout_alignParentBottom="true"
android:gravity="end|center_vertical"
android:orientation="horizontal">
<Button
android:id="@+id/cancel_button"
style="?attr/borderlessButtonStyle"
android:gravity="center_vertical|center_horizontal"
android:text="@string/general_cancel" />
<Button
android:id="@+id/attach_button"
style="?attr/borderlessButtonStyle"
android:gravity="center_vertical|center_horizontal"
android:text="@string/general_attach" />
</LinearLayout>
</RelativeLayout>
``` | /content/code_sandbox/app/src/main/res/layout/activity_file_provider.xml | xml | 2016-05-04T11:46:20 | 2024-08-15T16:29:10 | android | meganz/android | 1,537 | 516 |
```xml
const baseStyle = {
multiline: true,
p: '2',
textAlignVertical: 'top',
h: '20',
};
export default {
baseStyle,
defaultProps: {
size: 'sm',
variant: 'outline',
},
};
``` | /content/code_sandbox/src/theme/components/textarea.ts | xml | 2016-04-15T11:37:23 | 2024-08-14T16:16:44 | NativeBase | GeekyAnts/NativeBase | 20,132 | 57 |
```xml
declare const global: any;
// In standard node environments there is no DOM API
export const isDOMAvailable = false;
export const canUseEventListeners = false;
export const canUseViewport = false;
export let isAsyncDebugging: boolean = false;
if (__DEV__) {
// These native globals are injected by native React runtimes and not standard browsers
// we can use them to determine if the JS is being executed in Chrome.
isAsyncDebugging =
!global.nativeExtensions && !global.nativeCallSyncHook && !global.RN$Bridgeless;
}
``` | /content/code_sandbox/packages/expo-modules-core/src/environment/browser.ts | xml | 2016-08-15T17:14:25 | 2024-08-16T19:54:44 | expo | expo/expo | 32,004 | 121 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="path_to_url"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:id="@+id/listTitle"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:paddingLeft="?android:attr/expandableListPreferredItemPaddingLeft"
android:textColor="@android:color/black"
android:paddingTop="10dp"
android:paddingBottom="10dp" />
</LinearLayout>
``` | /content/code_sandbox/Android/ExpandableListView/app/src/main/res/layout/list_group.xml | xml | 2016-05-02T05:43:21 | 2024-08-16T06:51:39 | journaldev | WebJournal/journaldev | 1,314 | 131 |
```xml
/**
* @license
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
/**
* @file Provides file listing and completion for storage systems supporting the S3 XML API (e.g. S3
* and GCS).
*/
import { fetchWithOAuth2Credentials } from "#src/credentials_provider/oauth2.js";
import type { CancellationToken } from "#src/util/cancellation.js";
import type { BasicCompletionResult } from "#src/util/completion.js";
import type { SpecialProtocolCredentialsProvider } from "#src/util/special_protocol_request.js";
export async function getS3BucketListing(
credentialsProvider: SpecialProtocolCredentialsProvider,
bucketUrl: string,
prefix: string,
delimiter: string,
cancellationToken: CancellationToken,
): Promise<string[]> {
const response = await fetchWithOAuth2Credentials(
credentialsProvider,
`${bucketUrl}?prefix=${encodeURIComponent(prefix)}` +
`&delimiter=${encodeURIComponent(delimiter)}`,
/*init=*/ {},
(x) => x.text(),
cancellationToken,
);
const doc = new DOMParser().parseFromString(response, "application/xml");
const commonPrefixNodes = doc.evaluate(
'//*[name()="CommonPrefixes"]/*[name()="Prefix"]',
doc,
null,
XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
null,
);
const results: string[] = [];
for (let i = 0, n = commonPrefixNodes.snapshotLength; i < n; ++i) {
results.push(commonPrefixNodes.snapshotItem(i)!.textContent || "");
}
const contents = doc.evaluate(
'//*[name()="Contents"]/*[name()="Key"]',
doc,
null,
XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
null,
);
for (let i = 0, n = contents.snapshotLength; i < n; ++i) {
results.push(contents.snapshotItem(i)!.textContent || "");
}
return results;
}
export async function getS3CompatiblePathCompletions(
credentialsProvider: SpecialProtocolCredentialsProvider,
enteredBucketUrl: string,
bucketUrl: string,
path: string,
cancellationToken: CancellationToken,
): Promise<BasicCompletionResult> {
const prefix = path;
if (!prefix.startsWith("/")) throw null;
const paths = await getS3BucketListing(
credentialsProvider,
bucketUrl,
path.substring(1),
"/",
cancellationToken,
);
const offset = path.lastIndexOf("/");
return {
offset: offset + enteredBucketUrl.length + 1,
completions: paths.map((x) => ({ value: x.substring(offset) })),
};
}
``` | /content/code_sandbox/src/util/s3_bucket_listing.ts | xml | 2016-05-27T02:37:25 | 2024-08-16T07:24:25 | neuroglancer | google/neuroglancer | 1,045 | 580 |
```xml
export { default as Collapsible } from './Collapsible';
export * from './Collapsible';
export { default as CollapsibleHeader } from './CollapsibleHeader';
export * from './CollapsibleHeader';
export { default as CollapsibleContent } from './CollapsibleContent';
export * from './CollapsibleContent';
export { default as CollapsibleHeaderButton } from './CollapsibleHeaderButton';
export * from './CollapsibleHeaderButton';
export { default as CollapsibleHeaderIconButton } from './CollapsibleHeaderIconButton';
export * from './CollapsibleHeaderIconButton';
``` | /content/code_sandbox/packages/components/components/collapsible/index.ts | xml | 2016-06-08T11:16:51 | 2024-08-16T14:14:27 | WebClients | ProtonMail/WebClients | 4,300 | 114 |
```xml
import { SpawnOptions } from 'child_process';
import { join } from 'path';
import { exec } from '@verdaccio/test-cli-commons';
import { addRegistry } from '@verdaccio/test-cli-commons';
export function getCommand() {
return join(__dirname, './node_modules/.bin/npm');
}
export function npm(options: SpawnOptions, ...args: string[]) {
return exec(options, getCommand(), args);
}
export async function bumbUp(tempFolder, registry) {
await npm({ cwd: tempFolder }, 'version', 'minor', ...addRegistry(registry.getRegistryUrl()));
}
export async function publish(tempFolder, pkgName, registry, arg: string[] = []) {
const resp = await npm(
{ cwd: tempFolder },
'publish',
...arg,
'--json',
...addRegistry(registry.getRegistryUrl())
);
const parsedBody = JSON.parse(resp.stdout as string);
expect(parsedBody.name).toEqual(pkgName);
}
export async function getInfoVersions(pkgName, registry) {
const infoResp = await npm(
{},
'info',
pkgName,
'--json',
...addRegistry(registry.getRegistryUrl())
);
const infoBody = JSON.parse(infoResp.stdout as string);
return infoBody;
}
``` | /content/code_sandbox/e2e/cli/e2e-npm9/utils.ts | xml | 2016-04-15T16:21:12 | 2024-08-16T09:38:01 | verdaccio | verdaccio/verdaccio | 16,189 | 276 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="search_layover_bg">@color/gray</color>
<color name="search_field_bg">@color/white_ish</color>
<color name="transparent">#00FFFFFF</color>
<color name="white">#ffffffff</color>
<color name="black">#ff000000</color>
<color name="gray">#ff888888</color>
<color name="white_50">#88ffffff</color>
<color name="black_50">#88000000</color>
<color name="gray_50">#88888888</color>
<color name="white_ish">#fffefefe</color>
</resources>
``` | /content/code_sandbox/library/src/main/res/values/colors.xml | xml | 2016-04-19T23:48:39 | 2024-07-18T16:15:26 | MaterialSearchView | Mauker1/MaterialSearchView | 1,080 | 163 |
```xml
import type { DecryptedMessage } from '@proton/docs-shared'
export type SingleMessageVerificationResult = {
verified: boolean
message: DecryptedMessage
}
export type VerificationUsecaseResult = {
allVerified: boolean
messages: SingleMessageVerificationResult[]
}
``` | /content/code_sandbox/packages/docs-core/lib/UseCase/VerifyUpdatesResult.ts | xml | 2016-06-08T11:16:51 | 2024-08-16T14:14:27 | WebClients | ProtonMail/WebClients | 4,300 | 60 |
```xml
import { isObjectType } from "grafast/graphql";
import type { PoolClient } from "pg";
import * as core from "./core.js";
// WARNING: this function is not guaranteed to be SQL injection safe.
const offerViewComment = (comment: string) => (pgClient: PoolClient) =>
pgClient.query(
`comment on view smart_comment_relations.offer_view is E'${comment.replace(
/'/g,
"''",
)}';`,
);
test(
"referencing hidden table (ignored)",
core.test(
__filename,
["smart_comment_relations"],
{},
offerViewComment(`@name offers
@primaryKey id
@foreignKey (post_id) references post`),
(schema) => {
const Offer = schema.getType("Offer");
if (!isObjectType(Offer)) {
throw new Error("Expected Offer to be an object type");
}
const fields = Offer.getFields();
expect(fields.nodeId).toBeTruthy();
expect(fields.postsByPostId).toBeFalsy();
expect(Object.keys(fields)).toMatchInlineSnapshot(`
[
"nodeId",
"id",
"postId",
]
`);
},
),
);
``` | /content/code_sandbox/postgraphile/postgraphile/__tests__/schema/v4/smart_comment_relations.post.test.ts | xml | 2016-04-14T21:29:19 | 2024-08-16T17:12:51 | crystal | graphile/crystal | 12,539 | 252 |
```xml
import {
BaseClientSideWebPart,
IPropertyPaneConfiguration
} from '@microsoft/sp-webpart-base';
import {
Environment,
EnvironmentType
} from '@microsoft/sp-core-library';
import styles from './DepProps.module.scss';
import * as strings from 'depPropsStrings';
import { IDepPropsWebPartProps } from './IDepPropsWebPartProps';
import { PropertyPaneViewSelectorField } from './controls/PropertyPaneViewSelector';
export default class DepPropsWebPart extends BaseClientSideWebPart<IDepPropsWebPartProps> {
public constructor() {
super();
this.onCustomPropertyPaneFieldChanged = this.onCustomPropertyPaneFieldChanged.bind(this);
}
public render(): void {
this.domElement.innerHTML = `
<div class="${styles.depProps}">
<div class="${styles.container}">
<div class="ms-Grid-row ms-bgColor-themeDark ms-fontColor-white ${styles.row}">
<div class="ms-Grid-col ms-u-lg10 ms-u-xl8 ms-u-xlPush2 ms-u-lgPush1">
<p class="ms-font-l ms-fontColor-white">Selected List Id: ${this.properties.depProps.listId}</p>
<p class="ms-font-l ms-fontColor-white">Selected View Id: ${this.properties.depProps.viewId}</p>
</div>
</div>
</div>
</div>`;
}
/**
* Provides logic to update web part properties and initiate re-render
* @param targetProperty property that has been changed
* @param newValue new value of the property
*/
public onCustomPropertyPaneFieldChanged(targetProperty: string, newValue: any) {
const oldValue = this.properties[targetProperty];
this.properties[targetProperty] = newValue;
this.onPropertyPaneFieldChanged(targetProperty, oldValue, newValue);
// NOTE: in local workbench onPropertyPaneFieldChanged method initiates re-render
// in SharePoint environment we need to call re-render by ourselves
if (Environment.type !== EnvironmentType.Local) {
this.render();
}
}
protected getPropertyPaneConfiguration(): IPropertyPaneConfiguration {
return {
pages: [
{
header: {
description: strings.PropertyPaneDescription
},
groups: [
{
groupName: strings.BasicGroupName,
groupFields: [
PropertyPaneViewSelectorField('depProps', {
wpContext: this.context,
listId: this.properties.depProps && this.properties.depProps.listId,
viewId: this.properties.depProps && this.properties.depProps.viewId,
listLabel: strings.SelectList,
viewLabel: strings.SelectView,
onPropertyChange: this.onCustomPropertyPaneFieldChanged
})
]
}
]
}
]
};
}
}
``` | /content/code_sandbox/samples/knockout-dependent-properties/src/webparts/depProps/DepPropsWebPart.ts | xml | 2016-08-30T17:21:43 | 2024-08-16T18:41:32 | sp-dev-fx-webparts | pnp/sp-dev-fx-webparts | 2,027 | 586 |
```xml
import * as React from 'react';
import expect from 'expect';
import {
render,
fireEvent,
waitFor,
screen,
act,
} from '@testing-library/react';
import { testDataProvider } from '../../dataProvider';
import { memoryStore } from '../../store';
import { ListController } from './ListController';
import {
getListControllerProps,
sanitizeListRestProps,
} from './useListController';
import { CoreAdminContext } from '../../core';
import { TestMemoryRouter } from '../../routing';
describe('useListController', () => {
const defaultProps = {
children: jest.fn(),
resource: 'posts',
debounce: 200,
};
describe('queryOptions', () => {
it('should accept custom client query options', async () => {
jest.spyOn(console, 'error').mockImplementationOnce(() => {});
const getList = jest
.fn()
.mockImplementationOnce(() => Promise.reject(new Error()));
const onError = jest.fn();
const dataProvider = testDataProvider({ getList });
render(
<CoreAdminContext dataProvider={dataProvider}>
<ListController resource="posts" queryOptions={{ onError }}>
{() => <div />}
</ListController>
</CoreAdminContext>
);
await waitFor(() => {
expect(getList).toHaveBeenCalled();
expect(onError).toHaveBeenCalled();
});
});
it('should accept meta in queryOptions', async () => {
const getList = jest
.fn()
.mockImplementationOnce(() =>
Promise.resolve({ data: [], total: 25 })
);
const dataProvider = testDataProvider({ getList });
render(
<CoreAdminContext dataProvider={dataProvider}>
<ListController
resource="posts"
queryOptions={{ meta: { foo: 'bar' } }}
>
{() => <div />}
</ListController>
</CoreAdminContext>
);
await waitFor(() => {
expect(getList).toHaveBeenCalledWith('posts', {
filter: {},
pagination: { page: 1, perPage: 10 },
sort: { field: 'id', order: 'ASC' },
meta: { foo: 'bar' },
signal: undefined,
});
});
});
it('should reset page when enabled is set to false', async () => {
const children = jest.fn().mockReturnValue(<span>children</span>);
const dataProvider = testDataProvider({
getList: () => Promise.resolve({ data: [], total: 0 }),
});
const props = { ...defaultProps, children };
render(
<CoreAdminContext dataProvider={dataProvider}>
<ListController
disableSyncWithLocation
queryOptions={{ enabled: false }}
{...props}
resource="posts"
/>
</CoreAdminContext>
);
act(() => {
// @ts-ignore
children.mock.calls.at(-1)[0].setPage(3);
});
await waitFor(() => {
expect(children).toHaveBeenCalledWith(
expect.objectContaining({
page: 1,
})
);
});
});
});
describe('setFilters', () => {
let childFunction = ({ setFilters, filterValues }) => (
<input
aria-label="search"
type="text"
value={filterValues.q || ''}
onChange={event => {
setFilters({ q: event.target.value });
}}
/>
);
it('should take only last change in case of a burst of changes (case of inputs being currently edited)', async () => {
const props = {
...defaultProps,
children: childFunction,
};
const store = memoryStore();
const storeSpy = jest.spyOn(store, 'setItem');
render(
<CoreAdminContext
dataProvider={testDataProvider({
getList: () => Promise.resolve({ data: [], total: 0 }),
})}
store={store}
>
<ListController {...props} />
</CoreAdminContext>
);
const searchInput = screen.getByLabelText('search');
fireEvent.change(searchInput, { target: { value: 'hel' } });
fireEvent.change(searchInput, { target: { value: 'hell' } });
fireEvent.change(searchInput, { target: { value: 'hello' } });
await new Promise(resolve => setTimeout(resolve, 210));
await waitFor(() => {
expect(storeSpy).toHaveBeenCalledTimes(1);
});
expect(storeSpy).toHaveBeenCalledWith('posts.listParams', {
filter: { q: 'hello' },
order: 'ASC',
page: 1,
perPage: 10,
sort: 'id',
});
});
it('should remove empty filters', async () => {
const props = {
...defaultProps,
children: childFunction,
};
const store = memoryStore();
const storeSpy = jest.spyOn(store, 'setItem');
render(
<TestMemoryRouter
initialEntries={[
`/posts?filter=${JSON.stringify({
q: 'hello',
})}&displayedFilters=${JSON.stringify({ q: true })}`,
]}
>
<CoreAdminContext
dataProvider={testDataProvider({
getList: () =>
Promise.resolve({ data: [], total: 0 }),
})}
store={store}
>
<ListController {...props} />
</CoreAdminContext>
</TestMemoryRouter>
);
expect(storeSpy).toHaveBeenCalledTimes(1);
const searchInput = screen.getByLabelText('search');
// FIXME: For some reason, triggering the change event with an empty string
// does not call the event handler on childFunction
fireEvent.change(searchInput, { target: { value: '' } });
await new Promise(resolve => setTimeout(resolve, 210));
expect(storeSpy).toHaveBeenCalledTimes(2);
expect(storeSpy).toHaveBeenCalledWith('posts.listParams', {
filter: {},
displayedFilters: { q: true },
order: 'ASC',
page: 1,
perPage: 10,
sort: 'id',
});
});
it('should update data if permanent filters change', () => {
const children = jest.fn().mockReturnValue(<span>children</span>);
const props = {
...defaultProps,
debounce: 200,
children,
};
const getList = jest
.fn()
.mockImplementation(() =>
Promise.resolve({ data: [], total: 0 })
);
const dataProvider = testDataProvider({ getList });
const { rerender } = render(
<TestMemoryRouter initialEntries={[`/posts`]}>
<CoreAdminContext dataProvider={dataProvider}>
<ListController {...props} filter={{ foo: 1 }} />
</CoreAdminContext>
</TestMemoryRouter>
);
// Check that the permanent filter was used in the query
expect(getList).toHaveBeenCalledTimes(1);
expect(getList).toHaveBeenCalledWith(
'posts',
expect.objectContaining({ filter: { foo: 1 } })
);
// Check that the permanent filter is not included in the displayedFilters and filterValues (passed to Filter form and button)
expect(children).toHaveBeenCalledTimes(1);
expect(children).toHaveBeenCalledWith(
expect.objectContaining({
displayedFilters: {},
filterValues: {},
})
);
rerender(
<TestMemoryRouter initialEntries={[`/posts`]}>
<CoreAdminContext dataProvider={dataProvider}>
<ListController {...props} filter={{ foo: 2 }} />
</CoreAdminContext>
</TestMemoryRouter>
);
// Check that the permanent filter was used in the query
expect(getList).toHaveBeenCalledTimes(2);
expect(getList).toHaveBeenCalledWith(
'posts',
expect.objectContaining({ filter: { foo: 2 } })
);
expect(children).toHaveBeenCalledTimes(2);
});
});
describe('showFilter', () => {
it('Does not remove previously shown filter when adding a new one', async () => {
let currentDisplayedFilters;
let childFunction = ({ showFilter, displayedFilters }) => {
currentDisplayedFilters = displayedFilters;
return (
<>
<button
aria-label="Show filter 1"
onClick={() => {
showFilter('filter1.subdata', 'bob');
}}
/>
<button
aria-label="Show filter 2"
onClick={() => {
showFilter('filter2', '');
}}
/>
</>
);
};
const props = {
...defaultProps,
children: childFunction,
};
render(
<CoreAdminContext
dataProvider={testDataProvider({
getList: () => Promise.resolve({ data: [], total: 0 }),
})}
>
<ListController {...props} />
</CoreAdminContext>
);
fireEvent.click(screen.getByLabelText('Show filter 1'));
await waitFor(() => {
expect(currentDisplayedFilters).toEqual({
'filter1.subdata': true,
});
});
fireEvent.click(screen.getByLabelText('Show filter 2'));
await waitFor(() => {
expect(currentDisplayedFilters).toEqual({
'filter1.subdata': true,
filter2: true,
});
});
});
it('should support to sync calls', async () => {
render(
<CoreAdminContext
dataProvider={testDataProvider({
getList: () => Promise.resolve({ data: [], total: 0 }),
})}
>
<ListController {...defaultProps}>
{({ displayedFilters, showFilter }) => (
<>
<button
aria-label="Show filters"
onClick={() => {
showFilter('filter1.subdata', 'bob');
showFilter('filter2', '');
}}
/>
{Object.keys(displayedFilters).map(
(displayedFilter, index) => (
<div key={index}>{displayedFilter}</div>
)
)}
</>
)}
</ListController>
</CoreAdminContext>
);
fireEvent.click(screen.getByLabelText('Show filters'));
await waitFor(() => {
expect(screen.queryByText('filter1.subdata')).not.toBeNull();
expect(screen.queryByText('filter2')).not.toBeNull();
});
});
});
describe('pagination', () => {
it('should compute hasNextPage and hasPreviousPage based on total', async () => {
const getList = jest
.fn()
.mockImplementation(() =>
Promise.resolve({ data: [], total: 25 })
);
const dataProvider = testDataProvider({ getList });
const children = jest.fn().mockReturnValue(<span>children</span>);
const props = {
...defaultProps,
children,
};
render(
<CoreAdminContext dataProvider={dataProvider}>
<ListController {...props} />
</CoreAdminContext>
);
await waitFor(() => {
expect(children).toHaveBeenCalledWith(
expect.objectContaining({
page: 1,
total: 25,
hasNextPage: true,
hasPreviousPage: false,
})
);
});
act(() => {
// @ts-ignore
children.mock.calls.at(-1)[0].setPage(2);
});
await waitFor(() => {
expect(children).toHaveBeenCalledWith(
expect.objectContaining({
page: 2,
total: 25,
hasNextPage: true,
hasPreviousPage: true,
})
);
});
act(() => {
// @ts-ignore
children.mock.calls.at(-1)[0].setPage(3);
});
await waitFor(() => {
expect(children).toHaveBeenCalledWith(
expect.objectContaining({
page: 3,
total: 25,
hasNextPage: false,
hasPreviousPage: true,
})
);
});
});
it('should compute hasNextPage and hasPreviousPage based on pageInfo', async () => {
const getList = jest.fn().mockImplementation(() =>
Promise.resolve({
data: [],
pageInfo: { hasNextPage: true, hasPreviousPage: false },
})
);
const dataProvider = testDataProvider({ getList });
const children = jest.fn().mockReturnValue(<span>children</span>);
const props = {
...defaultProps,
children,
};
render(
<CoreAdminContext dataProvider={dataProvider}>
<ListController {...props} />
</CoreAdminContext>
);
await waitFor(() => {
expect(children).toHaveBeenCalledWith(
expect.objectContaining({
page: 1,
total: undefined,
hasNextPage: true,
hasPreviousPage: false,
})
);
});
});
});
describe('getListControllerProps', () => {
it('should only pick the props injected by the ListController', () => {
expect(
getListControllerProps({
foo: 1,
data: [4, 5],
page: 3,
bar: 'hello',
})
).toEqual({
sort: undefined,
data: [4, 5],
defaultTitle: undefined,
displayedFilters: undefined,
error: undefined,
exporter: undefined,
filterValues: undefined,
hasCreate: undefined,
hideFilter: undefined,
isFetching: undefined,
isLoading: undefined,
onSelect: undefined,
onToggleItem: undefined,
onUnselectItems: undefined,
page: 3,
perPage: undefined,
refetch: undefined,
refresh: undefined,
resource: undefined,
selectedIds: undefined,
setFilters: undefined,
setPage: undefined,
setPerPage: undefined,
setSort: undefined,
showFilter: undefined,
total: undefined,
totalPages: undefined,
});
});
});
describe('sanitizeListRestProps', () => {
it('should omit the props injected by the ListController', () => {
expect(
sanitizeListRestProps({
foo: 1,
data: [4, 5],
page: 3,
bar: 'hello',
})
).toEqual({
foo: 1,
bar: 'hello',
});
});
});
});
``` | /content/code_sandbox/packages/ra-core/src/controller/list/useListController.spec.tsx | xml | 2016-07-13T07:58:54 | 2024-08-16T18:32:27 | react-admin | marmelab/react-admin | 24,624 | 2,988 |
```xml
<resources>
<string name="app_name"> </string>
<string name="title_activity_gallery"></string>
<string name="title_activity_full_image"> </string>
<string name="images_scanned"> </string>
<string name="action_share"> </string>
<string name="action_delete"></string>
<string name="confirm_title"></string>
<string name="confirm_delete_text"> ;</string>
<string name="answer_yes"></string>
<string name="answer_no"></string>
<string name="confirm_delete_multiple_text"> ;</string>
<string name="share_snackbar"> </string>
<string name="action_about"> </string>
<string name="about_filename">about.md</string>
<string name="install_opencv"> OpenCV</string>
<string name="confirm_install_opencv"> OpenCV ;</string>
<string name="answer_cancel"></string>
<string name="downloading"> </string>
<string name="downloading_opencv"> OpenCV</string>
<string name="scanningToast"> \n , </string>
<string name="colorMode"> </string>
<string name="bwMode"> </string>
<string name="autoMode"> </string>
<string name="manualMode"> </string>
<string name="share_app"> </string>
<string name="share_app_using"> </string>
<string name="share_app_body"> . , , : </string>
<string name="share_app_subject"> </string>
<string name="settings"></string>
<string name="basic_settings"> </string>
<string name="automatic_tagging"> </string>
<string name="automatic_tagging_summary"> , , .</string>
<string name="match_aspect"> </string>
<string name="match_aspect_summary"> , , . , .</string>
<string name="bug_rotate"> 180</string>
<string name="bug_rotate_summary"> ( ). , .</string>
<string name="usage_stats"> </string>
<string name="usage_stats_summary"> . .</string>
<string name="send_message"> </string>
<string name="send_message_summary"> </string>
<string name="stats_optin_title"> </string>
<string name="stats_optin_text"> , , ;\n \n , , .</string>
<string name="answer_later"></string>
<string name="ask_install_opencv"> , OpenCV, , , .</string>
<string name="googleplay">Google Play</string>
<string name="githubdownload"> </string>
<string name="activateunknown"> </string>
<string name="messageactivateunknown"> , . , .</string>
<string name="github_project"> GitHub</string>
<string name="github_project_summary"> . , , , , , .</string>
<string name="donate"> </string>
<string name="donate_summary"> , .</string>
<string name="telegram"> Telegram</string>
<string name="telegram_summary"> Telegram </string>
<string name="feedback_and_contributions"> </string>
<string name="bitcoin_summary"> - Bitcoin</string>
<string name="paypal_summary"> </string>
<string name="filterModeOn"> </string>
<string name="filterModeOff"> </string>
<string name="action_tag"></string>
<string name="storage_folder"> </string>
<string name="storage_folder_summary"> </string>
<string name="save_png"> PNG</string>
<string name="save_png_summary"> . , , , . , .</string>
<string name="format_not_supported"> </string>
<string name="format_not_supported_message"> </string>
<string name="set_scan_topic"> </string>
<string name="cancel"></string>
<string name="custom_scan_topic"> </string>
<string name="scan_topic_dialog_title"> </string>
<string name="skip_scan_topic"> </string>
<string name="no_files_selected"> .</string>
<string name="action_pdfexport"> PDF</string>
<string name="googleplay_donation_summary"> Google Play, </string>
<string name="reward_ad_summary"> , Open Note Scanner . , .</string>
<string name="reward_ad_title"> </string>
<string name="privacy_policy"> </string>
<string name="close"></string>
<string name="donation_pending"> </string>
<string name="custom_scan_topic_summary"> </string>
<string name="standard_tags"> </string>
<string name="done"></string>
<string name="scan_topic_placeholder"> </string>
</resources>
``` | /content/code_sandbox/app/src/main/res/values-el/strings.xml | xml | 2016-02-10T11:14:38 | 2024-08-14T18:33:50 | OpenNoteScanner | allgood/OpenNoteScanner | 1,332 | 1,149 |
```xml
/*
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
import dmskmap = require( './index' );
/**
* Unary callback.
*
* @param x - input value
* @returns result
*/
function unary( x: number ): number {
return x;
}
// TESTS //
// The function returns a Float64Array...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap( x.length, x, 1, m, 1, y, 1, unary ); // $ExpectType Float64Array
}
// The compiler throws an error if the function is provided a first argument which is not a number...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap( '10', x, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( true, x, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( false, x, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( null, x, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( undefined, x, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( [], x, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( {}, x, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( ( x: number ): number => x, x, 1, m, 1, y, 1, unary ); // $ExpectError
}
// The compiler throws an error if the function is provided a second argument which is not a Float64Array...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap( x.length, 10, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, '10', 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, true, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, false, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, null, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, undefined, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, [ '1' ], 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, {}, 1, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, ( x: number ): number => x, 1, m, 1, y, 1, unary ); // $ExpectError
}
// The compiler throws an error if the function is provided a third argument which is not a number...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap( x.length, x, '10', m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, true, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, false, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, null, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, undefined, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, [], m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, {}, m, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, ( x: number ): number => x, m, 1, y, 1, unary ); // $ExpectError
}
// The compiler throws an error if the function is provided a fourth argument which is not a Uint8Array...
{
const x = new Float64Array( 10 );
const y = new Float64Array( 10 );
dmskmap( x.length, x, 1, 10, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, '10', 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, true, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, false, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, null, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, undefined, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, [ '1' ], 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, {}, 1, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, ( x: number ): number => x, 1, y, 1, unary ); // $ExpectError
}
// The compiler throws an error if the function is provided a fifth argument which is not a number...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap( x.length, x, 1, m, '10', y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, true, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, false, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, null, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, undefined, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, [], y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, {}, y, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, ( x: number ): number => x, y, 1, unary ); // $ExpectError
}
// The compiler throws an error if the function is provided a sixth argument which is not a Float64Array...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
dmskmap( x.length, x, 1, m, 1, 10, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, '10', 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, true, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, false, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, null, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, undefined, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, [ '1' ], 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, {}, 1, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, ( x: number ): number => x, 1, unary ); // $ExpectError
}
// The compiler throws an error if the function is provided a seventh argument which is not a number...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap( x.length, x, 1, m, 1, y, '10', unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, true, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, false, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, null, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, undefined, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, [], unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, {}, unary ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, ( x: number ): number => x, unary ); // $ExpectError
}
// The compiler throws an error if the function is provided an eighth argument which is not a unary function...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap( x.length, x, 1, m, 1, y, 1, '10' ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, 1, 0 ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, 1, true ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, 1, false ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, 1, null ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, 1, undefined ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, 1, [] ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, 1, {} ); // $ExpectError
}
// The compiler throws an error if the function is provided an unsupported number of arguments...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap(); // $ExpectError
dmskmap( x.length ); // $ExpectError
dmskmap( x.length, x ); // $ExpectError
dmskmap( x.length, x, 1 ); // $ExpectError
dmskmap( x.length, x, 1, m ); // $ExpectError
dmskmap( x.length, x, 1, m, 1 ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, 1 ); // $ExpectError
dmskmap( x.length, x, 1, m, 1, y, 1, unary, 10 ); // $ExpectError
}
// Attached to main export is an `ndarray` method which returns a Float64Array...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectType Float64Array
}
// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap.ndarray( '10', x, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( true, x, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( false, x, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( null, x, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( undefined, x, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( [], x, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( {}, x, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( ( x: number ): number => x, x, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a second argument which is not a Float64Array...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap.ndarray( x.length, 10, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, '10', 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, true, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, false, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, null, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, undefined, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, [ '1' ], 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, {}, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, ( x: number ): number => x, 1, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a third argument which is not a number...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap.ndarray( x.length, x, '10', 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, true, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, false, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, null, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, undefined, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, [], 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, {}, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, ( x: number ): number => x, 0, m, 1, 0, y, 1, 0, unary ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap.ndarray( x.length, x, 1, '10', m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, true, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, false, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, null, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, undefined, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, [], m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, {}, m, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, ( x: number ): number => x, m, 1, 0, y, 1, 0, unary ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a Uint8Array...
{
const x = new Float64Array( 10 );
const y = new Float64Array( 10 );
dmskmap.ndarray( x.length, x, 1, 0, 10, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, '10', 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, true, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, false, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, null, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, undefined, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, [ '1' ], 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, {}, 1, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, ( x: number ): number => x, 1, 0, y, 1, 0, unary ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a number...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap.ndarray( x.length, x, 1, 0, m, '10', 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, true, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, false, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, null, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, undefined, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, [], 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, {}, 0, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, ( x: number ): number => x, 0, y, 1, 0, unary ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap.ndarray( x.length, x, 1, 0, m, 1, '10', y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, true, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, false, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, null, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, undefined, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, [], y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, {}, y, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, ( x: number ): number => x, y, 1, 0, unary ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided an eighth argument which is not a Float64Array...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, 10, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, '10', 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, true, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, false, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, null, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, undefined, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, [ '1' ], 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, {}, 1, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, ( x: number ): number => x, 1, 0, unary ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a ninth argument which is not a number...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, '10', 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, true, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, false, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, null, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, undefined, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, [], 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, {}, 0, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, ( x: number ): number => x, 0, unary ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a tenth argument which is not a number...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, '10', unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, true, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, false, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, null, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, undefined, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, [], unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, {}, unary ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, ( x: number ): number => x, unary ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided an eleventh argument which is not a unary function...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0, '10' ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0, 0 ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0, true ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0, false ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0, null ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0, undefined ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0, [] ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0, {} ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
{
const x = new Float64Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float64Array( 10 );
dmskmap.ndarray(); // $ExpectError
dmskmap.ndarray( x.length ); // $ExpectError
dmskmap.ndarray( x.length, x ); // $ExpectError
dmskmap.ndarray( x.length, x, 1 ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0 ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1 ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0 ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1 ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
dmskmap.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0, unary, 10 ); // $ExpectError
}
``` | /content/code_sandbox/lib/node_modules/@stdlib/strided/base/dmskmap/docs/types/test.ts | xml | 2016-03-24T04:19:52 | 2024-08-16T09:03:19 | stdlib | stdlib-js/stdlib | 4,266 | 7,637 |
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!--
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
path_to_url
Unless required by applicable law or agreed to in writing,
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
specific language governing permissions and limitations
-->
<project xmlns="path_to_url"
xmlns:xsi="path_to_url"
xsi:schemaLocation="path_to_url
path_to_url">
<modelVersion>4.0.0</modelVersion>
<groupId>org.apache.guacamole</groupId>
<artifactId>extensions</artifactId>
<packaging>pom</packaging>
<version>1.5.5</version>
<name>extensions</name>
<url>path_to_url
<parent>
<groupId>org.apache.guacamole</groupId>
<artifactId>guacamole-client</artifactId>
<version>1.5.5</version>
<relativePath>../</relativePath>
</parent>
<modules>
<!-- Authentication extensions -->
<module>guacamole-auth-ban</module>
<module>guacamole-auth-duo</module>
<module>guacamole-auth-header</module>
<module>guacamole-auth-jdbc</module>
<module>guacamole-auth-json</module>
<module>guacamole-auth-ldap</module>
<module>guacamole-auth-quickconnect</module>
<module>guacamole-auth-sso</module>
<module>guacamole-auth-totp</module>
<!-- Additional features -->
<module>guacamole-history-recording-storage</module>
<module>guacamole-vault</module>
<!-- Utility extensions -->
<module>guacamole-display-statistics</module>
</modules>
<build>
<plugins>
<!-- Copy dependencies prior to packaging -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>3.1.2</version>
<executions>
<execution>
<id>copy-runtime-dependencies</id>
<phase>prepare-package</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<includeScope>runtime</includeScope>
<outputDirectory>${project.build.directory}/classes</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>
<!-- Automatically generate LICENSE and NOTICE -->
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<executions>
<execution>
<id>generate-license-files</id>
<phase>generate-resources</phase>
</execution>
</executions>
</plugin>
<!-- Verify that SLF4J is *NEVER* bundled within extensions (it
will conflict with the version bundled with the webapp) -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-enforcer-plugin</artifactId>
<executions>
<execution>
<id>never-bundle-slf4j</id>
<configuration>
<rules>
<bannedDependencies>
<excludes>
<exclude>org.slf4j:*:*:*:compile</exclude>
<exclude>org.slf4j:*:*:*:runtime</exclude>
</excludes>
</bannedDependencies>
</rules>
</configuration>
<goals>
<goal>enforce</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<!-- SLF4J is always available via the webapp -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>
<profiles>
<!-- Build extensions with LGPL-licensed dependencies only if explicitly requested -->
<profile>
<id>lgpl-extensions</id>
<modules>
<module>guacamole-auth-radius</module>
</modules>
</profile>
</profiles>
</project>
``` | /content/code_sandbox/extensions/pom.xml | xml | 2016-03-22T07:00:06 | 2024-08-16T13:03:48 | guacamole-client | apache/guacamole-client | 1,369 | 975 |
```xml
export class Rect {
x: number;
y: number;
width: number;
height: number;
constructor(x: number, y: number, width: number, height: number) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
containsPoint(x: number, y: number) {
return (
x >= this.x &&
y >= this.y &&
x <= this.x + this.width &&
y <= this.y + this.height
);
}
}
``` | /content/code_sandbox/packages/base/src/Slider/components/Rect.tsx | xml | 2016-09-08T14:21:41 | 2024-08-16T10:11:29 | react-native-elements | react-native-elements/react-native-elements | 24,875 | 120 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.