npmpackage.info

Gathering detailed insights and metrics for gettext-extractor-svelte

gettext-extractor-svelte - 5.1.0 | npmpackage.info

gettext-extractor-svelte

5.1.0

MIT

TypeScript

1.05 MB

4,632 1.7

Installations

npm install gettext-extractor-svelte

Developer Guide

BETA

Typescript

Yes

Module System

CommonJS

Node Version

20.7.0

NPM Version

10.1.0 Score

68.6

Supply Chain

96.8

Quality

74.2

Maintenance

100

Vulnerability

98.2

License

Pull Requests

Open

0

Total

1

Closed

1

Issues

Open

0

Total

1

Closed

1

Releases

v5.1.0

Updated on Oct 05, 2023

View All 1 releases

Languages

TypeScript

JavaScript

Svelte

Shell

TypeScript (99.19%)

JavaScript (0.52%)

Svelte (0.25%)

Shell (0.04%)

Developer

floratmin

Download Statistics

Total Downloads

4,632

Last Day

Last Week

Last Month

Last Year

570

GitHub Statistics

MIT License

4 Stars

63 Commits

1 Forks

2 Watchers

1 Branches

2 Contributors

Updated on Mar 16, 2023

Bundle Size

3.71 MB

Minified

1.05 MB

Minified + Gzipped

Bundlephobia

Maintainers

View All 2 Contributors

Package Meta Information

Latest Version

5.1.0

Package Id

gettext-extractor-svelte@5.1.0

Unpacked Size

123.17 kB

Size

20.92 kB

File Count

NPM Version

10.1.0

Node Version

20.7.0

Published on

Oct 05, 2023

Total Downloads

Cumulative downloads

Total Downloads

4,632

Dependencies

@floratmin/svelte-fragment-divider gettext-extractor pofile svelte

Dev Dependencies

@types/jest @typescript-eslint/eslint-plugin @typescript-eslint/parser eslint eslint-config-airbnb-typescript eslint-config-prettier eslint-plugin-prettier husky jest lint-staged prettier ts-jest ts-node typescript

gettext-extractor for svelte files

This extractor extracts also all the called functions and the function definition into a separate dictionary.

Installation

npm install gettext-extractor-svelte

Usage:

1import {
2    SvelteGettextExtractor, 
3    callExpressionExtractor, 
4    ICustomJsExtractorOptions,
5    FunctionExtractorBuilder
6} from 'gettext-extractor-svelte';
7
8const extractor = new SvelteGettextExtractor();
9const functionExtractor = new FunctionExtractorBuilder();
10const findTranslationClassExpression = functionExtractor.variableDeclaration(
11    'Foo', functionExtractor.classExpression(undefined, [
12        functionExtractor.methodDeclaration('bar', true)
13    ])
14);
15
16const options: ICustomJsExtractorOptions = {
17    arguments: {
18        text: 0,
19        context: 1,
20        comments: 2
21    },
22    comments: {
23        commentString: 'comment',
24        props: {
25            props: ['{', '}']
26        }
27    },
28    identifierKeys: ['text', 'context'],
29    translatorFunction: {
30        functionExtractor: findTranslationClassExpression,
31        identifier: 'translatorFunction',
32        restrictToFile: './src/translator.ts'
33    }
34}
35
36extractor.createSvelteParser()
37    .addExtractor(callExpressionExtractor('t', options))
38    .parseFilesGlob('./src/**/*.svelte');
39
40const messages = extractor.getMessages();
41const functionDict = extractor.getFunctions();
42const messageDict = extractor.getMessageDictionary();

From the following svelte file named src/App.svelte:

1<script lang="ts">
2    import { t } from './translator-function';
3    import Component from './Component.svelte';
4    export let place: string;
5    let caption = t(
6        'FooCaption', 
7        'Context', 
8        {comment: 'Comment', path: 'https://www.example.com'}
9    );
10</script>
11
12<body>
13    <h1>{caption}</h1>
14    <p>{t('Foo')}</p>
15    {#each [t('Bar'), t('Baz')] as text}
16        <p>{text}</p>
17        <Component label="{t('Bax', 'Context', {comment: 'Comment'})}">
18            {t(
19                'Hello {PLACE}', 
20                'Context', 
21                { 
22                    comment: 'Multiline\nComment', 
23                    props: {PLACE: 'The place where you are'},
24                    messageformat: 'This could be a messageformat function'
25                },
26                {PLACE: place}
27            )}
28        </Component>
29    {/each}
30</body>

and the following translation function in file src/translator.ts:

1let foo = class Bar {
2    bar(translationObject: any) {
3        return 'I am translated';
4    }
5}

we extract the following messages:

1[
2    {
3        text: 'FooCaption',
4        context: 'Context',
5        comments: [
6            'Comment',
7            'path: https://www.example.com'
8        ],
9        references: [
10            'src/App.svelte:5'
11        ],
12    },
13    {
14        text: 'Foo',
15        references: [
16            'src/App.svelte:14'
17        ],
18    },
19    {
20        text: 'Bar',
21        references: [
22            'src/App.svelte:15'
23        ],
24    },
25    {
26        text: 'Baz',
27        references: [
28            'src/App.svelte:15'
29        ],
30    },
31    {
32        text: 'Bax',
33        context: 'Context',
34        comments: [
35            'Comment',
36        ],
37        references: [
38            'src/App.svelte:17'
39        ],
40    },
41    {
42        text: 'Hello {PLACE}',
43        context: 'Context',
44        comments: [
45            'Multiline',
46            'Comment',
47            'messageformat: This could be a messageformat function',
48            '{PLACE}: The place where you are'
49        ],
50        references: [
51            'src/App.svelte:18'
52        ],
53    },
54]

the following functions:

1{
2    'src/App.svelte': [
3        {
4            functionString: `_(
5        'FooCaption',
6        'Context',
7        {comment: 'Comment', path: 'https://www.example.com'}
8    )`,
9            functionData: {
10                functionName: '_',
11                functionArgs: []
12            },
13            identifier: '{"text":"FooCaption","context":"Context"}',
14            startChar: 162,
15            endChar: 273
16        },                
17        {
18            functionString: "_('Foo')",
19            functionData: {
20                functionName: '_',
21                functionArgs: []
22            },
23            identifier: '{"text":"Foo"}',
24            startChar: 324,
25            endChar: 332
26        },
27        {
28            functionString: "_('Bar')",
29            functionData: {
30                functionName: '_',
31                functionArgs: []
32            },
33            identifier: '{"text":"Bar"}',
34            startChar: 350,
35            endChar: 358
36        },
37        {
38            functionString: "_('Baz')",
39            functionData: {
40                functionName: '_',
41                functionArgs: []
42            },
43            identifier: '{"text":"Baz"}',
44            startChar: 360,
45            endChar: 368
46        },
47        {
48            functionString: "_('Bax')",
49            functionData: {
50                functionName: '_',
51                functionArgs: []
52            },
53            identifier: '{"text":"Bax"}',
54            startChar: 428,
55            endChar: 436
56        },
57        {
58            functionString: `_(
59                'Hello {PLACE}',
60                'Context',
61                {
62                    comment: 'Multiline\\nComment',
63                    props: {PLACE: 'The place where you are'},
64                    messageformat: 'This could be a messageformat function'
65                },
66                {PLACE: place}
67            )`,
68            functionData: {
69                functionName: '_',
70                functionArgs: ['{PLACE: place}']
71            },
72            identifier: '{"text":"Hello {PLACE}","context":"Context"}',
73            startChar: 486,
74            endChar: 820
75        } 
76    ],
77    'src/translator.ts': [
78        {
79            functionString:
80`bar(translationObject: any) {
81        return 'I am translated';
82    }`,
83            identifier: 'translatorFunction',
84            definition: true, // marks that this entry is an extracted translation function
85            startChar: 26,
86            endChar: 95
87        }
88    ]
89}

and the mapping of identifiers to text as an object

1{
2    '{"text":"Foo"}': 'Foo',
3    '{"text":"Bar"}': 'Bar',
4    '{"text":"Baz"}': 'Baz',
5    '{"text":"Bax"}': 'Bax',
6    '{"text":"FooCaption","context":"Context"}': 'FooCaption',
7    '{"text":"Hello {PLACE}","context":"Context"}': 'Hello {PLACE}'
8}
9

Additional methods for SvelteGettextExtractor

`createSvelteParser()`

Create parser for parsing .svelte files

Return Value

SvelteParser · Can be used in the same way as parser created with createJsParser(), except the following added parse option:

Name	Type	Details
`options`	object	Additional parse option
`translatorFunctions`	TTranslatorFunction \| TTranslatorFunction[]	Translation Function Definition to extract functions.

`getFunctions()`

Gets all parsed function calls

Return Value

object · Dictionary with keys of file name and values of a list of function objects with properties as described below

Name	Type	Details
`functionString`	string	String of the function call in the source code
`functionData`	object	Object containing keys functionName and functionArgs
→ `functionName`	string	Name of the called function
→ `functionArgs`	string[]	Arguments without arguments defining text, textPlural, context and comment
`identifier`	string	Identifier string constructed trough options.identifierKeys
`definition`	true	When set marks that string is part of translation function definition
`startChar`	number	Index where the function call string starts
`endChar`	number	Index where the function call string ends

`getLastAddedFunctions()`

Receive array of functions, which got added in the last call of parseJsString, parseSvelteString.

Return Value

array · Same as values of dictionary described in getFunctions()

`getFunctionsByFileName(fileName)`

Gets all parsed function calls in a file

Parameters

Name	Type	Details
`fileName`	string	Required · Name of file

Return Value

array · Same as values of dictionary described in getFunctions()

`saveFunctionJSON(fileName)`

Save functions dictionary as a JSON file.

Parameters

Name	Type	Details
`fileName`	string	Required · Name of file

Return Value

void

`saveFunctionJSONAsync(fileName)`

Save functions dictionary as a JSON file asynchronously.

Parameters

Name	Type	Details
`fileName`	string	Required · Name of file

Return Value

Promise

`getMessageDictionary()`

Recieve a dictionary mapping message text to function identifiers.

Return Value

object · Dictionary with identifier strings as keys and message text as value

`getMessagesWithId()`

Recieve array of messages with identifier.

Return Value

Name	Type	Details
`text`	string	Message string
`textPlural`	string	Plural version of the message string
`context`	string	Message context
`references`	string[]	Array of file references where the message was extracted from
`comments`	string[]	Array of comments for this message
`identifier`	string	Identifier string constructed trough options.identifierKeys

`getLastAddedMessages()`

Receive array of messages with identifier, which got added in the last call of parseJsString, parseSvelteString or parseHtmlString.

Return Value

array · List of message objects (same properties as for getMessagesWithId())

`getTransformedMessages<T = any>(func: (messages: IMessage[]) => T)`

Transform message object with custom function.

Parameters

Name	Type	Details
`func`	(messages: IMessage[]) => T	Required · Transformer function

Return Value

T · Depends on your function

For all other available options please look at the package gettext-extractor

JS Parser for gettext-extractor

Extract comments provided by a string or an object in the translator function.

1import { callExpressionExtractor, ICustomJsExtractorOptions } 
2    from 'gettext-extractor-svelte';
3import { GettextExtractor } from 'gettext-extractor'; // Works also with SvelteGettextExtractor
4
5const options: ICustomJsExtractorOptions = {
6    arguments: {
7        text: 0,
8        textPlural: 1,
9        comments: 2,
10        context: 3,
11    },
12    comments: {
13        commentString: 'comment',
14        props: {
15            props: ['{', '}']
16        }
17    }
18};
19
20const extractor = new GettextExtractor();
21
22extractor
23    .createJsParser()
24    .addExtractor(callExpressionExtractor('_', options))
25    .parseFilesGlob('src/**/*.@(ts|js|tsx|jsx)');

`callExpressionExtractor(calleeName, options)`

Parameters

Name	Type	Details
`calleeName`	string or string[]	Required · Name(s) of the function(s)
`options`	object	Options to configure the extractor function
→ `arguments`	object	Required · See Argument Mapping below
→ `comments`	object	See Comment Options below
→ `identifierKeys`	<'text' \| 'textPlural' \| 'context'>[]	Fields for constructing ids to map messages to functions, defaults to all. At least one of these keys should match each message function. Defaults to `['text', 'context']`
→ `translatorFunction`	object	See Translator Function Options below
→ `content`	object	See Content Options below

Argument Mapping

Name	Type	Details
`text`	number	Required · Position of the argument containing the message text
`textPlural`	number	Position of the argument containing the plural message text
`context`	number	Position of the argument containing the message context
`comments`	number	Position of the argument containing the comments string or object

Comment Options

If ommitted the comment is expected to be a string. If fallback is true, the comment has to be an object, otherwise it can be a string or an object.

Name	Type	Default	Details
`commentString`	string	`comment`	Key for providing plain comments
`props`	object		Each key under `props` has a value of an array with two strings. In the comment object we can provide key value pairs under each key defined under `props`. Each of these keys gets wrapped in between the provided two strings. Then after a semicolon the value is concatenated.
`throwWhenMalformed`	boolean	`true`	If set to `true`, throws an error when in the comment object any value is not a plain string
`fallback`	boolean	`false`	If set to `true`, an omitted argument fallbacks to the next argument if the next argument is of different type

If not trough commentString or props specified keys are used in the comment object, then these keys (concatenated with dots when they are nested) are added to the comments with a semicolon followed by the value of the key.

Content Options

Name	Type	Default	Details
`trimWhiteSpace`	boolean	`false`	If set to `true`, white space at the very beginning and at the end of the content will get removed Normally this behaves like `.trim()`, however if `preseveIndentation` is `true`, the indentation of the first line is kept as well.
`preserveIndentation`	boolean	`true`	If set to `false`, white space at the beginning of the line will get removed
`replaceNewLines`	false or string	`false`	If a string is provided all new lines will be replaced with it

Function Extractor Options

Name	Type	Details
`functionExtractor`	FunctionExtractor	The function extractor describing the typescript nodes of the function to extract
`identifier`	string	The identifier under which the function will be added to the dict
`restrictToFile`	string	When set than only the specified file will be parsed for the function

Return Value

function · An extractor function that extracts messages from call expressions.

Example

With the example settings from the usage example and the following functions

1// We can provide comments as string
2const string1 = _(
3    'Foo',
4    'Plural',
5    'Comment',
6    'Context'
7);
8// Or we can provide comments as object
9const string2 = _(
10    'Hello {PLACE}',
11    'Plural',
12    {
13        comment: 'Comment',
14        props: {
15            PLACE: 'The place of interest'
16        },
17        path: 'https://www.example.com',
18        nested: {
19            key1: 'Key1',
20            key2: 'Key2'
21        }
22    }
23);
24// When type of argument does not match declared type, then all following arguments are ignored
25const string3 = _(
26    'Foo2',
27    {
28        comment: 'Comment'
29    },
30    'Context'
31)
32// We can omit empty arguments with `null`, `undefined` or `0`
33const string4 = _(
34    'Foo3',
35    null,
36    null,
37    'Context'
38);

We extract the following messages

1[
2    {
3        text: 'Foo',
4        textPlural: 'Plural',
5        coments: ['Comment'],
6        context: 'Context'
7    },
8    {
9        text: 'Hello {PLACE}',
10        textPlural: 'Plural',
11        comments: [
12            'Comment',
13            'path: https://www.example.com',
14            '{PLACE}: The place of interest',
15            'nested.key1: Key1',
16            'nested.key2: Key2'
17        ]
18    },
19    {
20        text: 'Foo2'
21    },
22    {
23        text: 'Foo3',
24        context: 'Context'
25    }
26]

If we have the option fallback: true set:

1const options: ICustomJsExtractorOptions = {
2    arguments: {
3        text: 0,
4        textPlural: 1,
5        comments: 2,
6        context: 3,
7    },
8    comments: {
9        commentString: 'comment',
10        props: {
11            props: ['{', '}']
12        },
13        fallback: true
14    }
15};
16

and the following functions

1const string1 = (worldPlace: string) => _(
2    'Hello {PLACE}', 
3    'Plural', 
4    {
5        comment: 'Comment', 
6        props: {
7            PLACE: 'The place of interest'
8        }, 
9        path: 'http://www.example.com', 
10        nested: {
11            key1: 'Key1',
12            key2: 'Key2'
13        }
14    },
15    'Context',
16    {
17        PLACE: worldPlace
18    }
19);
20// when omitting the second argument the third argument can take the place of the second argument 
21// if the arguments are of different type. If there are more arguments, they also change their
22// place accordingly.
23const string2 = _(
24    'Foo',
25    {
26        comment: 'No Plural here.'
27    }
28);
29// omit comment object
30const string3 = _(
31    'Foo2',
32    'Plural',
33    'Context'
34);
35// skip textPlural and comment object, allowed placeholders are `null`, `undefined` or `0`
36const string4 = _(
37    'Foo3',
38    null,
39    null,
40    'Context'
41);
42// if argument is not string or comment object than rest of arguments are ignored
43const string5 = (props: {PROPS: string}) => _(
44    'My {PROPS}',
45    {
46        props: {
47            PROPS: 'Some props'
48        }
49    },
50    props
51);

we extract the following messages

1[
2    {
3        text: 'Hello {PLACE}',
4        textPlural: 'Plural',
5        comments: [
6            'Comment',
7            'path: http://www.example.com',
8            '{PLACE}: The place of interest',
9            'nested.key1: Key1',
10            'nested.key2: Key2'
11        ],
12        context: 'Context'
13    },
14    {
15        text: 'Foo',
16        comments: [
17            'No Plural here.'
18        ],
19    },
20    {
21        text: 'Foo2',
22        textPlural: 'Plural',
23        context: 'Context'
24    },
25    {
26        text: 'Foo3',
27        context: 'Context'
28    },
29    {
30        text: 'My {PROPS}',
31        comments: [
32            '{PROPS}: Some props'
33        ]
34    }
35]

If any argument is not a string or comment object then the parsing is cut off starting from this argument. If there are other arguments in between these arguments, their position is not considered in the fallback.

JS Node Parser for gettext-extractor

Extracts nodes provided by TTranslatorFunction or by providing TTranslatorFunction[] on each .parseString or .parseSvelteString method call.

1import { nodeExtractor, TTranslatorFunction, FunctionExtractorBuilder, SvelteGettextExtractor } from 'gettext-extractor-svelte';
2
3const functionExtractor = new FunctionExtractorBuilder();
4const importDeclaration = functionExtractor.importDeclaration(
5    './translations',
6    functionExtractor.importClause(
7        't'
8    ),
9    true,
10);
11
12const translatorFunctions: TTranslatorFunction[] = [
13    {
14        identifier: 'translationFunctionImport',
15        functionName: 't',
16        functionExtractor: importDeclaration
17    }
18];
19
20const extractor = new SvelteGettextExtractor();
21
22extractor.createJsParser()
23    .addExtractor(nodeExtractor())
24    .parseString('import t from "./translations";', 'src/app.js', {translatorFunctions});
25
26extractor.getFunctions() === {
27    'src/app.js': [
28        {
29            functionString: 'import t from "./translations";',
30            functionData: {
31                functionName: 't',
32                functionArgs: []
33            },
34            startChar: 0,
35            endChar: 31,
36            identifier: 'translationFunctionImport',
37            definition: true
38        }
39    ]
40}; // true

`nodeExtractor(translatorFunction)`

Parameters

Name	Type	Details
`translatorFunction`	TTranslatorFunction or TTranslatorFunction[]	See Translator Function Options below

Function Extractor Options

Name	Type	Details
`functionExtractor`	FunctionExtractor	The function extractor describing the typescript nodes of the function to extract
`identifier`	string	The identifier under which the function will be added to the dict
`restrictToFile`	string	When set than only the specified file will be parsed for the function

Function Extractor Builder

1import {
2    FunctionExtractorBuilder
3} from 'gettext-extractor-svelte';
4
5const functionExtractor = new FunctionExtractorBuilder();

Methods for FunctionExtractorBuilder

`objectLiteralExpression(properties?, getPos?)`

Marks object literal expressions

Parameters

Name	Type	Default	Details
`properties`	FunctionExtractor []		List of function extractors defining the properties of the object
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`variableDeclaration(variableName, initializer?, getPos?)`

Marks variable declarations

Parameters

Name	Type	Default	Details
`variableName`	string		Required · Name of declared variable
`initializer`	FunctionExtractor		Function extractor defining the initializer
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`propertyAssignment(keyName, initializer?, getPos?)`

Marks property assignment

Parameters

Name	Type	Default	Details
`keyName`	string		Required · Name of property
`initializer`	FunctionExtractor		Function extractor defining the initializer
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`methodDeclaration(methodName, getPos?)`

Marks method declaration

Parameters

Name	Type	Default	Details
`methodName`	string		Required · Name of method
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`arrowFunction(getPos?)`

Marks arrow function

Parameters

Name	Type	Default	Details
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`propertyDeclaration(propertyName, initializer?, getPos?)`

Marks property declaration

Parameters

Name	Type	Default	Details
`propertyName`	string		Required · Name of property
`properties`	FunctionExtractor		Function extractor defining the initializer
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`functionDeclaration(functionName, getPos?)`

Marks function declaration

Parameters

Name	Type	Default	Details
`functionName`	string		Required · Name of function declaration
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`functionExpression(functionName?, getPos?)`

Marks function expression

Parameters

Name	Type	Default	Details
`functionName`	string		Name of function expression
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`classDeclaration(className, members?, getPos?)`

Marks class declarations

Parameters

Name	Type	Default	Details
`className`	string		Required · Name of class
`members`	FunctionExtractor[]		Array of function extractors defining the members of the class
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`classExpression(className?, members?, getPos?)`

Marks class expression

Parameters

Name	Type	Default	Details
`className`	string		Name of class
`members`	FunctionExtractor[]		Array of function extractors defining the members of the class
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`getAccessor(accessorName, body?, getPos?)`

Marks get accessor

Parameters

Name	Type	Default	Details
`accessorName`	string		Required · Name of accessor
`body`	FunctionExtractor		Function extractor defining the body of the get accessor
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`setAccessor(accessorName, body?, getPos?)`

Marks set accessor

Parameters

Name	Type	Default	Details
`accessorName`	string		Required · Name of accessor
`body`	FunctionExtractor		Function extractor defining the body of the set accessor
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`expressionStatement(identifier, right?, getPos?)`

Marks expression statement

Parameters

Name	Type	Default	Details
`identifier`	string		Required · Name of identifier on the left side of expression statement
`right`	FunctionExtractor		Function extractor defining the right side of the expression statement
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`labeledStatement(statement?, getPos?)`

Marks labeled statement

Parameters

Name	Type	Default	Details
`statement`	FunctionExtractor		Function extractor for defining the right side of the labeled statement
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`importDeclaration(moduleSpecifier, importClause?, getPos?)`

Marks import declaration

Parameters

Name	Type	Default	Details
`moduleSpecifier`	string		Required · Name of module imported in this declaration
`importClause`	FunctionExtractor		Function extractor defining the import clause
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`importClause(name?, elements?, getPos?)`

Marks import clause

Parameters

Name	Type	Default	Details
`name`	string		Name of main import in this clause
`elements`	FunctionExtractor[]		List of function extractors defining the imported elements
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`importSpecifier(name, getPos?)`

Marks import specifier

Parameters

Name	Type	Default	Details
`name`	string		Name of import in this specifier
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`variableStatment(declarations?, getPos?)`

Marks variable statement

Parameters

Name	Type	Default	Details
`declarations`	FunctionExtractor[]		List of variable declared in this statement
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

`newExpression(name, getPos?)`

Marks new expression

Parameters

Name	Type	Default	Details
`name`	string		Name of new expression
`getPos`	boolean	`false`	Return start and end position in call expression to extract node as string

Return Value

FunctionExtractor

No vulnerabilities found.

10

Binary-Artifacts

Determines if the project has generated executable (binary) artifacts in the source repository.

10

License

Determines if the project has defined a license.

0

Maintained

Determines if the project is "actively maintained".

0

Code-Review

Determines if the project requires human code review before pull requests (aka merge requests) are merged.

0

SAST

Determines if the project uses static code analysis.

0

CII-Best-Practices

Determines if the project has an OpenSSF (formerly CII) Best Practices Badge.

0

Security-Policy

Determines if the project has published a security policy.

0

Fuzzing

Determines if the project uses fuzzing.

0

Branch-Protection

Determines if the default and release branches are protected with GitHub's branch protection settings.

0

Vulnerabilities

Determines if the project has open, known unfixed vulnerabilities.

Score

1.7

/10

Last Scanned on 2025-06-30

The Open Source Security Foundation is a cross-industry collaboration to improve the security of open source software (OSS). The Scorecard provides security health metrics for open source projects.

Learn More